lael-labs/linux

Documentation/admin-guide/pm/intel_pstate.rst+12−2

 ``intel_pstate`` exposes several global attributes (files) in ``sysfs`` to
 control its functionality at the system level.  They are located in the
-``/sys/devices/system/cpu/cpufreq/intel_pstate/`` directory and affect all
+``/sys/devices/system/cpu/intel_pstate/`` directory and affect all CPUs.
-CPUs.
 Some of them are not present if the ``intel_pstate=per_cpu_perf_limits``
 argument is passed to the kernel in the command line.
 	but it affects the maximum possible value of per-policy P-state	limits
 	(see `Interpretation of Policy Attributes`_ below for details).
+``hwp_dynamic_boost``
+	This attribute is only present if ``intel_pstate`` works in the
+	`active mode with the HWP feature enabled <Active Mode With HWP_>`_ in
+	the processor.  If set (equal to 1), it causes the minimum P-state limit
+	to be increased dynamically for a short time whenever a task previously
+	waiting on I/O is selected to run on a given logical CPU (the purpose
+	of this mechanism is to improve performance).
+	This setting has no effect on logical CPUs whose minimum P-state limit
+	is directly set to the highest non-turbo P-state or above it.
 .. _status_attr:
 ``status``

Documentation/devicetree/bindings/input/sprd,sc27xx-vibra.txt+23−0

@@ -0,0 +1,23 @@
	1	Spreadtrum SC27xx PMIC Vibrator
	2
	3	Required properties:
	4	- compatible: should be "sprd,sc2731-vibrator".
	5	- reg: address of vibrator control register.
	6
	7	Example :
	8
	9	sc2731_pmic: pmic@0 {
	10	compatible = "sprd,sc2731";
	11	reg = <0>;
	12	spi-max-frequency = <26000000>;
	13	interrupts = <GIC_SPI 31 IRQ_TYPE_LEVEL_HIGH>;
	14	interrupt-controller;
	15	#interrupt-cells = <2>;
	16	#address-cells = <1>;
	17	#size-cells = <0>;
	18
	19	vibrator@eb4 {
	20	compatible = "sprd,sc2731-vibrator";
	21	reg = <0xeb4>;
	22	};
	23	};

Documentation/filesystems/Locking+1−6

 	int (*iterate) (struct file *, struct dir_context *);
 	int (*iterate_shared) (struct file *, struct dir_context *);
 	__poll_t (*poll) (struct file *, struct poll_table_struct *);
-	struct wait_queue_head * (*get_poll_head)(struct file *, __poll_t);
-	__poll_t (*poll_mask) (struct file *, __poll_t);
 	long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
 	long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
 	int (*mmap) (struct file *, struct vm_area_struct *);
 };
 locking rules:
-	All except for ->poll_mask may block.
+	All may block.
 ->llseek() locking has moved from llseek to the individual llseek
 implementations.  If your fs is not using generic_file_llseek, you
 the lease within the individual filesystem to record the result of the
 operation
-->poll_mask can be called with or without the waitqueue lock for the waitqueue
-returned from ->get_poll_head.
 --------------------------- dquot_operations -------------------------------
 prototypes:
 	int (*write_dquot) (struct dquot *);

Documentation/filesystems/vfs.txt+0−13

@@ -857,8 +857,6 @@ struct file_operations { · 856 unmodified lines
857	ssize_t (write_iter) (struct kiocb , struct iov_iter *);	857	ssize_t (write_iter) (struct kiocb , struct iov_iter *);
858	int (iterate) (struct file , struct dir_context *);	858	int (iterate) (struct file , struct dir_context *);
859	__poll_t (poll) (struct file , struct poll_table_struct *);	859	__poll_t (poll) (struct file , struct poll_table_struct *);
860	struct wait_queue_head * (get_poll_head)(struct file , __poll_t);
861	__poll_t (poll_mask) (struct file , __poll_t);
862	long (unlocked_ioctl) (struct file , unsigned int, unsigned long);	860	long (unlocked_ioctl) (struct file , unsigned int, unsigned long);
863	long (compat_ioctl) (struct file , unsigned int, unsigned long);	861	long (compat_ioctl) (struct file , unsigned int, unsigned long);
864	int (mmap) (struct file , struct vm_area_struct *);	862	int (mmap) (struct file , struct vm_area_struct *);
@@ -903,17 +901,6 @@ otherwise noted. · 38 unmodified lines
903	activity on this file and (optionally) go to sleep until there	901	activity on this file and (optionally) go to sleep until there
904	is activity. Called by the select(2) and poll(2) system calls	902	is activity. Called by the select(2) and poll(2) system calls
905		903
906	get_poll_head: Returns the struct wait_queue_head that callers can
907	wait on. Callers need to check the returned events using ->poll_mask
908	once woken. Can return NULL to indicate polling is not supported,
909	or any error code using the ERR_PTR convention to indicate that a
910	grave error occured and ->poll_mask shall not be called.
911
912	poll_mask: return the mask of EPOLL* values describing the file descriptor
913	state. Called either before going to sleep on the waitqueue returned by
914	get_poll_head, or after it has been woken. If ->get_poll_head and
915	->poll_mask are implemented ->poll does not need to be implement.
916
917	unlocked_ioctl: called by the ioctl(2) system call.	904	unlocked_ioctl: called by the ioctl(2) system call.
918		905
919	compat_ioctl: called by the ioctl(2) system call when 32 bit system calls	906	compat_ioctl: called by the ioctl(2) system call when 32 bit system calls

Documentation/kbuild/kconfig-language.txt+6−0

@@ -430,6 +430,12 @@ This sets the config program's title bar if the config program chooses · 429 unmodified lines
430	to use it. It should be placed at the top of the configuration, before any	430	to use it. It should be placed at the top of the configuration, before any
431	other statement.	431	other statement.
432		432
		433	'#' Kconfig source file comment:
		434
		435	An unquoted '#' character anywhere in a source file line indicates
		436	the beginning of a source file comment. The remainder of that line
		437	is a comment.
		438
433		439
434	Kconfig hints	440	Kconfig hints
435	-------------	441	-------------

Documentation/usb/gadget_configfs.txt+1−1

@@ -226,7 +226,7 @@ $ rm configs/<config name>.<number>/<function> · 225 unmodified lines
226	where <config name>.<number> specify the configuration and <function> is	226	where <config name>.<number> specify the configuration and <function> is
227	a symlink to a function being removed from the configuration, e.g.:	227	a symlink to a function being removed from the configuration, e.g.:
228		228
229	$ rm configfs/c.1/ncm.usb0	229	$ rm configs/c.1/ncm.usb0
230		230
231	...	231	...
232	...	232	...

MAINTAINERS+19−6

 N:	bcm586*
 N:	bcm88312
 N:	hr2
-F:	arch/arm64/boot/dts/broadcom/ns2*
+N:	stingray
+F:	arch/arm64/boot/dts/broadcom/northstar2/*
+F:	arch/arm64/boot/dts/broadcom/stingray/*
 F:	drivers/clk/bcm/clk-ns*
+F:	drivers/clk/bcm/clk-sr*
 F:	drivers/pinctrl/bcm/pinctrl-ns*
+F:	include/dt-bindings/clock/bcm-sr*
 BROADCOM KONA GPIO DRIVER
 M:	Ray Jui <rjui@broadcom.com>
 F:	Documentation/devicetree/bindings/crypto/fsl-sec4.txt
 FREESCALE DIU FRAMEBUFFER DRIVER
-M:	Timur Tabi <timur@tabi.org>
+M:	Timur Tabi <timur@kernel.org>
 L:	linux-fbdev@vger.kernel.org
 S:	Maintained
 F:	drivers/video/fbdev/fsl-diu-fb.*
 F:	drivers/net/wan/fsl_ucc_hdlc*
 FREESCALE QUICC ENGINE UCC UART DRIVER
-M:	Timur Tabi <timur@tabi.org>
+M:	Timur Tabi <timur@kernel.org>
 L:	linuxppc-dev@lists.ozlabs.org
 S:	Maintained
 F:	drivers/tty/serial/ucc_uart.c
 F:	include/linux/fs_enet_pd.h
 FREESCALE SOC SOUND DRIVERS
-M:	Timur Tabi <timur@tabi.org>
+M:	Timur Tabi <timur@kernel.org>
 M:	Nicolin Chen <nicoleotsuka@gmail.com>
 M:	Xiubo Li <Xiubo.Lee@gmail.com>
 R:	Fabio Estevam <fabio.estevam@nxp.com>
 S:	Obsolete
 F:	drivers/net/wireless/intersil/prism54/
+PROC FILESYSTEM
+R:	Alexey Dobriyan <adobriyan@gmail.com>
+L:	linux-kernel@vger.kernel.org
+L:	linux-fsdevel@vger.kernel.org
+S:	Maintained
+F:	fs/proc/
+F:	include/linux/proc_fs.h
+F:	tools/testing/selftests/proc/
 PROC SYSCTL
 M:	"Luis R. Rodriguez" <mcgrof@kernel.org>
 M:	Kees Cook <keescook@chromium.org>
 F:  drivers/cpufreq/qcom-cpufreq-kryo.c
 QUALCOMM EMAC GIGABIT ETHERNET DRIVER
-M:	Timur Tabi <timur@codeaurora.org>
+M:	Timur Tabi <timur@kernel.org>
 L:	netdev@vger.kernel.org
-S:	Supported
+S:	Maintained
 F:	drivers/net/ethernet/qualcomm/emac/
 QUALCOMM HEXAGON ARCHITECTURE

Makefile+1−6

 VERSION = 4
 PATCHLEVEL = 18
 SUBLEVEL = 0
-EXTRAVERSION = -rc2
+EXTRAVERSION = -rc3
 NAME = Merciless Moray
 # *DOCUMENTATION*
   KBUILD_AFLAGS += -DCC_HAVE_ASM_GOTO
 endif
-ifeq ($(shell $(CONFIG_SHELL) $(srctree)/scripts/cc-can-link.sh $(CC)), y)
-  CC_CAN_LINK := y
-  export CC_CAN_LINK
-endif
 # The expansion should be delayed until arch/$(SRCARCH)/Makefile is included.
 # Some architectures define CROSS_COMPILE in arch/$(SRCARCH)/Makefile.
 # CC_VERSION_TEXT is referenced from Kconfig (so it needs export),

arch/arm/Kconfig+7−1

 	  VESA. If you have PCI, say Y, otherwise N.
 config PCI_DOMAINS
-	bool
+	bool "Support for multiple PCI domains"
 	depends on PCI
+	help
+	  Enable PCI domains kernel management. Say Y if your machine
+	  has a PCI bus hierarchy that requires more than one PCI
+	  domain (aka segment) to be correctly managed. Say N otherwise.
+	  If you don't know what to do here, say N.
 config PCI_DOMAINS_GENERIC
 	def_bool PCI_DOMAINS

arch/arm/boot/dts/armada-385-synology-ds116.dts+1−1

@@ -139,7 +139,7 @@ · 138 unmodified lines
139	3700 5	139	3700 5
140	3900 6	140	3900 6
141	4000 7>;	141	4000 7>;
142	cooling-cells = <2>;	142	#cooling-cells = <2>;
143	};	143	};
144		144
145	gpio-leds {	145	gpio-leds {

arch/arm/boot/dts/bcm-cygnus.dtsi+12−12

@@ -216,7 +216,7 @@ · 215 unmodified lines
216	reg = <0x18008000 0x100>;	216	reg = <0x18008000 0x100>;
217	#address-cells = <1>;	217	#address-cells = <1>;
218	#size-cells = <0>;	218	#size-cells = <0>;
219	interrupts = <GIC_SPI 85 IRQ_TYPE_NONE>;	219	interrupts = <GIC_SPI 85 IRQ_TYPE_LEVEL_HIGH>;
220	clock-frequency = <100000>;	220	clock-frequency = <100000>;
221	status = "disabled";	221	status = "disabled";
222	};	222	};
@@ -245,7 +245,7 @@ · 22 unmodified lines
245	reg = <0x1800b000 0x100>;	245	reg = <0x1800b000 0x100>;
246	#address-cells = <1>;	246	#address-cells = <1>;
247	#size-cells = <0>;	247	#size-cells = <0>;
248	interrupts = <GIC_SPI 86 IRQ_TYPE_NONE>;	248	interrupts = <GIC_SPI 86 IRQ_TYPE_LEVEL_HIGH>;
249	clock-frequency = <100000>;	249	clock-frequency = <100000>;
250	status = "disabled";	250	status = "disabled";
251	};	251	};
@@ -256,7 +256,7 @@ · 4 unmodified lines
256		256
257	#interrupt-cells = <1>;	257	#interrupt-cells = <1>;
258	interrupt-map-mask = <0 0 0 0>;	258	interrupt-map-mask = <0 0 0 0>;
259	interrupt-map = <0 0 0 0 &gic GIC_SPI 100 IRQ_TYPE_NONE>;	259	interrupt-map = <0 0 0 0 &gic GIC_SPI 100 IRQ_TYPE_LEVEL_HIGH>;
260		260
261	linux,pci-domain = <0>;	261	linux,pci-domain = <0>;
262		262
@@ -278,10 +278,10 @@ · 15 unmodified lines
278	compatible = "brcm,iproc-msi";	278	compatible = "brcm,iproc-msi";
279	msi-controller;	279	msi-controller;
280	interrupt-parent = <&gic>;	280	interrupt-parent = <&gic>;
281	interrupts = <GIC_SPI 96 IRQ_TYPE_NONE>,	281	interrupts = <GIC_SPI 96 IRQ_TYPE_LEVEL_HIGH>,
282	<GIC_SPI 97 IRQ_TYPE_NONE>,	282	<GIC_SPI 97 IRQ_TYPE_LEVEL_HIGH>,
283	<GIC_SPI 98 IRQ_TYPE_NONE>,	283	<GIC_SPI 98 IRQ_TYPE_LEVEL_HIGH>,
284	<GIC_SPI 99 IRQ_TYPE_NONE>;	284	<GIC_SPI 99 IRQ_TYPE_LEVEL_HIGH>;
285	};	285	};
286	};	286	};
287		287
@@ -291,7 +291,7 @@ · 3 unmodified lines
291		291
292	#interrupt-cells = <1>;	292	#interrupt-cells = <1>;
293	interrupt-map-mask = <0 0 0 0>;	293	interrupt-map-mask = <0 0 0 0>;
294	interrupt-map = <0 0 0 0 &gic GIC_SPI 106 IRQ_TYPE_NONE>;	294	interrupt-map = <0 0 0 0 &gic GIC_SPI 106 IRQ_TYPE_LEVEL_HIGH>;
295		295
296	linux,pci-domain = <1>;	296	linux,pci-domain = <1>;
297		297
@@ -313,10 +313,10 @@ · 15 unmodified lines
313	compatible = "brcm,iproc-msi";	313	compatible = "brcm,iproc-msi";
314	msi-controller;	314	msi-controller;
315	interrupt-parent = <&gic>;	315	interrupt-parent = <&gic>;
316	interrupts = <GIC_SPI 102 IRQ_TYPE_NONE>,	316	interrupts = <GIC_SPI 102 IRQ_TYPE_LEVEL_HIGH>,
317	<GIC_SPI 103 IRQ_TYPE_NONE>,	317	<GIC_SPI 103 IRQ_TYPE_LEVEL_HIGH>,
318	<GIC_SPI 104 IRQ_TYPE_NONE>,	318	<GIC_SPI 104 IRQ_TYPE_LEVEL_HIGH>,
319	<GIC_SPI 105 IRQ_TYPE_NONE>;	319	<GIC_SPI 105 IRQ_TYPE_LEVEL_HIGH>;
320	};	320	};
321	};	321	};
322		322

arch/arm/boot/dts/bcm-hr2.dtsi+12−12

@@ -264,7 +264,7 @@ · 263 unmodified lines
264	reg = <0x38000 0x50>;	264	reg = <0x38000 0x50>;
265	#address-cells = <1>;	265	#address-cells = <1>;
266	#size-cells = <0>;	266	#size-cells = <0>;
267	interrupts = <GIC_SPI 95 IRQ_TYPE_NONE>;	267	interrupts = <GIC_SPI 95 IRQ_TYPE_LEVEL_HIGH>;
268	clock-frequency = <100000>;	268	clock-frequency = <100000>;
269	};	269	};
270		270
@@ -279,7 +279,7 @@ · 8 unmodified lines
279	reg = <0x3b000 0x50>;	279	reg = <0x3b000 0x50>;
280	#address-cells = <1>;	280	#address-cells = <1>;
281	#size-cells = <0>;	281	#size-cells = <0>;
282	interrupts = <GIC_SPI 96 IRQ_TYPE_NONE>;	282	interrupts = <GIC_SPI 96 IRQ_TYPE_LEVEL_HIGH>;
283	clock-frequency = <100000>;	283	clock-frequency = <100000>;
284	};	284	};
285	};	285	};
@@ -300,7 +300,7 @@ · 14 unmodified lines
300		300
301	#interrupt-cells = <1>;	301	#interrupt-cells = <1>;
302	interrupt-map-mask = <0 0 0 0>;	302	interrupt-map-mask = <0 0 0 0>;
303	interrupt-map = <0 0 0 0 &gic GIC_SPI 186 IRQ_TYPE_NONE>;	303	interrupt-map = <0 0 0 0 &gic GIC_SPI 186 IRQ_TYPE_LEVEL_HIGH>;
304		304
305	linux,pci-domain = <0>;	305	linux,pci-domain = <0>;
306		306
@@ -322,10 +322,10 @@ · 15 unmodified lines
322	compatible = "brcm,iproc-msi";	322	compatible = "brcm,iproc-msi";
323	msi-controller;	323	msi-controller;
324	interrupt-parent = <&gic>;	324	interrupt-parent = <&gic>;
325	interrupts = <GIC_SPI 182 IRQ_TYPE_NONE>,	325	interrupts = <GIC_SPI 182 IRQ_TYPE_LEVEL_HIGH>,
326	<GIC_SPI 183 IRQ_TYPE_NONE>,	326	<GIC_SPI 183 IRQ_TYPE_LEVEL_HIGH>,
327	<GIC_SPI 184 IRQ_TYPE_NONE>,	327	<GIC_SPI 184 IRQ_TYPE_LEVEL_HIGH>,
328	<GIC_SPI 185 IRQ_TYPE_NONE>;	328	<GIC_SPI 185 IRQ_TYPE_LEVEL_HIGH>;
329	brcm,pcie-msi-inten;	329	brcm,pcie-msi-inten;
330	};	330	};
331	};	331	};
@@ -336,7 +336,7 @@ · 4 unmodified lines
336		336
337	#interrupt-cells = <1>;	337	#interrupt-cells = <1>;
338	interrupt-map-mask = <0 0 0 0>;	338	interrupt-map-mask = <0 0 0 0>;
339	interrupt-map = <0 0 0 0 &gic GIC_SPI 192 IRQ_TYPE_NONE>;	339	interrupt-map = <0 0 0 0 &gic GIC_SPI 192 IRQ_TYPE_LEVEL_HIGH>;
340		340
341	linux,pci-domain = <1>;	341	linux,pci-domain = <1>;
342		342
@@ -358,10 +358,10 @@ · 15 unmodified lines
358	compatible = "brcm,iproc-msi";	358	compatible = "brcm,iproc-msi";
359	msi-controller;	359	msi-controller;
360	interrupt-parent = <&gic>;	360	interrupt-parent = <&gic>;
361	interrupts = <GIC_SPI 188 IRQ_TYPE_NONE>,	361	interrupts = <GIC_SPI 188 IRQ_TYPE_LEVEL_HIGH>,
362	<GIC_SPI 189 IRQ_TYPE_NONE>,	362	<GIC_SPI 189 IRQ_TYPE_LEVEL_HIGH>,
363	<GIC_SPI 190 IRQ_TYPE_NONE>,	363	<GIC_SPI 190 IRQ_TYPE_LEVEL_HIGH>,
364	<GIC_SPI 191 IRQ_TYPE_NONE>;	364	<GIC_SPI 191 IRQ_TYPE_LEVEL_HIGH>;
365	brcm,pcie-msi-inten;	365	brcm,pcie-msi-inten;
366	};	366	};
367	};	367	};

arch/arm/boot/dts/bcm-nsp.dtsi+16−16

@@ -391,7 +391,7 @@ · 390 unmodified lines
391	reg = <0x38000 0x50>;	391	reg = <0x38000 0x50>;
392	#address-cells = <1>;	392	#address-cells = <1>;
393	#size-cells = <0>;	393	#size-cells = <0>;
394	interrupts = <GIC_SPI 89 IRQ_TYPE_NONE>;	394	interrupts = <GIC_SPI 89 IRQ_TYPE_LEVEL_HIGH>;
395	clock-frequency = <100000>;	395	clock-frequency = <100000>;
396	dma-coherent;	396	dma-coherent;
397	status = "disabled";	397	status = "disabled";
@@ -496,7 +496,7 @@ · 98 unmodified lines
496		496
497	#interrupt-cells = <1>;	497	#interrupt-cells = <1>;
498	interrupt-map-mask = <0 0 0 0>;	498	interrupt-map-mask = <0 0 0 0>;
499	interrupt-map = <0 0 0 0 &gic GIC_SPI 131 IRQ_TYPE_NONE>;	499	interrupt-map = <0 0 0 0 &gic GIC_SPI 131 IRQ_TYPE_LEVEL_HIGH>;
500		500
501	linux,pci-domain = <0>;	501	linux,pci-domain = <0>;
502		502
@@ -519,10 +519,10 @@ · 16 unmodified lines
519	compatible = "brcm,iproc-msi";	519	compatible = "brcm,iproc-msi";
520	msi-controller;	520	msi-controller;
521	interrupt-parent = <&gic>;	521	interrupt-parent = <&gic>;
522	interrupts = <GIC_SPI 127 IRQ_TYPE_NONE>,	522	interrupts = <GIC_SPI 127 IRQ_TYPE_LEVEL_HIGH>,
523	<GIC_SPI 128 IRQ_TYPE_NONE>,	523	<GIC_SPI 128 IRQ_TYPE_LEVEL_HIGH>,
524	<GIC_SPI 129 IRQ_TYPE_NONE>,	524	<GIC_SPI 129 IRQ_TYPE_LEVEL_HIGH>,
525	<GIC_SPI 130 IRQ_TYPE_NONE>;	525	<GIC_SPI 130 IRQ_TYPE_LEVEL_HIGH>;
526	brcm,pcie-msi-inten;	526	brcm,pcie-msi-inten;
527	};	527	};
528	};	528	};
@@ -533,7 +533,7 @@ · 4 unmodified lines
533		533
534	#interrupt-cells = <1>;	534	#interrupt-cells = <1>;
535	interrupt-map-mask = <0 0 0 0>;	535	interrupt-map-mask = <0 0 0 0>;
536	interrupt-map = <0 0 0 0 &gic GIC_SPI 137 IRQ_TYPE_NONE>;	536	interrupt-map = <0 0 0 0 &gic GIC_SPI 137 IRQ_TYPE_LEVEL_HIGH>;
537		537
538	linux,pci-domain = <1>;	538	linux,pci-domain = <1>;
539		539
@@ -556,10 +556,10 @@ · 16 unmodified lines
556	compatible = "brcm,iproc-msi";	556	compatible = "brcm,iproc-msi";
557	msi-controller;	557	msi-controller;
558	interrupt-parent = <&gic>;	558	interrupt-parent = <&gic>;
559	interrupts = <GIC_SPI 133 IRQ_TYPE_NONE>,	559	interrupts = <GIC_SPI 133 IRQ_TYPE_LEVEL_HIGH>,
560	<GIC_SPI 134 IRQ_TYPE_NONE>,	560	<GIC_SPI 134 IRQ_TYPE_LEVEL_HIGH>,
561	<GIC_SPI 135 IRQ_TYPE_NONE>,	561	<GIC_SPI 135 IRQ_TYPE_LEVEL_HIGH>,
562	<GIC_SPI 136 IRQ_TYPE_NONE>;	562	<GIC_SPI 136 IRQ_TYPE_LEVEL_HIGH>;
563	brcm,pcie-msi-inten;	563	brcm,pcie-msi-inten;
564	};	564	};
565	};	565	};
@@ -570,7 +570,7 @@ · 4 unmodified lines
570		570
571	#interrupt-cells = <1>;	571	#interrupt-cells = <1>;
572	interrupt-map-mask = <0 0 0 0>;	572	interrupt-map-mask = <0 0 0 0>;
573	interrupt-map = <0 0 0 0 &gic GIC_SPI 143 IRQ_TYPE_NONE>;	573	interrupt-map = <0 0 0 0 &gic GIC_SPI 143 IRQ_TYPE_LEVEL_HIGH>;
574		574
575	linux,pci-domain = <2>;	575	linux,pci-domain = <2>;
576		576
@@ -593,10 +593,10 @@ · 16 unmodified lines
593	compatible = "brcm,iproc-msi";	593	compatible = "brcm,iproc-msi";
594	msi-controller;	594	msi-controller;
595	interrupt-parent = <&gic>;	595	interrupt-parent = <&gic>;
596	interrupts = <GIC_SPI 139 IRQ_TYPE_NONE>,	596	interrupts = <GIC_SPI 139 IRQ_TYPE_LEVEL_HIGH>,
597	<GIC_SPI 140 IRQ_TYPE_NONE>,	597	<GIC_SPI 140 IRQ_TYPE_LEVEL_HIGH>,
598	<GIC_SPI 141 IRQ_TYPE_NONE>,	598	<GIC_SPI 141 IRQ_TYPE_LEVEL_HIGH>,
599	<GIC_SPI 142 IRQ_TYPE_NONE>;	599	<GIC_SPI 142 IRQ_TYPE_LEVEL_HIGH>;
600	brcm,pcie-msi-inten;	600	brcm,pcie-msi-inten;
601	};	601	};
602	};	602	};

arch/arm/boot/dts/bcm5301x.dtsi+1−1

@@ -365,7 +365,7 @@ · 364 unmodified lines
365	i2c0: i2c@18009000 {	365	i2c0: i2c@18009000 {
366	compatible = "brcm,iproc-i2c";	366	compatible = "brcm,iproc-i2c";
367	reg = <0x18009000 0x50>;	367	reg = <0x18009000 0x50>;
368	interrupts = <GIC_SPI 121 IRQ_TYPE_NONE>;	368	interrupts = <GIC_SPI 121 IRQ_TYPE_LEVEL_HIGH>;
369	#address-cells = <1>;	369	#address-cells = <1>;
370	#size-cells = <0>;	370	#size-cells = <0>;
371	clock-frequency = <100000>;	371	clock-frequency = <100000>;

arch/arm/boot/dts/da850.dtsi+1−5

 			gpio-controller;
 			#gpio-cells = <2>;
 			reg = <0x226000 0x1000>;
-			interrupts = <42 IRQ_TYPE_EDGE_BOTH
+			interrupts = <42 43 44 45 46 47 48 49 50>;
-				43 IRQ_TYPE_EDGE_BOTH 44 IRQ_TYPE_EDGE_BOTH
-				45 IRQ_TYPE_EDGE_BOTH 46 IRQ_TYPE_EDGE_BOTH
-				47 IRQ_TYPE_EDGE_BOTH 48 IRQ_TYPE_EDGE_BOTH
-				49 IRQ_TYPE_EDGE_BOTH 50 IRQ_TYPE_EDGE_BOTH>;
 			ti,ngpio = <144>;
 			ti,davinci-gpio-unbanked = <0>;
 			status = "disabled";

arch/arm/boot/dts/imx6q.dtsi+1−1

@@ -90,7 +90,7 @@ · 89 unmodified lines
90	clocks = <&clks IMX6Q_CLK_ECSPI5>,	90	clocks = <&clks IMX6Q_CLK_ECSPI5>,
91	<&clks IMX6Q_CLK_ECSPI5>;	91	<&clks IMX6Q_CLK_ECSPI5>;
92	clock-names = "ipg", "per";	92	clock-names = "ipg", "per";
93	dmas = <&sdma 11 7 1>, <&sdma 12 7 2>;	93	dmas = <&sdma 11 8 1>, <&sdma 12 8 2>;
94	dma-names = "rx", "tx";	94	dma-names = "rx", "tx";
95	status = "disabled";	95	status = "disabled";
96	};	96	};

arch/arm/boot/dts/imx6sx.dtsi+1−1

@@ -1344,7 +1344,7 @@ · 1343 unmodified lines
1344	ranges = <0x81000000 0 0 0x08f80000 0 0x00010000 /* downstream I/O */	1344	ranges = <0x81000000 0 0 0x08f80000 0 0x00010000 /* downstream I/O */
1345	0x82000000 0 0x08000000 0x08000000 0 0x00f00000>; /* non-prefetchable memory */	1345	0x82000000 0 0x08000000 0x08000000 0 0x00f00000>; /* non-prefetchable memory */
1346	num-lanes = <1>;	1346	num-lanes = <1>;
1347	interrupts = <GIC_SPI 123 IRQ_TYPE_LEVEL_HIGH>;	1347	interrupts = <GIC_SPI 120 IRQ_TYPE_LEVEL_HIGH>;
1348	interrupt-names = "msi";	1348	interrupt-names = "msi";
1349	#interrupt-cells = <1>;	1349	#interrupt-cells = <1>;
1350	interrupt-map-mask = <0 0 0 0x7>;	1350	interrupt-map-mask = <0 0 0 0x7>;

arch/arm/boot/dts/socfpga.dtsi+2−2

@@ -748,13 +748,13 @@ · 747 unmodified lines
748	nand0: nand@ff900000 {	748	nand0: nand@ff900000 {
749	#address-cells = <0x1>;	749	#address-cells = <0x1>;
750	#size-cells = <0x1>;	750	#size-cells = <0x1>;
751	compatible = "denali,denali-nand-dt";	751	compatible = "altr,socfpga-denali-nand";
752	reg = <0xff900000 0x100000>,	752	reg = <0xff900000 0x100000>,
753	<0xffb80000 0x10000>;	753	<0xffb80000 0x10000>;
754	reg-names = "nand_data", "denali_reg";	754	reg-names = "nand_data", "denali_reg";
755	interrupts = <0x0 0x90 0x4>;	755	interrupts = <0x0 0x90 0x4>;
756	dma-mask = <0xffffffff>;	756	dma-mask = <0xffffffff>;
757	clocks = <&nand_clk>;	757	clocks = <&nand_x_clk>;
758	status = "disabled";	758	status = "disabled";
759	};	759	};
760		760

arch/arm/boot/dts/socfpga_arria10.dtsi+2−3

 			#size-cells = <0>;
 			reg = <0xffda5000 0x100>;
 			interrupts = <0 102 4>;
-			num-chipselect = <4>;
+			num-cs = <4>;
-			bus-num = <0>;
 			/*32bit_access;*/
 			tx-dma-channel = <&pdma 16>;
 			rx-dma-channel = <&pdma 17>;
 		nand: nand@ffb90000 {
 			#address-cells = <1>;
 			#size-cells = <1>;
-			compatible = "denali,denali-nand-dt", "altr,socfpga-denali-nand";
+			compatible = "altr,socfpga-denali-nand";
 			reg = <0xffb90000 0x72000>,
 			      <0xffb80000 0x10000>;
 			reg-names = "nand_data", "denali_reg";

arch/arm/common/Makefile+1−1

@@ -10,7 +10,7 @@ obj-$(CONFIG_DMABOUNCE) += dmabounce.o · 9 unmodified lines
10	obj-$(CONFIG_SHARP_LOCOMO) += locomo.o	10	obj-$(CONFIG_SHARP_LOCOMO) += locomo.o
11	obj-$(CONFIG_SHARP_PARAM) += sharpsl_param.o	11	obj-$(CONFIG_SHARP_PARAM) += sharpsl_param.o
12	obj-$(CONFIG_SHARP_SCOOP) += scoop.o	12	obj-$(CONFIG_SHARP_SCOOP) += scoop.o
13	obj-$(CONFIG_SMP) += secure_cntvoff.o	13	obj-$(CONFIG_CPU_V7) += secure_cntvoff.o
14	obj-$(CONFIG_PCI_HOST_ITE8152) += it8152.o	14	obj-$(CONFIG_PCI_HOST_ITE8152) += it8152.o
15	obj-$(CONFIG_MCPM) += mcpm_head.o mcpm_entry.o mcpm_platsmp.o vlock.o	15	obj-$(CONFIG_MCPM) += mcpm_head.o mcpm_entry.o mcpm_platsmp.o vlock.o
16	CFLAGS_REMOVE_mcpm_entry.o = -pg	16	CFLAGS_REMOVE_mcpm_entry.o = -pg

arch/arm/configs/multi_v7_defconfig+155−223

 CONFIG_SYSVIPC=y
-CONFIG_FHANDLE=y
 CONFIG_NO_HZ=y
 CONFIG_HIGH_RES_TIMERS=y
 CONFIG_CGROUPS=y
 CONFIG_MODULE_UNLOAD=y
 CONFIG_PARTITION_ADVANCED=y
 CONFIG_CMDLINE_PARTITION=y
-CONFIG_ARCH_MULTI_V7=y
-# CONFIG_ARCH_MULTI_V5 is not set
-# CONFIG_ARCH_MULTI_V4 is not set
 CONFIG_ARCH_VIRT=y
 CONFIG_ARCH_ALPINE=y
 CONFIG_ARCH_ARTPEC=y
 CONFIG_MACH_ARTPEC6=y
-CONFIG_ARCH_MVEBU=y
-CONFIG_MACH_ARMADA_370=y
-CONFIG_MACH_ARMADA_375=y
-CONFIG_MACH_ARMADA_38X=y
-CONFIG_MACH_ARMADA_39X=y
-CONFIG_MACH_ARMADA_XP=y
-CONFIG_MACH_DOVE=y
 CONFIG_ARCH_AT91=y
 CONFIG_SOC_SAMA5D2=y
 CONFIG_SOC_SAMA5D3=y
 CONFIG_ARCH_BCM_CYGNUS=y
 CONFIG_ARCH_BCM_HR2=y
 CONFIG_ARCH_BCM_NSP=y
-CONFIG_ARCH_BCM_21664=y
-CONFIG_ARCH_BCM_281XX=y
 CONFIG_ARCH_BCM_5301X=y
+CONFIG_ARCH_BCM_281XX=y
+CONFIG_ARCH_BCM_21664=y
 CONFIG_ARCH_BCM2835=y
 CONFIG_ARCH_BCM_63XX=y
 CONFIG_ARCH_BRCMSTB=y
 CONFIG_MACH_BERLIN_BG2CD=y
 CONFIG_MACH_BERLIN_BG2Q=y
 CONFIG_ARCH_DIGICOLOR=y
+CONFIG_ARCH_EXYNOS=y
+CONFIG_EXYNOS5420_MCPM=y
 CONFIG_ARCH_HIGHBANK=y
 CONFIG_ARCH_HISI=y
 CONFIG_ARCH_HI3xxx=y
-CONFIG_ARCH_HIX5HD2=y
 CONFIG_ARCH_HIP01=y
 CONFIG_ARCH_HIP04=y
-CONFIG_ARCH_KEYSTONE=y
+CONFIG_ARCH_HIX5HD2=y
-CONFIG_ARCH_MESON=y
 CONFIG_ARCH_MXC=y
 CONFIG_SOC_IMX50=y
 CONFIG_SOC_IMX51=y
 CONFIG_SOC_IMX6SX=y
 CONFIG_SOC_IMX6UL=y
 CONFIG_SOC_IMX7D=y
-CONFIG_SOC_VF610=y
 CONFIG_SOC_LS1021A=y
+CONFIG_SOC_VF610=y
+CONFIG_ARCH_KEYSTONE=y
+CONFIG_ARCH_MEDIATEK=y
+CONFIG_ARCH_MESON=y
+CONFIG_ARCH_MVEBU=y
+CONFIG_MACH_ARMADA_370=y
+CONFIG_MACH_ARMADA_375=y
+CONFIG_MACH_ARMADA_38X=y
+CONFIG_MACH_ARMADA_39X=y
+CONFIG_MACH_ARMADA_XP=y
+CONFIG_MACH_DOVE=y
 CONFIG_ARCH_OMAP3=y
 CONFIG_ARCH_OMAP4=y
 CONFIG_SOC_OMAP5=y
 CONFIG_SOC_AM33XX=y
 CONFIG_SOC_AM43XX=y
 CONFIG_SOC_DRA7XX=y
+CONFIG_ARCH_SIRF=y
 CONFIG_ARCH_QCOM=y
-CONFIG_ARCH_MEDIATEK=y
 CONFIG_ARCH_MSM8X60=y
 CONFIG_ARCH_MSM8960=y
 CONFIG_ARCH_MSM8974=y
 CONFIG_ARCH_ROCKCHIP=y
-CONFIG_ARCH_SOCFPGA=y
-CONFIG_PLAT_SPEAR=y
-CONFIG_ARCH_SPEAR13XX=y
-CONFIG_MACH_SPEAR1310=y
-CONFIG_MACH_SPEAR1340=y
-CONFIG_ARCH_STI=y
-CONFIG_ARCH_STM32=y
-CONFIG_ARCH_EXYNOS=y
-CONFIG_EXYNOS5420_MCPM=y
 CONFIG_ARCH_RENESAS=y
 CONFIG_ARCH_EMEV2=y
 CONFIG_ARCH_R7S72100=y
 CONFIG_ARCH_R8A7793=y
 CONFIG_ARCH_R8A7794=y
 CONFIG_ARCH_SH73A0=y
+CONFIG_ARCH_SOCFPGA=y
+CONFIG_PLAT_SPEAR=y
+CONFIG_ARCH_SPEAR13XX=y
+CONFIG_MACH_SPEAR1310=y
+CONFIG_MACH_SPEAR1340=y
+CONFIG_ARCH_STI=y
+CONFIG_ARCH_STM32=y
 CONFIG_ARCH_SUNXI=y
-CONFIG_ARCH_SIRF=y
 CONFIG_ARCH_TEGRA=y
-CONFIG_ARCH_TEGRA_2x_SOC=y
-CONFIG_ARCH_TEGRA_3x_SOC=y
-CONFIG_ARCH_TEGRA_114_SOC=y
-CONFIG_ARCH_TEGRA_124_SOC=y
 CONFIG_ARCH_UNIPHIER=y
 CONFIG_ARCH_U8500=y
-CONFIG_MACH_HREFV60=y
-CONFIG_MACH_SNOWBALL=y
 CONFIG_ARCH_VEXPRESS=y
 CONFIG_ARCH_VEXPRESS_TC2_PM=y
 CONFIG_ARCH_WM8850=y
 CONFIG_ARCH_ZYNQ=y
-CONFIG_TRUSTED_FOUNDATIONS=y
+CONFIG_PCIEPORTBUS=y
-CONFIG_PCI=y
-CONFIG_PCI_HOST_GENERIC=y
-CONFIG_PCI_DRA7XX=y
-CONFIG_PCI_DRA7XX_EP=y
-CONFIG_PCI_KEYSTONE=y
-CONFIG_PCI_MSI=y
 CONFIG_PCI_MVEBU=y
 CONFIG_PCI_TEGRA=y
 CONFIG_PCI_RCAR_GEN2=y
 CONFIG_PCIE_RCAR=y
-CONFIG_PCIEPORTBUS=y
+CONFIG_PCI_DRA7XX_EP=y
+CONFIG_PCI_KEYSTONE=y
 CONFIG_PCI_ENDPOINT=y
 CONFIG_PCI_ENDPOINT_CONFIGFS=y
 CONFIG_PCI_EPF_TEST=m
 CONFIG_SMP=y
 CONFIG_NR_CPUS=16
-CONFIG_HIGHPTE=y
-CONFIG_CMA=y
 CONFIG_SECCOMP=y
 CONFIG_ARM_APPENDED_DTB=y
 CONFIG_ARM_ATAG_DTB_COMPAT=y
 CONFIG_CPU_FREQ_GOV_USERSPACE=m
 CONFIG_CPU_FREQ_GOV_CONSERVATIVE=m
 CONFIG_CPU_FREQ_GOV_SCHEDUTIL=y
+CONFIG_CPUFREQ_DT=y
 CONFIG_ARM_IMX6Q_CPUFREQ=y
 CONFIG_QORIQ_CPUFREQ=y
 CONFIG_CPU_IDLE=y
 CONFIG_ARM_CPUIDLE=y
-CONFIG_NEON=y
-CONFIG_KERNEL_MODE_NEON=y
 CONFIG_ARM_ZYNQ_CPUIDLE=y
 CONFIG_ARM_EXYNOS_CPUIDLE=y
+CONFIG_KERNEL_MODE_NEON=y
 CONFIG_NET=y
 CONFIG_PACKET=y
 CONFIG_UNIX=y
 CONFIG_IPV6_TUNNEL=m
 CONFIG_IPV6_MULTIPLE_TABLES=y
 CONFIG_NET_DSA=m
-CONFIG_NET_SWITCHDEV=y
 CONFIG_CAN=y
-CONFIG_CAN_RAW=y
-CONFIG_CAN_BCM=y
-CONFIG_CAN_DEV=y
 CONFIG_CAN_AT91=m
 CONFIG_CAN_FLEXCAN=m
-CONFIG_CAN_RCAR=m
+CONFIG_CAN_SUN4I=y
 CONFIG_CAN_XILINXCAN=y
+CONFIG_CAN_RCAR=m
 CONFIG_CAN_MCP251X=y
-CONFIG_NET_DSA_BCM_SF2=m
-CONFIG_B53=m
-CONFIG_B53_SPI_DRIVER=m
-CONFIG_B53_MDIO_DRIVER=m
-CONFIG_B53_MMAP_DRIVER=m
-CONFIG_B53_SRAB_DRIVER=m
-CONFIG_CAN_SUN4I=y
 CONFIG_BT=m
 CONFIG_BT_HCIUART=m
 CONFIG_BT_HCIUART_BCM=y
 CONFIG_RFKILL_GPIO=y
 CONFIG_DEVTMPFS=y
 CONFIG_DEVTMPFS_MOUNT=y
-CONFIG_DMA_CMA=y
 CONFIG_CMA_SIZE_MBYTES=64
 CONFIG_OMAP_OCP2SCP=y
 CONFIG_SIMPLE_PM_BUS=y
-CONFIG_SUNXI_RSB=y
 CONFIG_MTD=y
 CONFIG_MTD_CMDLINE_PARTS=y
 CONFIG_MTD_BLOCK=y
 CONFIG_EEPROM_AT24=y
 CONFIG_BLK_DEV_SD=y
 CONFIG_BLK_DEV_SR=y
-CONFIG_SCSI_MULTI_LUN=y
 CONFIG_ATA=y
 CONFIG_SATA_AHCI=y
 CONFIG_SATA_AHCI_PLATFORM=y
 CONFIG_SATA_RCAR=y
 CONFIG_NETDEVICES=y
 CONFIG_VIRTIO_NET=y
-CONFIG_HIX5HD2_GMAC=y
+CONFIG_B53_SPI_DRIVER=m
+CONFIG_B53_MDIO_DRIVER=m
+CONFIG_B53_MMAP_DRIVER=m
+CONFIG_B53_SRAB_DRIVER=m
+CONFIG_NET_DSA_BCM_SF2=m
 CONFIG_SUN4I_EMAC=y
-CONFIG_MACB=y
 CONFIG_BCMGENET=m
 CONFIG_BGMAC_BCMA=y
 CONFIG_SYSTEMPORT=m
+CONFIG_MACB=y
 CONFIG_NET_CALXEDA_XGMAC=y
 CONFIG_GIANFAR=y
+CONFIG_HIX5HD2_GMAC=y
+CONFIG_E1000E=y
 CONFIG_IGB=y
 CONFIG_MV643XX_ETH=y
 CONFIG_MVNETA=y
 CONFIG_SH_ETH=y
 CONFIG_SMSC911X=y
 CONFIG_STMMAC_ETH=y
-CONFIG_STMMAC_PLATFORM=y
 CONFIG_DWMAC_DWC_QOS_ETH=y
 CONFIG_TI_CPSW=y
 CONFIG_XILINX_EMACLITE=y
 CONFIG_AT803X_PHY=y
-CONFIG_MARVELL_PHY=y
-CONFIG_SMSC_PHY=y
 CONFIG_BROADCOM_PHY=y
 CONFIG_ICPLUS_PHY=y
-CONFIG_REALTEK_PHY=y
+CONFIG_MARVELL_PHY=y
 CONFIG_MICREL_PHY=y
-CONFIG_FIXED_PHY=y
+CONFIG_REALTEK_PHY=y
 CONFIG_ROCKCHIP_PHY=y
+CONFIG_SMSC_PHY=y
 CONFIG_USB_PEGASUS=y
 CONFIG_USB_RTL8152=m
 CONFIG_USB_LAN78XX=m
 CONFIG_USB_NET_SMSC75XX=y
 CONFIG_USB_NET_SMSC95XX=y
 CONFIG_BRCMFMAC=m
-CONFIG_RT2X00=m
-CONFIG_RT2800USB=m
 CONFIG_MWIFIEX=m
 CONFIG_MWIFIEX_SDIO=m
+CONFIG_RT2X00=m
+CONFIG_RT2800USB=m
 CONFIG_INPUT_JOYDEV=y
 CONFIG_INPUT_EVDEV=y
 CONFIG_KEYBOARD_QT1070=m
 CONFIG_KEYBOARD_GPIO=y
 CONFIG_KEYBOARD_TEGRA=y
-CONFIG_KEYBOARD_SPEAR=y
+CONFIG_KEYBOARD_SAMSUNG=m
 CONFIG_KEYBOARD_ST_KEYSCAN=y
+CONFIG_KEYBOARD_SPEAR=y
 CONFIG_KEYBOARD_CROS_EC=m
-CONFIG_KEYBOARD_SAMSUNG=m
 CONFIG_MOUSE_PS2_ELANTECH=y
 CONFIG_MOUSE_CYAPA=m
 CONFIG_MOUSE_ELAN_I2C=y
 CONFIG_INPUT_TOUCHSCREEN=y
 CONFIG_TOUCHSCREEN_ATMEL_MXT=m
 CONFIG_TOUCHSCREEN_MMS114=m
+CONFIG_TOUCHSCREEN_WM97XX=m
 CONFIG_TOUCHSCREEN_ST1232=m
 CONFIG_TOUCHSCREEN_STMPE=y
 CONFIG_TOUCHSCREEN_SUN4I=y
-CONFIG_TOUCHSCREEN_WM97XX=m
 CONFIG_INPUT_MISC=y
 CONFIG_INPUT_MAX77693_HAPTIC=m
 CONFIG_INPUT_MAX8997_HAPTIC=m
 CONFIG_SERIAL_8250_EM=y
 CONFIG_SERIAL_8250_MT6577=y
 CONFIG_SERIAL_8250_UNIPHIER=y
+CONFIG_SERIAL_OF_PLATFORM=y
 CONFIG_SERIAL_AMBA_PL011=y
 CONFIG_SERIAL_AMBA_PL011_CONSOLE=y
 CONFIG_SERIAL_ATMEL=y
 CONFIG_SERIAL_ATMEL_CONSOLE=y
 CONFIG_SERIAL_ATMEL_TTYAT=y
-CONFIG_SERIAL_BCM63XX=y
-CONFIG_SERIAL_BCM63XX_CONSOLE=y
 CONFIG_SERIAL_MESON=y
 CONFIG_SERIAL_MESON_CONSOLE=y
 CONFIG_SERIAL_SAMSUNG=y
 CONFIG_SERIAL_IMX_CONSOLE=y
 CONFIG_SERIAL_SH_SCI=y
 CONFIG_SERIAL_SH_SCI_NR_UARTS=20
-CONFIG_SERIAL_SH_SCI_CONSOLE=y
-CONFIG_SERIAL_SH_SCI_DMA=y
 CONFIG_SERIAL_MSM=y
 CONFIG_SERIAL_MSM_CONSOLE=y
 CONFIG_SERIAL_VT8500=y
 CONFIG_SERIAL_VT8500_CONSOLE=y
-CONFIG_SERIAL_OF_PLATFORM=y
 CONFIG_SERIAL_OMAP=y
 CONFIG_SERIAL_OMAP_CONSOLE=y
+CONFIG_SERIAL_BCM63XX=y
+CONFIG_SERIAL_BCM63XX_CONSOLE=y
 CONFIG_SERIAL_XILINX_PS_UART=y
 CONFIG_SERIAL_XILINX_PS_UART_CONSOLE=y
 CONFIG_SERIAL_FSL_LPUART=y
 CONFIG_SERIAL_STM32=y
 CONFIG_SERIAL_STM32_CONSOLE=y
 CONFIG_SERIAL_DEV_BUS=y
-CONFIG_HVC_DRIVER=y
 CONFIG_VIRTIO_CONSOLE=y
+CONFIG_HW_RANDOM=y
+CONFIG_HW_RANDOM_ST=y
 CONFIG_I2C_CHARDEV=y
-CONFIG_I2C_DAVINCI=y
-CONFIG_I2C_MESON=y
-CONFIG_I2C_MUX=y
 CONFIG_I2C_ARB_GPIO_CHALLENGE=m
 CONFIG_I2C_MUX_PCA954x=y
 CONFIG_I2C_MUX_PINCTRL=y
 CONFIG_I2C_AT91=m
 CONFIG_I2C_BCM2835=y
 CONFIG_I2C_CADENCE=y
+CONFIG_I2C_DAVINCI=y
 CONFIG_I2C_DESIGNWARE_PLATFORM=y
 CONFIG_I2C_DIGICOLOR=m
 CONFIG_I2C_EMEV2=m
 CONFIG_I2C_GPIO=m
-CONFIG_I2C_EXYNOS5=y
 CONFIG_I2C_IMX=y
+CONFIG_I2C_MESON=y
 CONFIG_I2C_MV64XXX=y
 CONFIG_I2C_RIIC=y
 CONFIG_I2C_RK3X=y
 CONFIG_SPMI=y
 CONFIG_PINCTRL_AS3722=y
 CONFIG_PINCTRL_PALMAS=y
-CONFIG_PINCTRL_BCM2835=y
 CONFIG_PINCTRL_APQ8064=y
 CONFIG_PINCTRL_APQ8084=y
 CONFIG_PINCTRL_IPQ8064=y
 CONFIG_PINCTRL_MSM8916=y
 CONFIG_PINCTRL_QCOM_SPMI_PMIC=y
 CONFIG_PINCTRL_QCOM_SSBI_PMIC=y
-CONFIG_GPIO_GENERIC_PLATFORM=y
 CONFIG_GPIO_DAVINCI=y
 CONFIG_GPIO_DWAPB=y
 CONFIG_GPIO_EM=y
 CONFIG_GPIO_RCAR=y
+CONFIG_GPIO_SYSCON=y
 CONFIG_GPIO_UNIPHIER=y
 CONFIG_GPIO_XILINX=y
 CONFIG_GPIO_ZYNQ=y
 CONFIG_GPIO_PCA953X=y
 CONFIG_GPIO_PCA953X_IRQ=y
 CONFIG_GPIO_PCF857X=y
-CONFIG_GPIO_TWL4030=y
 CONFIG_GPIO_PALMAS=y
-CONFIG_GPIO_SYSCON=y
 CONFIG_GPIO_TPS6586X=y
 CONFIG_GPIO_TPS65910=y
+CONFIG_GPIO_TWL4030=y
+CONFIG_POWER_AVS=y
+CONFIG_ROCKCHIP_IODOMAIN=y
+CONFIG_POWER_RESET_AS3722=y
+CONFIG_POWER_RESET_GPIO=y
+CONFIG_POWER_RESET_GPIO_RESTART=y
+CONFIG_POWER_RESET_ST=y
+CONFIG_POWER_RESET_KEYSTONE=y
+CONFIG_POWER_RESET_RMOBILE=y
 CONFIG_BATTERY_ACT8945A=y
 CONFIG_BATTERY_CPCAP=m
 CONFIG_BATTERY_SBS=y
+CONFIG_AXP20X_POWER=m
 CONFIG_BATTERY_MAX17040=m
 CONFIG_BATTERY_MAX17042=m
 CONFIG_CHARGER_CPCAP=m
 CONFIG_CHARGER_MAX8997=m
 CONFIG_CHARGER_MAX8998=m
 CONFIG_CHARGER_TPS65090=y
-CONFIG_AXP20X_POWER=m
-CONFIG_POWER_RESET_AS3722=y
-CONFIG_POWER_RESET_GPIO=y
-CONFIG_POWER_RESET_GPIO_RESTART=y
-CONFIG_POWER_RESET_KEYSTONE=y
-CONFIG_POWER_RESET_RMOBILE=y
-CONFIG_POWER_RESET_ST=y
-CONFIG_POWER_AVS=y
-CONFIG_ROCKCHIP_IODOMAIN=y
 CONFIG_SENSORS_IIO_HWMON=y
 CONFIG_SENSORS_LM90=y
 CONFIG_SENSORS_LM95245=y
 CONFIG_SENSORS_PWM_FAN=m
 CONFIG_SENSORS_INA2XX=m
 CONFIG_CPU_THERMAL=y
-CONFIG_BCM2835_THERMAL=m
-CONFIG_BRCMSTB_THERMAL=m
 CONFIG_IMX_THERMAL=y
 CONFIG_ROCKCHIP_THERMAL=y
 CONFIG_RCAR_THERMAL=y
 CONFIG_ARMADA_THERMAL=y
-CONFIG_DAVINCI_WATCHDOG=m
+CONFIG_BCM2835_THERMAL=m
-CONFIG_EXYNOS_THERMAL=m
+CONFIG_BRCMSTB_THERMAL=m
 CONFIG_ST_THERMAL_MEMMAP=y
 CONFIG_WATCHDOG=y
 CONFIG_DA9063_WATCHDOG=m
 CONFIG_ARM_SP805_WATCHDOG=y
 CONFIG_AT91SAM9X_WATCHDOG=y
 CONFIG_SAMA5D4_WATCHDOG=y
+CONFIG_DW_WATCHDOG=y
+CONFIG_DAVINCI_WATCHDOG=m
 CONFIG_ORION_WATCHDOG=y
 CONFIG_RN5T618_WATCHDOG=y
-CONFIG_ST_LPC_WATCHDOG=y
 CONFIG_SUNXI_WATCHDOG=y
 CONFIG_IMX2_WDT=y
+CONFIG_ST_LPC_WATCHDOG=y
 CONFIG_TEGRA_WATCHDOG=m
 CONFIG_MESON_WATCHDOG=y
-CONFIG_DW_WATCHDOG=y
 CONFIG_DIGICOLOR_WATCHDOG=y
 CONFIG_RENESAS_WDT=m
-CONFIG_BCM2835_WDT=y
 CONFIG_BCM47XX_WDT=y
-CONFIG_BCM7038_WDT=m
+CONFIG_BCM2835_WDT=y
 CONFIG_BCM_KONA_WDT=y
+CONFIG_BCM7038_WDT=m
+CONFIG_BCMA_HOST_SOC=y
+CONFIG_BCMA_DRIVER_GMAC_CMN=y
+CONFIG_BCMA_DRIVER_GPIO=y
 CONFIG_MFD_ACT8945A=y
 CONFIG_MFD_AS3711=y
 CONFIG_MFD_AS3722=y
 CONFIG_MFD_ATMEL_HLCDC=m
 CONFIG_MFD_BCM590XX=y
 CONFIG_MFD_AC100=y
-CONFIG_MFD_AXP20X=y
 CONFIG_MFD_AXP20X_I2C=y
 CONFIG_MFD_AXP20X_RSB=y
 CONFIG_MFD_CROS_EC=m
 CONFIG_MFD_MAX8907=y
 CONFIG_MFD_MAX8997=y
 CONFIG_MFD_MAX8998=y
-CONFIG_MFD_RK808=y
 CONFIG_MFD_CPCAP=y
 CONFIG_MFD_PM8XXX=y
 CONFIG_MFD_QCOM_RPM=y
 CONFIG_MFD_SPMI_PMIC=y
+CONFIG_MFD_RK808=y
 CONFIG_MFD_RN5T618=y
 CONFIG_MFD_SEC_CORE=y
 CONFIG_MFD_STMPE=y
 CONFIG_MFD_TPS65218=y
 CONFIG_MFD_TPS6586X=y
 CONFIG_MFD_TPS65910=y
-CONFIG_REGULATOR_ACT8945A=y
-CONFIG_REGULATOR_AB8500=y
 CONFIG_REGULATOR_ACT8865=y
+CONFIG_REGULATOR_ACT8945A=y
 CONFIG_REGULATOR_ANATOP=y
+CONFIG_REGULATOR_AB8500=y
 CONFIG_REGULATOR_AS3711=y
 CONFIG_REGULATOR_AS3722=y
 CONFIG_REGULATOR_AXP20X=y
 CONFIG_REGULATOR_CPCAP=y
 CONFIG_REGULATOR_DA9210=y
 CONFIG_REGULATOR_FAN53555=y
-CONFIG_REGULATOR_RK808=y
 CONFIG_REGULATOR_GPIO=y
-CONFIG_MFD_SYSCON=y
-CONFIG_POWER_RESET_SYSCON=y
 CONFIG_REGULATOR_LP872X=y
 CONFIG_REGULATOR_MAX14577=m
 CONFIG_REGULATOR_MAX8907=y
 CONFIG_REGULATOR_PBIAS=y
 CONFIG_REGULATOR_PWM=y
 CONFIG_REGULATOR_QCOM_RPM=y
-CONFIG_REGULATOR_QCOM_SMD_RPM=y
+CONFIG_REGULATOR_QCOM_SMD_RPM=m
+CONFIG_REGULATOR_RK808=y
 CONFIG_REGULATOR_RN5T618=y
 CONFIG_REGULATOR_S2MPS11=y
 CONFIG_REGULATOR_S5M8767=y
 CONFIG_MEDIA_CONTROLLER=y
 CONFIG_VIDEO_V4L2_SUBDEV_API=y
 CONFIG_MEDIA_USB_SUPPORT=y
-CONFIG_USB_VIDEO_CLASS=y
+CONFIG_USB_VIDEO_CLASS=m
-CONFIG_USB_GSPCA=y
 CONFIG_V4L_PLATFORM_DRIVERS=y
 CONFIG_SOC_CAMERA=m
 CONFIG_SOC_CAMERA_PLATFORM=m
-CONFIG_VIDEO_RCAR_VIN=m
-CONFIG_VIDEO_ATMEL_ISI=m
 CONFIG_VIDEO_SAMSUNG_EXYNOS4_IS=m
 CONFIG_VIDEO_S5P_FIMC=m
 CONFIG_VIDEO_S5P_MIPI_CSIS=m
 CONFIG_VIDEO_EXYNOS_FIMC_LITE=m
 CONFIG_VIDEO_EXYNOS4_FIMC_IS=m
+CONFIG_VIDEO_RCAR_VIN=m
+CONFIG_VIDEO_ATMEL_ISI=m
 CONFIG_V4L_MEM2MEM_DRIVERS=y
 CONFIG_VIDEO_SAMSUNG_S5P_JPEG=m
 CONFIG_VIDEO_SAMSUNG_S5P_MFC=m
 CONFIG_VIDEO_RENESAS_JPU=m
 CONFIG_VIDEO_RENESAS_VSP1=m
 CONFIG_V4L_TEST_DRIVERS=y
+CONFIG_VIDEO_VIVID=m
 CONFIG_CEC_PLATFORM_DRIVERS=y
 CONFIG_VIDEO_SAMSUNG_S5P_CEC=m
 # CONFIG_MEDIA_SUBDRV_AUTOSELECT is not set
 CONFIG_VIDEO_ADV7180=m
 CONFIG_VIDEO_ML86V7667=m
 CONFIG_DRM=y
-CONFIG_DRM_I2C_ADV7511=m
-CONFIG_DRM_I2C_ADV7511_AUDIO=y
 # CONFIG_DRM_I2C_CH7006 is not set
 # CONFIG_DRM_I2C_SIL164 is not set
-CONFIG_DRM_DUMB_VGA_DAC=m
-CONFIG_DRM_NXP_PTN3460=m
-CONFIG_DRM_PARADE_PS8622=m
 CONFIG_DRM_NOUVEAU=m
 CONFIG_DRM_EXYNOS=m
 CONFIG_DRM_EXYNOS_FIMD=y
 CONFIG_DRM_SUN4I=m
 CONFIG_DRM_FSL_DCU=m
 CONFIG_DRM_TEGRA=y
+CONFIG_DRM_PANEL_SIMPLE=y
 CONFIG_DRM_PANEL_SAMSUNG_LD9040=m
 CONFIG_DRM_PANEL_SAMSUNG_S6E63J0X03=m
 CONFIG_DRM_PANEL_SAMSUNG_S6E8AA0=m
-CONFIG_DRM_PANEL_SIMPLE=y
+CONFIG_DRM_DUMB_VGA_DAC=m
+CONFIG_DRM_NXP_PTN3460=m
+CONFIG_DRM_PARADE_PS8622=m
 CONFIG_DRM_SII9234=m
+CONFIG_DRM_I2C_ADV7511=m
+CONFIG_DRM_I2C_ADV7511_AUDIO=y
 CONFIG_DRM_STI=m
-CONFIG_DRM_VC4=y
+CONFIG_DRM_VC4=m
 CONFIG_DRM_ETNAVIV=m
 CONFIG_DRM_MXSFB=m
 CONFIG_FB_ARMCLCD=y
 CONFIG_FB_WM8505=y
 CONFIG_FB_SH_MOBILE_LCDC=y
 CONFIG_FB_SIMPLE=y
-CONFIG_BACKLIGHT_LCD_SUPPORT=y
-CONFIG_BACKLIGHT_CLASS_DEVICE=y
 CONFIG_LCD_PLATFORM=m
 CONFIG_BACKLIGHT_PWM=y
 CONFIG_BACKLIGHT_AS3711=y
 CONFIG_FRAMEBUFFER_CONSOLE_ROTATION=y
 CONFIG_SOUND=m
 CONFIG_SND=m
-CONFIG_SND_DYNAMIC_MINORS=y
 CONFIG_SND_HDA_TEGRA=m
 CONFIG_SND_HDA_INPUT_BEEP=y
 CONFIG_SND_HDA_PATCH_LOADER=y
 CONFIG_SND_SOC_ODROID=m
 CONFIG_SND_SOC_SH4_FSI=m
 CONFIG_SND_SOC_RCAR=m
-CONFIG_SND_SIMPLE_SCU_CARD=m
+CONFIG_SND_SOC_STI=m
 CONFIG_SND_SUN4I_CODEC=m
 CONFIG_SND_SOC_TEGRA=m
 CONFIG_SND_SOC_TEGRA20_I2S=m
 CONFIG_SND_SOC_TEGRA_WM9712=m
 CONFIG_SND_SOC_TEGRA_TRIMSLICE=m
 CONFIG_SND_SOC_TEGRA_ALC5632=m
-CONFIG_SND_SOC_CPCAP=m
 CONFIG_SND_SOC_TEGRA_MAX98090=m
 CONFIG_SND_SOC_AK4642=m
+CONFIG_SND_SOC_CPCAP=m
 CONFIG_SND_SOC_SGTL5000=m
 CONFIG_SND_SOC_SPDIF=m
-CONFIG_SND_SOC_WM8978=m
-CONFIG_SND_SOC_STI=m
 CONFIG_SND_SOC_STI_SAS=m
-CONFIG_SND_SIMPLE_CARD=m
+CONFIG_SND_SOC_WM8978=m
+CONFIG_SND_SIMPLE_SCU_CARD=m
 CONFIG_USB=y
 CONFIG_USB_OTG=y
 CONFIG_USB_XHCI_HCD=y
 CONFIG_USB_XHCI_MVEBU=y
-CONFIG_USB_XHCI_RCAR=m
 CONFIG_USB_XHCI_TEGRA=m
 CONFIG_USB_EHCI_HCD=y
-CONFIG_USB_EHCI_MSM=m
-CONFIG_USB_EHCI_EXYNOS=y
-CONFIG_USB_EHCI_TEGRA=y
 CONFIG_USB_EHCI_HCD_STI=y
-CONFIG_USB_EHCI_HCD_PLATFORM=y
+CONFIG_USB_EHCI_TEGRA=y
-CONFIG_USB_ISP1760=y
+CONFIG_USB_EHCI_EXYNOS=y
 CONFIG_USB_OHCI_HCD=y
 CONFIG_USB_OHCI_HCD_STI=y
-CONFIG_USB_OHCI_HCD_PLATFORM=y
 CONFIG_USB_OHCI_EXYNOS=m
 CONFIG_USB_R8A66597_HCD=m
 CONFIG_USB_RENESAS_USBHS=m
 CONFIG_USB_TUSB_OMAP_DMA=y
 CONFIG_USB_DWC3=y
 CONFIG_USB_DWC2=y
-CONFIG_USB_HSIC_USB3503=y
 CONFIG_USB_CHIPIDEA=y
 CONFIG_USB_CHIPIDEA_UDC=y
 CONFIG_USB_CHIPIDEA_HOST=y
+CONFIG_USB_ISP1760=y
+CONFIG_USB_HSIC_USB3503=y
 CONFIG_AB8500_USB=y
-CONFIG_KEYSTONE_USB_PHY=y
+CONFIG_KEYSTONE_USB_PHY=m
 CONFIG_NOP_USB_XCEIV=m
 CONFIG_AM335X_PHY_USB=m
 CONFIG_TWL6030_USB=m
 CONFIG_USB_GPIO_VBUS=y
 CONFIG_USB_ISP1301=y
-CONFIG_USB_MSM_OTG=m
 CONFIG_USB_MXS_PHY=y
 CONFIG_USB_GADGET=y
 CONFIG_USB_FSL_USB2=y
 CONFIG_MMC_SDHCI_ESDHC_IMX=y
 CONFIG_MMC_SDHCI_DOVE=y
 CONFIG_MMC_SDHCI_TEGRA=y
+CONFIG_MMC_SDHCI_S3C=y
 CONFIG_MMC_SDHCI_PXAV3=y
 CONFIG_MMC_SDHCI_SPEAR=y
-CONFIG_MMC_SDHCI_S3C=y
 CONFIG_MMC_SDHCI_S3C_DMA=y
 CONFIG_MMC_SDHCI_BCM_KONA=y
+CONFIG_MMC_MESON_MX_SDIO=y
 CONFIG_MMC_SDHCI_ST=y
 CONFIG_MMC_OMAP=y
 CONFIG_MMC_OMAP_HS=y
 CONFIG_MMC_ATMELMCI=y
 CONFIG_MMC_SDHCI_MSM=y
-CONFIG_MMC_MESON_MX_SDIO=y
 CONFIG_MMC_MVSDIO=y
 CONFIG_MMC_SDHI=y
 CONFIG_MMC_DW=y
-CONFIG_MMC_DW_PLTFM=y
 CONFIG_MMC_DW_EXYNOS=y
 CONFIG_MMC_DW_ROCKCHIP=y
 CONFIG_MMC_SH_MMCIF=y
 CONFIG_RTC_DRV_RK808=m
 CONFIG_RTC_DRV_RS5C372=m
 CONFIG_RTC_DRV_BQ32K=m
-CONFIG_RTC_DRV_PALMAS=y
-CONFIG_RTC_DRV_ST_LPC=y
 CONFIG_RTC_DRV_TWL4030=y
+CONFIG_RTC_DRV_PALMAS=y
 CONFIG_RTC_DRV_TPS6586X=y
 CONFIG_RTC_DRV_TPS65910=y
 CONFIG_RTC_DRV_S35390A=m
 CONFIG_RTC_DRV_RX8581=m
 CONFIG_RTC_DRV_EM3027=y
+CONFIG_RTC_DRV_S5M=m
 CONFIG_RTC_DRV_DA9063=m
 CONFIG_RTC_DRV_EFI=m
 CONFIG_RTC_DRV_DIGICOLOR=m
-CONFIG_RTC_DRV_S5M=m
 CONFIG_RTC_DRV_S3C=m
 CONFIG_RTC_DRV_PL031=y
 CONFIG_RTC_DRV_AT91RM9200=m
 CONFIG_RTC_DRV_AT91SAM9=m
 CONFIG_RTC_DRV_VT8500=y
-CONFIG_RTC_DRV_SUN6I=y
 CONFIG_RTC_DRV_SUNXI=y
 CONFIG_RTC_DRV_MV=y
 CONFIG_RTC_DRV_TEGRA=y
+CONFIG_RTC_DRV_ST_LPC=y
 CONFIG_RTC_DRV_CPCAP=m
 CONFIG_DMADEVICES=y
-CONFIG_DW_DMAC=y
 CONFIG_AT_HDMAC=y
 CONFIG_AT_XDMAC=y
+CONFIG_DMA_BCM2835=y
+CONFIG_DMA_SUN6I=y
 CONFIG_FSL_EDMA=y
+CONFIG_IMX_DMA=y
+CONFIG_IMX_SDMA=y
 CONFIG_MV_XOR=y
+CONFIG_MXS_DMA=y
+CONFIG_PL330_DMA=y
+CONFIG_SIRF_DMA=y
+CONFIG_STE_DMA40=y
+CONFIG_ST_FDMA=m
 CONFIG_TEGRA20_APB_DMA=y
+CONFIG_XILINX_DMA=y
+CONFIG_QCOM_BAM_DMA=y
+CONFIG_DW_DMAC=y
 CONFIG_SH_DMAE=y
 CONFIG_RCAR_DMAC=y
 CONFIG_RENESAS_USB_DMAC=m
-CONFIG_STE_DMA40=y
+CONFIG_VIRTIO_PCI=y
-CONFIG_SIRF_DMA=y
+CONFIG_VIRTIO_MMIO=y
-CONFIG_TI_EDMA=y
-CONFIG_PL330_DMA=y
-CONFIG_IMX_SDMA=y
-CONFIG_IMX_DMA=y
-CONFIG_MXS_DMA=y
-CONFIG_DMA_BCM2835=y
-CONFIG_DMA_OMAP=y
-CONFIG_QCOM_BAM_DMA=y
-CONFIG_XILINX_DMA=y
-CONFIG_DMA_SUN6I=y
-CONFIG_ST_FDMA=m
 CONFIG_STAGING=y
-CONFIG_SENSORS_ISL29018=y
-CONFIG_SENSORS_ISL29028=y
 CONFIG_MFD_NVEC=y
 CONFIG_KEYBOARD_NVEC=y
 CONFIG_SERIO_NVEC_PS2=y
 CONFIG_NVEC_POWER=y
 CONFIG_NVEC_PAZ00=y
-CONFIG_BCMA=y
-CONFIG_BCMA_HOST_SOC=y
-CONFIG_BCMA_DRIVER_GMAC_CMN=y
-CONFIG_BCMA_DRIVER_GPIO=y
-CONFIG_QCOM_GSBI=y
-CONFIG_QCOM_PM=y
-CONFIG_QCOM_SMEM=y
-CONFIG_QCOM_SMD_RPM=y
-CONFIG_QCOM_SMP2P=y
-CONFIG_QCOM_SMSM=y
-CONFIG_QCOM_WCNSS_CTRL=m
-CONFIG_ROCKCHIP_PM_DOMAINS=y
-CONFIG_COMMON_CLK_QCOM=y
-CONFIG_QCOM_CLK_RPM=y
-CONFIG_CHROME_PLATFORMS=y
 CONFIG_STAGING_BOARD=y
-CONFIG_CROS_EC_CHARDEV=m
 CONFIG_COMMON_CLK_MAX77686=y
 CONFIG_COMMON_CLK_RK808=m
 CONFIG_COMMON_CLK_S2MPS11=m
+CONFIG_COMMON_CLK_QCOM=y
+CONFIG_QCOM_CLK_RPM=y
 CONFIG_APQ_MMCC_8084=y
 CONFIG_MSM_GCC_8660=y
 CONFIG_MSM_MMCC_8960=y
 CONFIG_MSM_MMCC_8974=y
-CONFIG_HWSPINLOCK_QCOM=y
+CONFIG_BCM2835_MBOX=y
 CONFIG_ROCKCHIP_IOMMU=y
 CONFIG_TEGRA_IOMMU_GART=y
 CONFIG_TEGRA_IOMMU_SMMU=y
 CONFIG_REMOTEPROC=m
 CONFIG_ST_REMOTEPROC=m
 CONFIG_RPMSG_VIRTIO=m
+CONFIG_RASPBERRYPI_POWER=y
+CONFIG_QCOM_GSBI=y
+CONFIG_QCOM_PM=y
+CONFIG_QCOM_SMD_RPM=m
+CONFIG_QCOM_WCNSS_CTRL=m
+CONFIG_ROCKCHIP_PM_DOMAINS=y
+CONFIG_ARCH_TEGRA_2x_SOC=y
+CONFIG_ARCH_TEGRA_3x_SOC=y
+CONFIG_ARCH_TEGRA_114_SOC=y
+CONFIG_ARCH_TEGRA_124_SOC=y
 CONFIG_PM_DEVFREQ=y
 CONFIG_ARM_TEGRA_DEVFREQ=m
-CONFIG_MEMORY=y
-CONFIG_EXTCON=y
 CONFIG_TI_AEMIF=y
 CONFIG_IIO=y
 CONFIG_IIO_SW_TRIGGER=y
 CONFIG_XILINX_XADC=y
 CONFIG_MPU3050_I2C=y
 CONFIG_CM36651=m
+CONFIG_SENSORS_ISL29018=y
+CONFIG_SENSORS_ISL29028=y
 CONFIG_AK8975=y
-CONFIG_RASPBERRYPI_POWER=y
 CONFIG_IIO_HRTIMER_TRIGGER=y
 CONFIG_PWM=y
 CONFIG_PWM_ATMEL=m
 CONFIG_PWM_ATMEL_HLCDC_PWM=m
 CONFIG_PWM_ATMEL_TCB=m
+CONFIG_PWM_BCM2835=y
+CONFIG_PWM_BRCMSTB=m
 CONFIG_PWM_FSL_FTM=m
 CONFIG_PWM_MESON=m
 CONFIG_PWM_RCAR=m
 CONFIG_PWM_RENESAS_TPU=y
 CONFIG_PWM_ROCKCHIP=m
 CONFIG_PWM_SAMSUNG=m
+CONFIG_PWM_STI=y
 CONFIG_PWM_SUN4I=y
 CONFIG_PWM_TEGRA=y
 CONFIG_PWM_VT8500=y
+CONFIG_KEYSTONE_IRQ=y
+CONFIG_PHY_SUN4I_USB=y
+CONFIG_PHY_SUN9I_USB=y
 CONFIG_PHY_HIX5HD2_SATA=y
-CONFIG_E1000E=y
+CONFIG_PHY_BERLIN_SATA=y
-CONFIG_PWM_STI=y
-CONFIG_PWM_BCM2835=y
-CONFIG_PWM_BRCMSTB=m
-CONFIG_PHY_DM816X_USB=m
-CONFIG_OMAP_USB2=y
-CONFIG_TI_PIPE3=y
-CONFIG_TWL4030_USB=m
 CONFIG_PHY_BERLIN_USB=y
 CONFIG_PHY_CPCAP_USB=m
-CONFIG_PHY_BERLIN_SATA=y
+CONFIG_PHY_QCOM_APQ8064_SATA=m
+CONFIG_PHY_RCAR_GEN2=m
 CONFIG_PHY_ROCKCHIP_DP=m
 CONFIG_PHY_ROCKCHIP_USB=y
-CONFIG_PHY_QCOM_APQ8064_SATA=m
+CONFIG_PHY_SAMSUNG_USB2=m
 CONFIG_PHY_MIPHY28LP=y
-CONFIG_PHY_RCAR_GEN2=m
 CONFIG_PHY_STIH407_USB=y
 CONFIG_PHY_STM32_USBPHYC=y
-CONFIG_PHY_SUN4I_USB=y
-CONFIG_PHY_SUN9I_USB=y
-CONFIG_PHY_SAMSUNG_USB2=m
 CONFIG_PHY_TEGRA_XUSB=y
-CONFIG_PHY_BRCM_SATA=y
+CONFIG_PHY_DM816X_USB=m
-CONFIG_NVMEM=y
+CONFIG_OMAP_USB2=y
+CONFIG_TI_PIPE3=y
+CONFIG_TWL4030_USB=m
 CONFIG_NVMEM_IMX_OCOTP=y
 CONFIG_NVMEM_SUNXI_SID=y
 CONFIG_NVMEM_VF610_OCOTP=y
-CONFIG_BCM2835_MBOX=y
 CONFIG_RASPBERRYPI_FIRMWARE=y
-CONFIG_EFI_VARS=m
-CONFIG_EFI_CAPSULE_LOADER=m
 CONFIG_BCM47XX_NVRAM=y
 CONFIG_BCM47XX_SPROM=y
+CONFIG_EFI_VARS=m
+CONFIG_EFI_CAPSULE_LOADER=m
 CONFIG_EXT4_FS=y
 CONFIG_AUTOFS4_FS=y
 CONFIG_MSDOS_FS=y
 CONFIG_NTFS_FS=y
 CONFIG_TMPFS_POSIX_ACL=y
 CONFIG_UBIFS_FS=y
-CONFIG_TMPFS=y
 CONFIG_SQUASHFS=y
 CONFIG_SQUASHFS_LZO=y
 CONFIG_SQUASHFS_XZ=y
 CONFIG_NLS_ISO8859_1=y
 CONFIG_NLS_UTF8=y
 CONFIG_PRINTK_TIME=y
-CONFIG_DEBUG_FS=y
 CONFIG_MAGIC_SYSRQ=y
-CONFIG_LOCKUP_DETECTOR=y
-CONFIG_CPUFREQ_DT=y
-CONFIG_KEYSTONE_IRQ=y
-CONFIG_HW_RANDOM=y
-CONFIG_HW_RANDOM_ST=y
 CONFIG_CRYPTO_USER=m
 CONFIG_CRYPTO_USER_API_HASH=m
 CONFIG_CRYPTO_USER_API_SKCIPHER=m
 CONFIG_CRYPTO_DEV_MARVELL_CESA=m
 CONFIG_CRYPTO_DEV_EXYNOS_RNG=m
 CONFIG_CRYPTO_DEV_S5P=m
+CONFIG_CRYPTO_DEV_ATMEL_AES=m
+CONFIG_CRYPTO_DEV_ATMEL_TDES=m
+CONFIG_CRYPTO_DEV_ATMEL_SHA=m
 CONFIG_CRYPTO_DEV_SUN4I_SS=m
 CONFIG_CRYPTO_DEV_ROCKCHIP=m
 CONFIG_ARM_CRYPTO=y
-CONFIG_CRYPTO_SHA1_ARM=m
 CONFIG_CRYPTO_SHA1_ARM_NEON=m
 CONFIG_CRYPTO_SHA1_ARM_CE=m
 CONFIG_CRYPTO_SHA2_ARM_CE=m
-CONFIG_CRYPTO_SHA256_ARM=m
 CONFIG_CRYPTO_SHA512_ARM=m
 CONFIG_CRYPTO_AES_ARM=m
 CONFIG_CRYPTO_AES_ARM_BS=m
 CONFIG_CRYPTO_AES_ARM_CE=m
-CONFIG_CRYPTO_CHACHA20_NEON=m
-CONFIG_CRYPTO_CRC32_ARM_CE=m
-CONFIG_CRYPTO_CRCT10DIF_ARM_CE=m
 CONFIG_CRYPTO_GHASH_ARM_CE=m
-CONFIG_CRYPTO_DEV_ATMEL_AES=m
+CONFIG_CRYPTO_CRC32_ARM_CE=m
-CONFIG_CRYPTO_DEV_ATMEL_TDES=m
+CONFIG_CRYPTO_CHACHA20_NEON=m
-CONFIG_CRYPTO_DEV_ATMEL_SHA=m
-CONFIG_VIDEO_VIVID=m
-CONFIG_VIRTIO=y
-CONFIG_VIRTIO_PCI=y
-CONFIG_VIRTIO_PCI_LEGACY=y
-CONFIG_VIRTIO_MMIO=y

arch/arm/mach-bcm/Kconfig+1−0

@@ -20,6 +20,7 @@ config ARCH_BCM_IPROC · 19 unmodified lines
20	select GPIOLIB	20	select GPIOLIB
21	select ARM_AMBA	21	select ARM_AMBA
22	select PINCTRL	22	select PINCTRL
		23	select PCI_DOMAINS if PCI
23	help	24	help
24	This enables support for systems based on Broadcom IPROC architected SoCs.	25	This enables support for systems based on Broadcom IPROC architected SoCs.
25	The IPROC complex contains one or more ARM CPUs along with common	26	The IPROC complex contains one or more ARM CPUs along with common

arch/arm/mach-davinci/board-da850-evm.c+1−1

@@ -774,7 +774,7 @@ static struct gpiod_lookup_table mmc_gpios_table = { · 773 unmodified lines
774	GPIO_LOOKUP("davinci_gpio.0", DA850_MMCSD_CD_PIN, "cd",	774	GPIO_LOOKUP("davinci_gpio.0", DA850_MMCSD_CD_PIN, "cd",
775	GPIO_ACTIVE_LOW),	775	GPIO_ACTIVE_LOW),
776	GPIO_LOOKUP("davinci_gpio.0", DA850_MMCSD_WP_PIN, "wp",	776	GPIO_LOOKUP("davinci_gpio.0", DA850_MMCSD_WP_PIN, "wp",
777	GPIO_ACTIVE_LOW),	777	GPIO_ACTIVE_HIGH),
778	},	778	},
779	};	779	};
780		780

arch/arm/mach-socfpga/Kconfig+1−0

@@ -10,6 +10,7 @@ menuconfig ARCH_SOCFPGA · 9 unmodified lines
10	select HAVE_ARM_SCU	10	select HAVE_ARM_SCU
11	select HAVE_ARM_TWD if SMP	11	select HAVE_ARM_TWD if SMP
12	select MFD_SYSCON	12	select MFD_SYSCON
		13	select PCI_DOMAINS if PCI
13		14
14	if ARCH_SOCFPGA	15	if ARCH_SOCFPGA
15	config SOCFPGA_SUSPEND	16	config SOCFPGA_SUSPEND

arch/arm/net/bpf_jit_32.c+1−1

@@ -1844,7 +1844,7 @@ struct bpf_prog bpf_int_jit_compile(struct bpf_prog prog) · 1843 unmodified lines
1844	/* there are 2 passes here */	1844	/* there are 2 passes here */
1845	bpf_jit_dump(prog->len, image_size, 2, ctx.target);	1845	bpf_jit_dump(prog->len, image_size, 2, ctx.target);
1846		1846
1847	set_memory_ro((unsigned long)header, header->pages);	1847	bpf_jit_binary_lock_ro(header);
1848	prog->bpf_func = (void *)ctx.target;	1848	prog->bpf_func = (void *)ctx.target;
1849	prog->jited = 1;	1849	prog->jited = 1;
1850	prog->jited_len = image_size;	1850	prog->jited_len = image_size;

arch/arm64/boot/dts/altera/socfpga_stratix10.dtsi+2−4

 			interrupts = <0 99 4>;
 			resets = <&rst SPIM0_RESET>;
 			reg-io-width = <4>;
-			num-chipselect = <4>;
+			num-cs = <4>;
-			bus-num = <0>;
 			status = "disabled";
 		};
 			interrupts = <0 100 4>;
 			resets = <&rst SPIM1_RESET>;
 			reg-io-width = <4>;
-			num-chipselect = <4>;
+			num-cs = <4>;
-			bus-num = <0>;
 			status = "disabled";
 		};

arch/arm64/boot/dts/amlogic/meson-axg-s400.dts+14−1

@@ -66,9 +66,22 @@ · 65 unmodified lines
66		66
67	&ethmac {	67	&ethmac {
68	status = "okay";	68	status = "okay";
69	phy-mode = "rgmii";
70	pinctrl-0 = <&eth_rgmii_y_pins>;	69	pinctrl-0 = <&eth_rgmii_y_pins>;
71	pinctrl-names = "default";	70	pinctrl-names = "default";
		71	phy-handle = <&eth_phy0>;
		72	phy-mode = "rgmii";
		73
		74	mdio {
		75	compatible = "snps,dwmac-mdio";
		76	#address-cells = <1>;
		77	#size-cells = <0>;
		78
		79	eth_phy0: ethernet-phy@0 {
		80	/* Realtek RTL8211F (0x001cc916) */
		81	reg = <0>;
		82	eee-broken-1000t;
		83	};
		84	};
72	};	85	};
73		86
74	&uart_A {	87	&uart_A {

arch/arm64/boot/dts/amlogic/meson-axg.dtsi+2−2

@@ -132,7 +132,7 @@ · 131 unmodified lines
132		132
133	sd_emmc_b: sd@5000 {	133	sd_emmc_b: sd@5000 {
134	compatible = "amlogic,meson-axg-mmc";	134	compatible = "amlogic,meson-axg-mmc";
135	reg = <0x0 0x5000 0x0 0x2000>;	135	reg = <0x0 0x5000 0x0 0x800>;
136	interrupts = <GIC_SPI 217 IRQ_TYPE_EDGE_RISING>;	136	interrupts = <GIC_SPI 217 IRQ_TYPE_EDGE_RISING>;
137	status = "disabled";	137	status = "disabled";
138	clocks = <&clkc CLKID_SD_EMMC_B>,	138	clocks = <&clkc CLKID_SD_EMMC_B>,
@@ -144,7 +144,7 @@ · 5 unmodified lines
144		144
145	sd_emmc_c: mmc@7000 {	145	sd_emmc_c: mmc@7000 {
146	compatible = "amlogic,meson-axg-mmc";	146	compatible = "amlogic,meson-axg-mmc";
147	reg = <0x0 0x7000 0x0 0x2000>;	147	reg = <0x0 0x7000 0x0 0x800>;
148	interrupts = <GIC_SPI 218 IRQ_TYPE_EDGE_RISING>;	148	interrupts = <GIC_SPI 218 IRQ_TYPE_EDGE_RISING>;
149	status = "disabled";	149	status = "disabled";
150	clocks = <&clkc CLKID_SD_EMMC_C>,	150	clocks = <&clkc CLKID_SD_EMMC_C>,

arch/arm64/boot/dts/amlogic/meson-gx.dtsi+9−3

 			no-map;
 		};
+		/* Alternate 3 MiB reserved for ARM Trusted Firmware (BL31) */
+		secmon_reserved_alt: secmon@5000000 {
+			reg = <0x0 0x05000000 0x0 0x300000>;
+			no-map;
+		};
 		linux,cma {
 			compatible = "shared-dma-pool";
 			reusable;
 			sd_emmc_a: mmc@70000 {
 				compatible = "amlogic,meson-gx-mmc", "amlogic,meson-gxbb-mmc";
-				reg = <0x0 0x70000 0x0 0x2000>;
+				reg = <0x0 0x70000 0x0 0x800>;
 				interrupts = <GIC_SPI 216 IRQ_TYPE_EDGE_RISING>;
 				status = "disabled";
 			};
 			sd_emmc_b: mmc@72000 {
 				compatible = "amlogic,meson-gx-mmc", "amlogic,meson-gxbb-mmc";
-				reg = <0x0 0x72000 0x0 0x2000>;
+				reg = <0x0 0x72000 0x0 0x800>;
 				interrupts = <GIC_SPI 217 IRQ_TYPE_EDGE_RISING>;
 				status = "disabled";
 			};
 			sd_emmc_c: mmc@74000 {
 				compatible = "amlogic,meson-gx-mmc", "amlogic,meson-gxbb-mmc";
-				reg = <0x0 0x74000 0x0 0x2000>;
+				reg = <0x0 0x74000 0x0 0x800>;
 				interrupts = <GIC_SPI 218 IRQ_TYPE_EDGE_RISING>;
 				status = "disabled";
 			};

arch/arm64/boot/dts/amlogic/meson-gxl-mali.dtsi+1−1

@@ -6,7 +6,7 @@ · 5 unmodified lines
6		6
7	&apb {	7	&apb {
8	mali: gpu@c0000 {	8	mali: gpu@c0000 {
9	compatible = "amlogic,meson-gxbb-mali", "arm,mali-450";	9	compatible = "amlogic,meson-gxl-mali", "arm,mali-450";
10	reg = <0x0 0xc0000 0x0 0x40000>;	10	reg = <0x0 0xc0000 0x0 0x40000>;
11	interrupts = <GIC_SPI 160 IRQ_TYPE_LEVEL_HIGH>,	11	interrupts = <GIC_SPI 160 IRQ_TYPE_LEVEL_HIGH>,
12	<GIC_SPI 161 IRQ_TYPE_LEVEL_HIGH>,	12	<GIC_SPI 161 IRQ_TYPE_LEVEL_HIGH>,

arch/arm64/boot/dts/amlogic/meson-gxl-s905x-libretech-cc.dts+0−3

@@ -234,9 +234,6 @@ · 233 unmodified lines
234		234
235	bus-width = <4>;	235	bus-width = <4>;
236	cap-sd-highspeed;	236	cap-sd-highspeed;
237	sd-uhs-sdr12;
238	sd-uhs-sdr25;
239	sd-uhs-sdr50;
240	max-frequency = <100000000>;	237	max-frequency = <100000000>;
241	disable-wp;	238	disable-wp;
242		239

arch/arm64/boot/dts/amlogic/meson-gxl-s905x-p212.dtsi+7−0

@@ -189,3 +189,10 @@ · 188 unmodified lines
189	&usb0 {	189	&usb0 {
190	status = "okay";	190	status = "okay";
191	};	191	};
		192
		193	&usb2_phy0 {
		194	/*
		195	* HDMI_5V is also used as supply for the USB VBUS.
		196	*/
		197	phy-supply = <&hdmi_5v>;
		198	};

arch/arm64/boot/dts/amlogic/meson-gxl.dtsi+0−8

@@ -13,14 +13,6 @@ · 12 unmodified lines
13	/ {	13	/ {
14	compatible = "amlogic,meson-gxl";	14	compatible = "amlogic,meson-gxl";
15		15
16	reserved-memory {
17	/* Alternate 3 MiB reserved for ARM Trusted Firmware (BL31) */
18	secmon_reserved_alt: secmon@5000000 {
19	reg = <0x0 0x05000000 0x0 0x300000>;
20	no-map;
21	};
22	};
23
24	soc {	16	soc {
25	usb0: usb@c9000000 {	17	usb0: usb@c9000000 {
26	status = "disabled";	18	status = "disabled";

arch/arm64/boot/dts/broadcom/northstar2/ns2.dtsi+4−4

@@ -118,7 +118,7 @@ · 117 unmodified lines
118		118
119	#interrupt-cells = <1>;	119	#interrupt-cells = <1>;
120	interrupt-map-mask = <0 0 0 0>;	120	interrupt-map-mask = <0 0 0 0>;
121	interrupt-map = <0 0 0 0 &gic 0 GIC_SPI 281 IRQ_TYPE_NONE>;	121	interrupt-map = <0 0 0 0 &gic 0 GIC_SPI 281 IRQ_TYPE_LEVEL_HIGH>;
122		122
123	linux,pci-domain = <0>;	123	linux,pci-domain = <0>;
124		124
@@ -149,7 +149,7 @@ · 24 unmodified lines
149		149
150	#interrupt-cells = <1>;	150	#interrupt-cells = <1>;
151	interrupt-map-mask = <0 0 0 0>;	151	interrupt-map-mask = <0 0 0 0>;
152	interrupt-map = <0 0 0 0 &gic 0 GIC_SPI 305 IRQ_TYPE_NONE>;	152	interrupt-map = <0 0 0 0 &gic 0 GIC_SPI 305 IRQ_TYPE_LEVEL_HIGH>;
153		153
154	linux,pci-domain = <4>;	154	linux,pci-domain = <4>;
155		155
@@ -566,7 +566,7 @@ · 410 unmodified lines
566	reg = <0x66080000 0x100>;	566	reg = <0x66080000 0x100>;
567	#address-cells = <1>;	567	#address-cells = <1>;
568	#size-cells = <0>;	568	#size-cells = <0>;
569	interrupts = <GIC_SPI 394 IRQ_TYPE_NONE>;	569	interrupts = <GIC_SPI 394 IRQ_TYPE_LEVEL_HIGH>;
570	clock-frequency = <100000>;	570	clock-frequency = <100000>;
571	status = "disabled";	571	status = "disabled";
572	};	572	};
@@ -594,7 +594,7 @@ · 21 unmodified lines
594	reg = <0x660b0000 0x100>;	594	reg = <0x660b0000 0x100>;
595	#address-cells = <1>;	595	#address-cells = <1>;
596	#size-cells = <0>;	596	#size-cells = <0>;
597	interrupts = <GIC_SPI 395 IRQ_TYPE_NONE>;	597	interrupts = <GIC_SPI 395 IRQ_TYPE_LEVEL_HIGH>;
598	clock-frequency = <100000>;	598	clock-frequency = <100000>;
599	status = "disabled";	599	status = "disabled";
600	};	600	};

arch/arm64/boot/dts/broadcom/stingray/bcm958742k.dts+4−0

 	enet-phy-lane-swap;
 };
+&sdio0 {
+	mmc-ddr-1_8v;
+};
 &uart2 {
 	status = "okay";
 };

arch/arm64/boot/dts/broadcom/stingray/bcm958742t.dts+4−0

@@ -42,3 +42,7 @@ · 41 unmodified lines
42	&gphy0 {	42	&gphy0 {
43	enet-phy-lane-swap;	43	enet-phy-lane-swap;
44	};	44	};
		45
		46	&sdio0 {
		47	mmc-ddr-1_8v;
		48	};

arch/arm64/boot/dts/broadcom/stingray/stingray.dtsi+2−2

@@ -409,7 +409,7 @@ · 408 unmodified lines
409	reg = <0x000b0000 0x100>;	409	reg = <0x000b0000 0x100>;
410	#address-cells = <1>;	410	#address-cells = <1>;
411	#size-cells = <0>;	411	#size-cells = <0>;
412	interrupts = <GIC_SPI 177 IRQ_TYPE_NONE>;	412	interrupts = <GIC_SPI 177 IRQ_TYPE_LEVEL_HIGH>;
413	clock-frequency = <100000>;	413	clock-frequency = <100000>;
414	status = "disabled";	414	status = "disabled";
415	};	415	};
@@ -453,7 +453,7 @@ · 37 unmodified lines
453	reg = <0x000e0000 0x100>;	453	reg = <0x000e0000 0x100>;
454	#address-cells = <1>;	454	#address-cells = <1>;
455	#size-cells = <0>;	455	#size-cells = <0>;
456	interrupts = <GIC_SPI 178 IRQ_TYPE_NONE>;	456	interrupts = <GIC_SPI 178 IRQ_TYPE_LEVEL_HIGH>;
457	clock-frequency = <100000>;	457	clock-frequency = <100000>;
458	status = "disabled";	458	status = "disabled";
459	};	459	};

arch/arm64/boot/dts/hisilicon/hi3660-hikey960.dts+2−0

 	vmmc-supply = <&wlan_en>;
 	ti,non-removable;
 	non-removable;
+	cap-power-off-card;
+	keep-power-in-suspend;
 	#address-cells = <0x1>;
 	#size-cells = <0x0>;
 	status = "ok";

arch/arm64/boot/dts/hisilicon/hi6220-hikey.dts+2−0

@@ -322,6 +322,8 @@ · 321 unmodified lines
322	dwmmc_2: dwmmc2@f723f000 {	322	dwmmc_2: dwmmc2@f723f000 {
323	bus-width = <0x4>;	323	bus-width = <0x4>;
324	non-removable;	324	non-removable;
		325	cap-power-off-card;
		326	keep-power-in-suspend;
325	vmmc-supply = <&reg_vdd_3v3>;	327	vmmc-supply = <&reg_vdd_3v3>;
326	mmc-pwrseq = <&wl1835_pwrseq>;	328	mmc-pwrseq = <&wl1835_pwrseq>;
327		329

arch/arm64/boot/dts/marvell/armada-cp110.dtsi+1−1

@@ -149,7 +149,7 @@ · 148 unmodified lines
149		149
150	CP110_LABEL(icu): interrupt-controller@1e0000 {	150	CP110_LABEL(icu): interrupt-controller@1e0000 {
151	compatible = "marvell,cp110-icu";	151	compatible = "marvell,cp110-icu";
152	reg = <0x1e0000 0x10>;	152	reg = <0x1e0000 0x440>;
153	#interrupt-cells = <3>;	153	#interrupt-cells = <3>;
154	interrupt-controller;	154	interrupt-controller;
155	msi-parent = <&gicp>;	155	msi-parent = <&gicp>;

arch/arm64/boot/dts/qcom/apq8096-db820c.dtsi+1−1

@@ -75,7 +75,7 @@ · 74 unmodified lines
75		75
76	serial@75b1000 {	76	serial@75b1000 {
77	label = "LS-UART0";	77	label = "LS-UART0";
78	status = "okay";	78	status = "disabled";
79	pinctrl-names = "default", "sleep";	79	pinctrl-names = "default", "sleep";
80	pinctrl-0 = <&blsp2_uart2_4pins_default>;	80	pinctrl-0 = <&blsp2_uart2_4pins_default>;
81	pinctrl-1 = <&blsp2_uart2_4pins_sleep>;	81	pinctrl-1 = <&blsp2_uart2_4pins_sleep>;

arch/arm64/boot/dts/qcom/msm8916.dtsi+2−2

@@ -1191,14 +1191,14 @@ · 1190 unmodified lines
1191		1191
1192	port@0 {	1192	port@0 {
1193	reg = <0>;	1193	reg = <0>;
1194	etf_out: endpoint {	1194	etf_in: endpoint {
1195	slave-mode;	1195	slave-mode;
1196	remote-endpoint = <&funnel0_out>;	1196	remote-endpoint = <&funnel0_out>;
1197	};	1197	};
1198	};	1198	};
1199	port@1 {	1199	port@1 {
1200	reg = <0>;	1200	reg = <0>;
1201	etf_in: endpoint {	1201	etf_out: endpoint {
1202	remote-endpoint = <&replicator_in>;	1202	remote-endpoint = <&replicator_in>;
1203	};	1203	};
1204	};	1204	};

arch/arm64/boot/dts/socionext/uniphier-ld11-global.dts+1−1

@@ -54,7 +54,7 @@ · 53 unmodified lines
54	sound {	54	sound {
55	compatible = "audio-graph-card";	55	compatible = "audio-graph-card";
56	label = "UniPhier LD11";	56	label = "UniPhier LD11";
57	widgets = "Headphone", "Headphone Jack";	57	widgets = "Headphone", "Headphones";
58	dais = <&i2s_port2	58	dais = <&i2s_port2
59	&i2s_port3	59	&i2s_port3
60	&i2s_port4	60	&i2s_port4

arch/arm64/boot/dts/socionext/uniphier-ld20-global.dts+1−1

@@ -54,7 +54,7 @@ · 53 unmodified lines
54	sound {	54	sound {
55	compatible = "audio-graph-card";	55	compatible = "audio-graph-card";
56	label = "UniPhier LD20";	56	label = "UniPhier LD20";
57	widgets = "Headphone", "Headphone Jack";	57	widgets = "Headphone", "Headphones";
58	dais = <&i2s_port2	58	dais = <&i2s_port2
59	&i2s_port3	59	&i2s_port3
60	&i2s_port4	60	&i2s_port4

arch/arm64/configs/defconfig+39−63

 CONFIG_ARCH_QCOM=y
 CONFIG_ARCH_ROCKCHIP=y
 CONFIG_ARCH_SEATTLE=y
+CONFIG_ARCH_SYNQUACER=y
 CONFIG_ARCH_RENESAS=y
 CONFIG_ARCH_R8A7795=y
 CONFIG_ARCH_R8A7796=y
 CONFIG_ARCH_STRATIX10=y
 CONFIG_ARCH_TEGRA=y
 CONFIG_ARCH_SPRD=y
-CONFIG_ARCH_SYNQUACER=y
 CONFIG_ARCH_THUNDER=y
 CONFIG_ARCH_THUNDER2=y
 CONFIG_ARCH_UNIPHIER=y
 CONFIG_ARCH_ZX=y
 CONFIG_ARCH_ZYNQMP=y
 CONFIG_PCI=y
-CONFIG_HOTPLUG_PCI_PCIE=y
 CONFIG_PCI_IOV=y
 CONFIG_HOTPLUG_PCI=y
 CONFIG_HOTPLUG_PCI_ACPI=y
-CONFIG_PCI_LAYERSCAPE=y
-CONFIG_PCI_HISI=y
-CONFIG_PCIE_QCOM=y
-CONFIG_PCIE_KIRIN=y
-CONFIG_PCIE_ARMADA_8K=y
-CONFIG_PCIE_HISI_STB=y
 CONFIG_PCI_AARDVARK=y
 CONFIG_PCI_TEGRA=y
 CONFIG_PCIE_RCAR=y
-CONFIG_PCIE_ROCKCHIP=y
-CONFIG_PCIE_ROCKCHIP_HOST=m
 CONFIG_PCI_HOST_GENERIC=y
 CONFIG_PCI_XGENE=y
 CONFIG_PCI_HOST_THUNDER_PEM=y
 CONFIG_PCI_HOST_THUNDER_ECAM=y
+CONFIG_PCIE_ROCKCHIP_HOST=m
+CONFIG_PCI_LAYERSCAPE=y
+CONFIG_PCI_HISI=y
+CONFIG_PCIE_QCOM=y
+CONFIG_PCIE_ARMADA_8K=y
+CONFIG_PCIE_KIRIN=y
+CONFIG_PCIE_HISI_STB=y
 CONFIG_ARM64_VA_BITS_48=y
 CONFIG_SCHED_MC=y
 CONFIG_NUMA=y
 CONFIG_WQ_POWER_EFFICIENT_DEFAULT=y
 CONFIG_ARM_CPUIDLE=y
 CONFIG_CPU_FREQ=y
-CONFIG_CPU_FREQ_GOV_ATTR_SET=y
-CONFIG_CPU_FREQ_GOV_COMMON=y
 CONFIG_CPU_FREQ_STAT=y
 CONFIG_CPU_FREQ_GOV_POWERSAVE=m
 CONFIG_CPU_FREQ_GOV_USERSPACE=y
 CONFIG_CPU_FREQ_GOV_CONSERVATIVE=m
 CONFIG_CPU_FREQ_GOV_SCHEDUTIL=y
 CONFIG_CPUFREQ_DT=y
+CONFIG_ACPI_CPPC_CPUFREQ=m
 CONFIG_ARM_ARMADA_37XX_CPUFREQ=y
 CONFIG_ARM_BIG_LITTLE_CPUFREQ=y
 CONFIG_ARM_SCPI_CPUFREQ=y
 CONFIG_ARM_TEGRA186_CPUFREQ=y
-CONFIG_ACPI_CPPC_CPUFREQ=m
 CONFIG_NET=y
 CONFIG_PACKET=y
 CONFIG_UNIX=y
 CONFIG_SNI_AVE=y
 CONFIG_SNI_NETSEC=y
 CONFIG_STMMAC_ETH=m
-CONFIG_DWMAC_IPQ806X=m
-CONFIG_DWMAC_MESON=m
-CONFIG_DWMAC_ROCKCHIP=m
-CONFIG_DWMAC_SUNXI=m
-CONFIG_DWMAC_SUN8I=m
 CONFIG_MDIO_BUS_MUX_MMIOREG=y
 CONFIG_AT803X_PHY=m
 CONFIG_MARVELL_PHY=m
 CONFIG_WLCORE_SDIO=m
 CONFIG_INPUT_EVDEV=y
 CONFIG_KEYBOARD_ADC=m
-CONFIG_KEYBOARD_CROS_EC=y
 CONFIG_KEYBOARD_GPIO=y
+CONFIG_KEYBOARD_CROS_EC=y
 CONFIG_INPUT_TOUCHSCREEN=y
 CONFIG_TOUCHSCREEN_ATMEL_MXT=m
 CONFIG_INPUT_MISC=y
 CONFIG_SERIAL_SAMSUNG_CONSOLE=y
 CONFIG_SERIAL_TEGRA=y
 CONFIG_SERIAL_SH_SCI=y
-CONFIG_SERIAL_SH_SCI_NR_UARTS=11
-CONFIG_SERIAL_SH_SCI_CONSOLE=y
 CONFIG_SERIAL_MSM=y
 CONFIG_SERIAL_MSM_CONSOLE=y
 CONFIG_SERIAL_XILINX_PS_UART=y
 CONFIG_SERIAL_XILINX_PS_UART_CONSOLE=y
 CONFIG_SERIAL_MVEBU_UART=y
 CONFIG_SERIAL_DEV_BUS=y
-CONFIG_SERIAL_DEV_CTRL_TTYPORT=y
 CONFIG_VIRTIO_CONSOLE=y
-CONFIG_I2C_HID=m
 CONFIG_I2C_CHARDEV=y
 CONFIG_I2C_MUX=y
 CONFIG_I2C_MUX_PCA954x=y
 CONFIG_I2C_CROS_EC_TUNNEL=y
 CONFIG_SPI=y
 CONFIG_SPI_ARMADA_3700=y
-CONFIG_SPI_MESON_SPICC=m
-CONFIG_SPI_MESON_SPIFC=m
 CONFIG_SPI_BCM2835=m
 CONFIG_SPI_BCM2835AUX=m
+CONFIG_SPI_MESON_SPICC=m
+CONFIG_SPI_MESON_SPIFC=m
 CONFIG_SPI_ORION=y
 CONFIG_SPI_PL022=y
-CONFIG_SPI_QUP=y
 CONFIG_SPI_ROCKCHIP=y
+CONFIG_SPI_QUP=y
 CONFIG_SPI_S3C64XX=y
 CONFIG_SPI_SPIDEV=m
 CONFIG_SPMI=y
-CONFIG_PINCTRL_IPQ8074=y
 CONFIG_PINCTRL_SINGLE=y
 CONFIG_PINCTRL_MAX77620=y
+CONFIG_PINCTRL_IPQ8074=y
 CONFIG_PINCTRL_MSM8916=y
 CONFIG_PINCTRL_MSM8994=y
 CONFIG_PINCTRL_MSM8996=y
-CONFIG_PINCTRL_MT7622=y
 CONFIG_PINCTRL_QDF2XXX=y
 CONFIG_PINCTRL_QCOM_SPMI_PMIC=y
+CONFIG_PINCTRL_MT7622=y
 CONFIG_GPIO_DWAPB=y
 CONFIG_GPIO_MB86S7X=y
 CONFIG_GPIO_PL061=y
 CONFIG_THERMAL_GOV_POWER_ALLOCATOR=y
 CONFIG_CPU_THERMAL=y
 CONFIG_THERMAL_EMULATION=y
+CONFIG_ROCKCHIP_THERMAL=m
+CONFIG_RCAR_GEN3_THERMAL=y
 CONFIG_ARMADA_THERMAL=y
 CONFIG_BRCMSTB_THERMAL=m
 CONFIG_EXYNOS_THERMAL=y
-CONFIG_RCAR_GEN3_THERMAL=y
-CONFIG_QCOM_TSENS=y
-CONFIG_ROCKCHIP_THERMAL=m
 CONFIG_TEGRA_BPMP_THERMAL=m
+CONFIG_QCOM_TSENS=y
 CONFIG_UNIPHIER_THERMAL=y
 CONFIG_WATCHDOG=y
 CONFIG_S3C2410_WATCHDOG=y
 CONFIG_MFD_SPMI_PMIC=y
 CONFIG_MFD_RK808=y
 CONFIG_MFD_SEC_CORE=y
+CONFIG_REGULATOR_FIXED_VOLTAGE=y
 CONFIG_REGULATOR_AXP20X=y
 CONFIG_REGULATOR_FAN53555=y
-CONFIG_REGULATOR_FIXED_VOLTAGE=y
 CONFIG_REGULATOR_GPIO=y
 CONFIG_REGULATOR_HI6421V530=y
 CONFIG_REGULATOR_HI655X=y
 CONFIG_REGULATOR_QCOM_SPMI=y
 CONFIG_REGULATOR_RK808=y
 CONFIG_REGULATOR_S2MPS11=y
+CONFIG_RC_CORE=m
+CONFIG_RC_DECODERS=y
+CONFIG_RC_DEVICES=y
+CONFIG_IR_MESON=m
 CONFIG_MEDIA_SUPPORT=m
 CONFIG_MEDIA_CAMERA_SUPPORT=y
 CONFIG_MEDIA_ANALOG_TV_SUPPORT=y
 CONFIG_MEDIA_DIGITAL_TV_SUPPORT=y
 CONFIG_MEDIA_CONTROLLER=y
-CONFIG_MEDIA_RC_SUPPORT=y
-CONFIG_RC_CORE=m
-CONFIG_RC_DEVICES=y
-CONFIG_RC_DECODERS=y
-CONFIG_IR_MESON=m
 CONFIG_VIDEO_V4L2_SUBDEV_API=y
 # CONFIG_DVB_NET is not set
 CONFIG_V4L_MEM2MEM_DRIVERS=y
 CONFIG_ROCKCHIP_DW_MIPI_DSI=y
 CONFIG_ROCKCHIP_INNO_HDMI=y
 CONFIG_DRM_RCAR_DU=m
-CONFIG_DRM_RCAR_LVDS=y
+CONFIG_DRM_RCAR_LVDS=m
-CONFIG_DRM_RCAR_VSP=y
 CONFIG_DRM_TEGRA=m
 CONFIG_DRM_PANEL_SIMPLE=m
 CONFIG_DRM_I2C_ADV7511=m
 CONFIG_BACKLIGHT_GENERIC=m
 CONFIG_BACKLIGHT_PWM=m
 CONFIG_BACKLIGHT_LP855X=m
-CONFIG_FRAMEBUFFER_CONSOLE=y
 CONFIG_LOGO=y
 # CONFIG_LOGO_LINUX_MONO is not set
 # CONFIG_LOGO_LINUX_VGA16 is not set
 CONFIG_SND_SOC_AK4613=m
 CONFIG_SND_SIMPLE_CARD=m
 CONFIG_SND_AUDIO_GRAPH_CARD=m
+CONFIG_I2C_HID=m
 CONFIG_USB=y
 CONFIG_USB_OTG=y
 CONFIG_USB_XHCI_HCD=y
 CONFIG_MMC_ARMMMCI=y
 CONFIG_MMC_SDHCI=y
 CONFIG_MMC_SDHCI_ACPI=y
-CONFIG_MMC_SDHCI_F_SDH30=y
 CONFIG_MMC_SDHCI_PLTFM=y
 CONFIG_MMC_SDHCI_OF_ARASAN=y
 CONFIG_MMC_SDHCI_OF_ESDHC=y
 CONFIG_MMC_SDHCI_CADENCE=y
 CONFIG_MMC_SDHCI_TEGRA=y
+CONFIG_MMC_SDHCI_F_SDH30=y
 CONFIG_MMC_MESON_GX=y
 CONFIG_MMC_SDHCI_MSM=y
 CONFIG_MMC_SPI=y
 CONFIG_LEDS_GPIO=y
 CONFIG_LEDS_PWM=y
 CONFIG_LEDS_SYSCON=y
+CONFIG_LEDS_TRIGGER_DISK=y
 CONFIG_LEDS_TRIGGER_HEARTBEAT=y
 CONFIG_LEDS_TRIGGER_CPU=y
 CONFIG_LEDS_TRIGGER_DEFAULT_ON=y
 CONFIG_LEDS_TRIGGER_PANIC=y
-CONFIG_LEDS_TRIGGER_DISK=y
 CONFIG_EDAC=y
 CONFIG_EDAC_GHES=y
 CONFIG_RTC_CLASS=y
 CONFIG_RTC_DRV_S5M=y
 CONFIG_RTC_DRV_DS3232=y
 CONFIG_RTC_DRV_EFI=y
+CONFIG_RTC_DRV_CROS_EC=y
 CONFIG_RTC_DRV_S3C=y
 CONFIG_RTC_DRV_PL031=y
 CONFIG_RTC_DRV_SUN6I=y
 CONFIG_RTC_DRV_ARMADA38X=y
 CONFIG_RTC_DRV_TEGRA=y
 CONFIG_RTC_DRV_XGENE=y
-CONFIG_RTC_DRV_CROS_EC=y
 CONFIG_DMADEVICES=y
 CONFIG_DMA_BCM2835=m
 CONFIG_K3_DMA=y
 CONFIG_ARM_MHU=y
 CONFIG_PLATFORM_MHU=y
 CONFIG_BCM2835_MBOX=y
-CONFIG_HI6220_MBOX=y
 CONFIG_QCOM_APCS_IPC=y
 CONFIG_ROCKCHIP_IOMMU=y
 CONFIG_TEGRA_IOMMU_SMMU=y
 CONFIG_EXTCON_USB_GPIO=y
 CONFIG_EXTCON_USBC_CROS_EC=y
 CONFIG_MEMORY=y
-CONFIG_TEGRA_MC=y
 CONFIG_IIO=y
 CONFIG_EXYNOS_ADC=y
 CONFIG_ROCKCHIP_SARADC=m
 CONFIG_PWM_ROCKCHIP=y
 CONFIG_PWM_SAMSUNG=y
 CONFIG_PWM_TEGRA=m
+CONFIG_PHY_XGENE=y
+CONFIG_PHY_SUN4I_USB=y
+CONFIG_PHY_HI6220_USB=y
 CONFIG_PHY_HISTB_COMBPHY=y
 CONFIG_PHY_HISI_INNO_USB2=y
-CONFIG_PHY_RCAR_GEN3_USB2=y
-CONFIG_PHY_RCAR_GEN3_USB3=m
-CONFIG_PHY_HI6220_USB=y
-CONFIG_PHY_QCOM_USB_HS=y
-CONFIG_PHY_SUN4I_USB=y
 CONFIG_PHY_MVEBU_CP110_COMPHY=y
 CONFIG_PHY_QCOM_QMP=m
-CONFIG_PHY_ROCKCHIP_INNO_USB2=y
+CONFIG_PHY_QCOM_USB_HS=y
+CONFIG_PHY_RCAR_GEN3_USB2=y
+CONFIG_PHY_RCAR_GEN3_USB3=m
 CONFIG_PHY_ROCKCHIP_EMMC=y
+CONFIG_PHY_ROCKCHIP_INNO_USB2=y
 CONFIG_PHY_ROCKCHIP_PCIE=m
 CONFIG_PHY_ROCKCHIP_TYPEC=y
-CONFIG_PHY_XGENE=y
 CONFIG_PHY_TEGRA_XUSB=y
 CONFIG_QCOM_L2_PMU=y
 CONFIG_QCOM_L3_PMU=y
-CONFIG_MESON_EFUSE=m
 CONFIG_QCOM_QFPROM=y
 CONFIG_ROCKCHIP_EFUSE=y
 CONFIG_UNIPHIER_EFUSE=y
+CONFIG_MESON_EFUSE=m
 CONFIG_TEE=y
 CONFIG_OPTEE=y
 CONFIG_ARM_SCPI_PROTOCOL=y
 CONFIG_ACPI=y
 CONFIG_ACPI_APEI=y
 CONFIG_ACPI_APEI_GHES=y
-CONFIG_ACPI_APEI_PCIEAER=y
 CONFIG_ACPI_APEI_MEMORY_FAILURE=y
 CONFIG_ACPI_APEI_EINJ=y
 CONFIG_EXT2_FS=y
 CONFIG_DEBUG_FS=y
 CONFIG_MAGIC_SYSRQ=y
 CONFIG_DEBUG_KERNEL=y
-CONFIG_LOCKUP_DETECTOR=y
 # CONFIG_SCHED_DEBUG is not set
 # CONFIG_DEBUG_PREEMPT is not set
 # CONFIG_FTRACE is not set
 CONFIG_CRYPTO_ECHAINIV=y
 CONFIG_CRYPTO_ANSI_CPRNG=y
 CONFIG_ARM64_CRYPTO=y
-CONFIG_CRYPTO_SHA256_ARM64=m
-CONFIG_CRYPTO_SHA512_ARM64=m
 CONFIG_CRYPTO_SHA1_ARM64_CE=y
 CONFIG_CRYPTO_SHA2_ARM64_CE=y
+CONFIG_CRYPTO_SHA512_ARM64_CE=m
+CONFIG_CRYPTO_SHA3_ARM64=m
+CONFIG_CRYPTO_SM3_ARM64_CE=m
 CONFIG_CRYPTO_GHASH_ARM64_CE=y
 CONFIG_CRYPTO_CRCT10DIF_ARM64_CE=m
 CONFIG_CRYPTO_CRC32_ARM64_CE=m
-CONFIG_CRYPTO_AES_ARM64=m
-CONFIG_CRYPTO_AES_ARM64_CE=m
 CONFIG_CRYPTO_AES_ARM64_CE_CCM=y
 CONFIG_CRYPTO_AES_ARM64_CE_BLK=y
-CONFIG_CRYPTO_AES_ARM64_NEON_BLK=m
 CONFIG_CRYPTO_CHACHA20_NEON=m
 CONFIG_CRYPTO_AES_ARM64_BS=m
-CONFIG_CRYPTO_SHA512_ARM64_CE=m
-CONFIG_CRYPTO_SHA3_ARM64=m
-CONFIG_CRYPTO_SM3_ARM64_CE=m

arch/arm64/include/asm/alternative.h+6−1

@@ -28,7 +28,12 @@ typedef void (alternative_cb_t)(struct alt_instr alt, · 27 unmodified lines
28	__le32 origptr, __le32 updptr, int nr_inst);	28	__le32 origptr, __le32 updptr, int nr_inst);
29		29
30	void __init apply_alternatives_all(void);	30	void __init apply_alternatives_all(void);
31	void apply_alternatives(void *start, size_t length);	31
		32	#ifdef CONFIG_MODULES
		33	void apply_alternatives_module(void *start, size_t length);
		34	#else
		35	static inline void apply_alternatives_module(void *start, size_t length) { }
		36	#endif
32		37
33	#define ALTINSTR_ENTRY(feature,cb) \	38	#define ALTINSTR_ENTRY(feature,cb) \
34	" .word 661b - .\n" /* label */ \	39	" .word 661b - .\n" /* label */ \

arch/arm64/include/asm/pgtable.h+1−5

 	 * Only if the new pte is valid and kernel, otherwise TLB maintenance
 	 * or update_mmu_cache() have the necessary barriers.
 	 */
-	if (pte_valid_not_user(pte)) {
+	if (pte_valid_not_user(pte))
 		dsb(ishst);
-		isb();
-	}
 }
 extern void __sync_icache_dcache(pte_t pteval);
 {
 	WRITE_ONCE(*pmdp, pmd);
 	dsb(ishst);
-	isb();
 }
 static inline void pmd_clear(pmd_t *pmdp)
 {
 	WRITE_ONCE(*pudp, pud);
 	dsb(ishst);
-	isb();
 }
 static inline void pud_clear(pud_t *pudp)

arch/arm64/kernel/alternative.c+44−7

 	}
 }
-static void __apply_alternatives(void *alt_region, bool use_linear_alias)
+/*
+ * We provide our own, private D-cache cleaning function so that we don't
+ * accidentally call into the cache.S code, which is patched by us at
+ * runtime.
+ */
+static void clean_dcache_range_nopatch(u64 start, u64 end)
+{
+	u64 cur, d_size, ctr_el0;
+	ctr_el0 = read_sanitised_ftr_reg(SYS_CTR_EL0);
+	d_size = 4 << cpuid_feature_extract_unsigned_field(ctr_el0,
+							   CTR_DMINLINE_SHIFT);
+	cur = start & ~(d_size - 1);
+	do {
+		/*
+		 * We must clean+invalidate to the PoC in order to avoid
+		 * Cortex-A53 errata 826319, 827319, 824069 and 819472
+		 * (this corresponds to ARM64_WORKAROUND_CLEAN_CACHE)
+		 */
+		asm volatile("dc civac, %0" : : "r" (cur) : "memory");
+	} while (cur += d_size, cur < end);
+}
+static void __apply_alternatives(void *alt_region, bool is_module)
 {
 	struct alt_instr *alt;
 	struct alt_region *region = alt_region;
 		pr_info_once("patching kernel code\n");
 		origptr = ALT_ORIG_PTR(alt);
-		updptr = use_linear_alias ? lm_alias(origptr) : origptr;
+		updptr = is_module ? origptr : lm_alias(origptr);
 		nr_inst = alt->orig_len / AARCH64_INSN_SIZE;
 		if (alt->cpufeature < ARM64_CB_PATCH)
 		alt_cb(alt, origptr, updptr, nr_inst);
-		flush_icache_range((uintptr_t)origptr,
+		if (!is_module) {
-				   (uintptr_t)(origptr + nr_inst));
+			clean_dcache_range_nopatch((u64)origptr,
+						   (u64)(origptr + nr_inst));
+		}
+	}
+	/*
+	 * The core module code takes care of cache maintenance in
+	 * flush_module_icache().
+	 */
+	if (!is_module) {
+		dsb(ish);
+		__flush_icache_all();
+		isb();
 	}
 }
 		isb();
 	} else {
 		BUG_ON(alternatives_applied);
-		__apply_alternatives(&region, true);
+		__apply_alternatives(&region, false);
 		/* Barriers provided by the cache flushing */
 		WRITE_ONCE(alternatives_applied, 1);
 	}
 	stop_machine(__apply_alternatives_multi_stop, NULL, cpu_online_mask);
 }
-void apply_alternatives(void *start, size_t length)
+#ifdef CONFIG_MODULES
+void apply_alternatives_module(void *start, size_t length)
 {
 	struct alt_region region = {
 		.begin	= start,
 		.end	= start + length,
 	};
-	__apply_alternatives(&region, false);
+	__apply_alternatives(&region, true);
 }
+#endif

arch/arm64/kernel/module.c+2−3

 	const char *secstrs = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
 	for (s = sechdrs, se = sechdrs + hdr->e_shnum; s < se; s++) {
-		if (strcmp(".altinstructions", secstrs + s->sh_name) == 0) {
+		if (strcmp(".altinstructions", secstrs + s->sh_name) == 0)
-			apply_alternatives((void *)s->sh_addr, s->sh_size);
+			apply_alternatives_module((void *)s->sh_addr, s->sh_size);
-		}
 #ifdef CONFIG_ARM64_MODULE_PLTS
 		if (IS_ENABLED(CONFIG_DYNAMIC_FTRACE) &&
 		    !strcmp(".text.ftrace_trampoline", secstrs + s->sh_name))

arch/microblaze/Kconfig.debug+0−7

@@ -8,11 +8,4 @@ config TRACE_IRQFLAGS_SUPPORT · 7 unmodified lines
8		8
9	source "lib/Kconfig.debug"	9	source "lib/Kconfig.debug"
10		10
11	config HEART_BEAT
12	bool "Heart beat function for kernel"
13	default n
14	help
15	This option turns on/off heart beat kernel functionality.
16	First GPIO node is taken.
17
18	endmenu	11	endmenu

arch/microblaze/include/asm/setup.h+0−5

 extern char *klimit;
-void microblaze_heartbeat(void);
-void microblaze_setup_heartbeat(void);
 #   ifdef CONFIG_MMU
 extern void mmu_reset(void);
 #   endif /* CONFIG_MMU */
-extern void of_platform_reset_gpio_probe(void);
 void time_init(void);
 void init_IRQ(void);
 void machine_early_init(const char *cmdline, unsigned int ram,

arch/microblaze/include/asm/unistd.h+1−1

@@ -38,6 +38,6 @@ · 37 unmodified lines
38		38
39	#endif /* __ASSEMBLY__ */	39	#endif /* __ASSEMBLY__ */
40		40
41	#define __NR_syscalls 399	41	#define __NR_syscalls 401
42		42
43	#endif /* _ASM_MICROBLAZE_UNISTD_H */	43	#endif /* _ASM_MICROBLAZE_UNISTD_H */

arch/microblaze/include/uapi/asm/unistd.h+2−0

@@ -415,5 +415,7 @@ · 414 unmodified lines
415	#define __NR_pkey_alloc 396	415	#define __NR_pkey_alloc 396
416	#define __NR_pkey_free 397	416	#define __NR_pkey_free 397
417	#define __NR_statx 398	417	#define __NR_statx 398
		418	#define __NR_io_pgetevents 399
		419	#define __NR_rseq 400
418		420
419	#endif /* _UAPI_ASM_MICROBLAZE_UNISTD_H */	421	#endif /* _UAPI_ASM_MICROBLAZE_UNISTD_H */

arch/microblaze/kernel/Makefile+1−3

 CFLAGS_REMOVE_timer.o = -pg
 CFLAGS_REMOVE_intc.o = -pg
 CFLAGS_REMOVE_early_printk.o = -pg
-CFLAGS_REMOVE_heartbeat.o = -pg
 CFLAGS_REMOVE_ftrace.o = -pg
 CFLAGS_REMOVE_process.o = -pg
 endif
 obj-y += dma.o exceptions.o \
 	hw_exception_handler.o irq.o \
-	platform.o process.o prom.o ptrace.o \
+	process.o prom.o ptrace.o \
 	reset.o setup.o signal.o sys_microblaze.o timer.o traps.o unwind.o
 obj-y += cpu/
-obj-$(CONFIG_HEART_BEAT)	+= heartbeat.o
 obj-$(CONFIG_MODULES)		+= microblaze_ksyms.o module.o
 obj-$(CONFIG_MMU)		+= misc.o
 obj-$(CONFIG_STACKTRACE)	+= stacktrace.o

arch/microblaze/kernel/heartbeat.c+0−72

@@ -1,72 +0,0 @@
1	/*
2	* Copyright (C) 2007-2009 Michal Simek <monstr@monstr.eu>
3	* Copyright (C) 2007-2009 PetaLogix
4	* Copyright (C) 2006 Atmark Techno, Inc.
5	*
6	* This file is subject to the terms and conditions of the GNU General Public
7	* License. See the file "COPYING" in the main directory of this archive
8	* for more details.
9	*/
10
11	#include <linux/sched.h>
12	#include <linux/sched/loadavg.h>
13	#include <linux/io.h>
14
15	#include <asm/setup.h>
16	#include <asm/page.h>
17	#include <asm/prom.h>
18
19	static unsigned int base_addr;
20
21	void microblaze_heartbeat(void)
22	{
23	static unsigned int cnt, period, dist;
24
25	if (base_addr) {
26	if (cnt == 0 \|\| cnt == dist)
27	out_be32(base_addr, 1);
28	else if (cnt == 7 \|\| cnt == dist + 7)
29	out_be32(base_addr, 0);
30
31	if (++cnt > period) {
32	cnt = 0;
33	/*
34	* The hyperbolic function below modifies the heartbeat
35	* period length in dependency of the current (5min)
36	* load. It goes through the points f(0)=126, f(1)=86,
37	* f(5)=51, f(inf)->30.
38	*/
39	period = ((672 << FSHIFT) / (5 * avenrun[0] +
40	(7 << FSHIFT))) + 30;
41	dist = period / 4;
42	}
43	}
44	}
45
46	void microblaze_setup_heartbeat(void)
47	{
48	struct device_node *gpio = NULL;
49	int *prop;
50	int j;
51	const char * const gpio_list[] = {
52	"xlnx,xps-gpio-1.00.a",
53	NULL
54	};
55
56	for (j = 0; gpio_list[j] != NULL; j++) {
57	gpio = of_find_compatible_node(NULL, NULL, gpio_list[j]);
58	if (gpio)
59	break;
60	}
61
62	if (gpio) {
63	base_addr = be32_to_cpup(of_get_property(gpio, "reg", NULL));
64	base_addr = (unsigned long) ioremap(base_addr, PAGE_SIZE);
65	pr_notice("Heartbeat GPIO at 0x%x\n", base_addr);
66
67	/* GPIO is configured as output */
68	prop = (int *) of_get_property(gpio, "xlnx,is-bidir", NULL);
69	if (prop)
70	out_be32(base_addr + 4, 0);
71	}
72	}

arch/microblaze/kernel/platform.c+0−29

@@ -1,29 +0,0 @@
1	/*
2	* Copyright 2008 Michal Simek <monstr@monstr.eu>
3	*
4	* based on virtex.c file
5	*
6	* Copyright 2007 Secret Lab Technologies Ltd.
7	*
8	* This file is licensed under the terms of the GNU General Public License
9	* version 2. This program is licensed "as is" without any warranty of any
10	* kind, whether express or implied.
11	*/
12
13	#include <linux/init.h>
14	#include <linux/of_platform.h>
15	#include <asm/setup.h>
16
17	static struct of_device_id xilinx_of_bus_ids[] __initdata = {
18	{ .compatible = "simple-bus", },
19	{ .compatible = "xlnx,compound", },
20	{}
21	};
22
23	static int __init microblaze_device_probe(void)
24	{
25	of_platform_bus_probe(NULL, xilinx_of_bus_ids, NULL);
26	of_platform_reset_gpio_probe();
27	return 0;
28	}
29	device_initcall(microblaze_device_probe);

arch/microblaze/kernel/reset.c+6−5

 static int handle; /* reset pin handle */
 static unsigned int reset_val;
-void of_platform_reset_gpio_probe(void)
+static int of_platform_reset_gpio_probe(void)
 {
 	int ret;
 	handle = of_get_named_gpio(of_find_node_by_path("/"),
 	if (!gpio_is_valid(handle)) {
 		pr_info("Skipping unavailable RESET gpio %d (%s)\n",
 				handle, "reset");
-		return;
+		return -ENODEV;
 	}
 	ret = gpio_request(handle, "reset");
 	if (ret < 0) {
 		pr_info("GPIO pin is already allocated\n");
-		return;
+		return ret;
 	}
 	/* get current setup value */
 	pr_info("RESET: Registered gpio device: %d, current val: %d\n",
 							handle, reset_val);
-	return;
+	return 0;
 err:
 	gpio_free(handle);
-	return;
+	return ret;
 }
+device_initcall(of_platform_reset_gpio_probe);
 static void gpio_system_reset(void)

arch/microblaze/kernel/syscall_table.S+2−0

@@ -400,3 +400,5 @@ ENTRY(sys_call_table) · 399 unmodified lines
400	.long sys_pkey_alloc	400	.long sys_pkey_alloc
401	.long sys_pkey_free	401	.long sys_pkey_free
402	.long sys_statx	402	.long sys_statx
		403	.long sys_io_pgetevents
		404	.long sys_rseq

arch/microblaze/kernel/timer.c+0−7

 static irqreturn_t timer_interrupt(int irq, void *dev_id)
 {
 	struct clock_event_device *evt = &clockevent_xilinx_timer;
-#ifdef CONFIG_HEART_BEAT
-	microblaze_heartbeat();
-#endif
 	timer_ack();
 	evt->event_handler(evt);
 	return IRQ_HANDLED;
 		return ret;
 	}
-#ifdef CONFIG_HEART_BEAT
-	microblaze_setup_heartbeat();
-#endif
 	ret = xilinx_clocksource_init();
 	if (ret)
 		return ret;

arch/mips/kernel/signal.c+2−2

@@ -801,7 +801,7 @@ static void handle_signal(struct ksignal ksig, struct pt_regs regs) · 800 unmodified lines
801	regs->regs[0] = 0; /* Don't deal with this again. */	801	regs->regs[0] = 0; /* Don't deal with this again. */
802	}	802	}
803		803
804	rseq_signal_deliver(regs);	804	rseq_signal_deliver(ksig, regs);
805		805
806	if (sig_uses_siginfo(&ksig->ka, abi))	806	if (sig_uses_siginfo(&ksig->ka, abi))
807	ret = abi->setup_rt_frame(vdso + abi->vdso->off_rt_sigreturn,	807	ret = abi->setup_rt_frame(vdso + abi->vdso->off_rt_sigreturn,
@@ -870,7 +870,7 @@ asmlinkage void do_notify_resume(struct pt_regs regs, void unused, · 62 unmodified lines
870	if (thread_info_flags & _TIF_NOTIFY_RESUME) {	870	if (thread_info_flags & _TIF_NOTIFY_RESUME) {
871	clear_thread_flag(TIF_NOTIFY_RESUME);	871	clear_thread_flag(TIF_NOTIFY_RESUME);
872	tracehook_notify_resume(regs);	872	tracehook_notify_resume(regs);
873	rseq_handle_notify_resume(regs);	873	rseq_handle_notify_resume(NULL, regs);
874	}	874	}
875		875
876	user_enter();	876	user_enter();

arch/openrisc/include/asm/pgalloc.h+5−1

 	__free_page(pte);
 }
+#define __pte_free_tlb(tlb, pte, addr)	\
+do {					\
+	pgtable_page_dtor(pte);		\
+	tlb_remove_page((tlb), (pte));	\
+} while (0)
-#define __pte_free_tlb(tlb, pte, addr) tlb_remove_page((tlb), (pte))
 #define pmd_pgtable(pmd) pmd_page(pmd)
 #define check_pgt_cache()          do { } while (0)

arch/openrisc/kernel/entry.S+1−7

 	l.addi  r3,r1,0                    // pt_regs
 	/* r4 set be EXCEPTION_HANDLE */   // effective address of fault
-	/*
-	 * __PHX__: TODO
-	 *
-	 * all this can be written much simpler. look at
-	 * DTLB miss handler in the CONFIG_GUARD_PROTECTED_CORE part
-	 */
 #ifdef CONFIG_OPENRISC_NO_SPR_SR_DSX
 	l.lwz   r6,PT_PC(r3)               // address of an offending insn
 	l.lwz   r6,0(r6)                   // instruction that caused pf
 #else
-	l.lwz   r6,PT_SR(r3)               // SR
+	l.mfspr r6,r0,SPR_SR               // SR
 	l.andi  r6,r6,SPR_SR_DSX           // check for delay slot exception
 	l.sfne  r6,r0                      // exception happened in delay slot
 	l.bnf   7f

arch/openrisc/kernel/head.S+6−3

  *	 r4  - EEAR     exception EA
  *	 r10 - current	pointing to current_thread_info struct
  *	 r12 - syscall  0, since we didn't come from syscall
- *	 r13 - temp	it actually contains new SR, not needed anymore
+ *	 r30 - handler	address of the handler we'll jump to
- *	 r31 - handler	address of the handler we'll jump to
  *
  *	 handler has to save remaining registers to the exception
  *	 ksp frame *before* tainting them!
 	/* r1 is KSP, r30 is __pa(KSP) */			;\
 	tophys  (r30,r1)					;\
 	l.sw    PT_GPR12(r30),r12				;\
+	/* r4 use for tmp before EA */				;\
 	l.mfspr r12,r0,SPR_EPCR_BASE				;\
 	l.sw    PT_PC(r30),r12					;\
 	l.mfspr r12,r0,SPR_ESR_BASE				;\
 	/* r12 == 1 if we come from syscall */			;\
 	CLEAR_GPR(r12)						;\
 	/* ----- turn on MMU ----- */				;\
-	l.ori	r30,r0,(EXCEPTION_SR)				;\
+	/* Carry DSX into exception SR */			;\
+	l.mfspr r30,r0,SPR_SR					;\
+	l.andi	r30,r30,SPR_SR_DSX				;\
+	l.ori	r30,r30,(EXCEPTION_SR)				;\
 	l.mtspr	r0,r30,SPR_ESR_BASE				;\
 	/* r30:	EA address of handler */			;\
 	LOAD_SYMBOL_2_GPR(r30,handler)				;\

arch/openrisc/kernel/traps.c+1−1

@@ -300,7 +300,7 @@ static inline int in_delay_slot(struct pt_regs *regs) · 299 unmodified lines
300	return 0;	300	return 0;
301	}	301	}
302	#else	302	#else
303	return regs->sr & SPR_SR_DSX;	303	return mfspr(SPR_SR) & SPR_SR_DSX;
304	#endif	304	#endif
305	}	305	}
306		306

arch/parisc/Kconfig+3−3

@@ -244,11 +244,11 @@ config PARISC_PAGE_SIZE_4KB · 243 unmodified lines
244		244
245	config PARISC_PAGE_SIZE_16KB	245	config PARISC_PAGE_SIZE_16KB
246	bool "16KB"	246	bool "16KB"
247	depends on PA8X00	247	depends on PA8X00 && BROKEN
248		248
249	config PARISC_PAGE_SIZE_64KB	249	config PARISC_PAGE_SIZE_64KB
250	bool "64KB"	250	bool "64KB"
251	depends on PA8X00	251	depends on PA8X00 && BROKEN
252		252
253	endchoice	253	endchoice
254		254
@@ -347,7 +347,7 @@ config NR_CPUS · 92 unmodified lines
347	int "Maximum number of CPUs (2-32)"	347	int "Maximum number of CPUs (2-32)"
348	range 2 32	348	range 2 32
349	depends on SMP	349	depends on SMP
350	default "32"	350	default "4"
351		351
352	endmenu	352	endmenu
353		353

arch/parisc/Makefile+0−4

 # kernel.
 cflags-y	+= -mdisable-fpregs
-# Without this, "ld -r" results in .text sections that are too big
-# (> 0x40000) for branches to reach stubs.
-cflags-y	+= -ffunction-sections
 # Use long jumps instead of long branches (needed if your linker fails to
 # link a too big vmlinux executable). Not enabled for building modules.
 ifdef CONFIG_MLONGCALLS

arch/parisc/include/asm/signal.h+0−8

@@ -21,14 +21,6 @@ typedef struct { · 20 unmodified lines
21	unsigned long sig[_NSIG_WORDS];	21	unsigned long sig[_NSIG_WORDS];
22	} sigset_t;	22	} sigset_t;
23		23
24	#ifndef __KERNEL__
25	struct sigaction {
26	__sighandler_t sa_handler;
27	unsigned long sa_flags;
28	sigset_t sa_mask; /* mask last for extensibility */
29	};
30	#endif
31
32	#include <asm/sigcontext.h>	24	#include <asm/sigcontext.h>
33		25
34	#endif /* !__ASSEMBLY */	26	#endif /* !__ASSEMBLY */

arch/parisc/include/uapi/asm/unistd.h+2−1

@@ -364,8 +364,9 @@ · 363 unmodified lines
364	#define __NR_preadv2 (__NR_Linux + 347)	364	#define __NR_preadv2 (__NR_Linux + 347)
365	#define __NR_pwritev2 (__NR_Linux + 348)	365	#define __NR_pwritev2 (__NR_Linux + 348)
366	#define __NR_statx (__NR_Linux + 349)	366	#define __NR_statx (__NR_Linux + 349)
		367	#define __NR_io_pgetevents (__NR_Linux + 350)
367		368
368	#define __NR_Linux_syscalls (__NR_statx + 1)	369	#define __NR_Linux_syscalls (__NR_io_pgetevents + 1)
369		370
370		371
371	#define __IGNORE_select /* newselect */	372	#define __IGNORE_select /* newselect */

arch/parisc/kernel/drivers.c+9−16

 {
 	/* FIXME: we need this because apparently the sti
 	 * driver can be registered twice */
-	if(driver->drv.name) {
+	if (driver->drv.name) {
-		printk(KERN_WARNING
+		pr_warn("BUG: skipping previously registered driver %s\n",
-		       "BUG: skipping previously registered driver %s\n",
+			driver->name);
-		       driver->name);
 		return 1;
 	}
 	if (!driver->probe) {
-		printk(KERN_WARNING
+		pr_warn("BUG: driver %s has no probe routine\n", driver->name);
-		       "BUG: driver %s has no probe routine\n",
-		       driver->name);
 		return 1;
 	}
 	dev = create_parisc_device(mod_path);
 	if (dev->id.hw_type != HPHW_FAULTY) {
-		printk(KERN_ERR "Two devices have hardware path [%s].  "
+		pr_err("Two devices have hardware path [%s].  IODC data for second device: %7phN\n"
-				"IODC data for second device: "
+		       "Rearranging GSC cards sometimes helps\n",
-				"%02x%02x%02x%02x%02x%02x\n"
+			parisc_pathname(dev), iodc_data);
-				"Rearranging GSC cards sometimes helps\n",
-			parisc_pathname(dev), iodc_data[0], iodc_data[1],
-			iodc_data[3], iodc_data[4], iodc_data[5], iodc_data[6]);
 		return NULL;
 	}
 	 * the keyboard controller
 	 */
 	if ((hpa & 0xfff) == 0 && insert_resource(&iomem_resource, &dev->hpa))
-		printk("Unable to claim HPA %lx for device %s\n",
+		pr_warn("Unable to claim HPA %lx for device %s\n", hpa, name);
-				hpa, name);
 	return dev;
 }
 	static int count;
 	print_pa_hwpath(dev, hw_path);
-	printk(KERN_INFO "%d. %s at 0x%px [%s] { %d, 0x%x, 0x%.3x, 0x%.5x }",
+	pr_info("%d. %s at 0x%px [%s] { %d, 0x%x, 0x%.3x, 0x%.5x }",
 		++count, dev->name, (void*) dev->hpa.start, hw_path, dev->id.hw_type,
 		dev->id.hversion_rev, dev->id.hversion, dev->id.sversion);

arch/parisc/kernel/syscall_table.S+1−0

@@ -445,6 +445,7 @@ · 444 unmodified lines
445	ENTRY_COMP(preadv2)	445	ENTRY_COMP(preadv2)
446	ENTRY_COMP(pwritev2)	446	ENTRY_COMP(pwritev2)
447	ENTRY_SAME(statx)	447	ENTRY_SAME(statx)
		448	ENTRY_COMP(io_pgetevents) /* 350 */
448		449
449		450
450	.ifne (. - 90b) - (__NR_Linux_syscalls * (91b - 90b))	451	.ifne (. - 90b) - (__NR_Linux_syscalls * (91b - 90b))

arch/parisc/kernel/unwind.c+2−2

@@ -25,7 +25,7 @@ · 24 unmodified lines
25		25
26	/* #define DEBUG 1 */	26	/* #define DEBUG 1 */
27	#ifdef DEBUG	27	#ifdef DEBUG
28	#define dbg(x...) printk(x)	28	#define dbg(x...) pr_debug(x)
29	#else	29	#else
30	#define dbg(x...)	30	#define dbg(x...)
31	#endif	31	#endif
@@ -182,7 +182,7 @@ int __init unwind_init(void) · 150 unmodified lines
182	start = (long)&__start___unwind[0];	182	start = (long)&__start___unwind[0];
183	stop = (long)&__stop___unwind[0];	183	stop = (long)&__stop___unwind[0];
184		184
185	printk("unwind_init: start = 0x%lx, end = 0x%lx, entries = %lu\n",	185	dbg("unwind_init: start = 0x%lx, end = 0x%lx, entries = %lu\n",
186	start, stop,	186	start, stop,
187	(stop - start) / sizeof(struct unwind_table_entry));	187	(stop - start) / sizeof(struct unwind_table_entry));
188		188

arch/powerpc/include/asm/book3s/32/pgalloc.h+0−1

@@ -138,7 +138,6 @@ static inline void pgtable_free_tlb(struct mmu_gather *tlb, · 137 unmodified lines
138	static inline void __pte_free_tlb(struct mmu_gather *tlb, pgtable_t table,	138	static inline void __pte_free_tlb(struct mmu_gather *tlb, pgtable_t table,
139	unsigned long address)	139	unsigned long address)
140	{	140	{
141	pgtable_page_dtor(table);
142	pgtable_free_tlb(tlb, page_address(table), 0);	141	pgtable_free_tlb(tlb, page_address(table), 0);
143	}	142	}
144	#endif /* _ASM_POWERPC_BOOK3S_32_PGALLOC_H */	143	#endif /* _ASM_POWERPC_BOOK3S_32_PGALLOC_H */

arch/powerpc/include/asm/nohash/32/pgalloc.h+0−1

@@ -140,7 +140,6 @@ static inline void __pte_free_tlb(struct mmu_gather *tlb, pgtable_t table, · 139 unmodified lines
140	unsigned long address)	140	unsigned long address)
141	{	141	{
142	tlb_flush_pgtable(tlb, address);	142	tlb_flush_pgtable(tlb, address);
143	pgtable_page_dtor(table);
144	pgtable_free_tlb(tlb, page_address(table), 0);	143	pgtable_free_tlb(tlb, page_address(table), 0);
145	}	144	}
146	#endif /* _ASM_POWERPC_PGALLOC_32_H */	145	#endif /* _ASM_POWERPC_PGALLOC_32_H */

arch/powerpc/include/asm/systbl.h+1−0

@@ -393,3 +393,4 @@ SYSCALL(pkey_alloc) · 392 unmodified lines
393	SYSCALL(pkey_free)	393	SYSCALL(pkey_free)
394	SYSCALL(pkey_mprotect)	394	SYSCALL(pkey_mprotect)
395	SYSCALL(rseq)	395	SYSCALL(rseq)
		396	COMPAT_SYS(io_pgetevents)

arch/powerpc/include/asm/unistd.h+1−1

@@ -12,7 +12,7 @@ · 11 unmodified lines
12	#include <uapi/asm/unistd.h>	12	#include <uapi/asm/unistd.h>
13		13
14		14
15	#define NR_syscalls 388	15	#define NR_syscalls 389
16		16
17	#define __NR__exit __NR_exit	17	#define __NR__exit __NR_exit
18		18

arch/powerpc/include/uapi/asm/unistd.h+1−0

@@ -399,5 +399,6 @@ · 398 unmodified lines
399	#define __NR_pkey_free 385	399	#define __NR_pkey_free 385
400	#define __NR_pkey_mprotect 386	400	#define __NR_pkey_mprotect 386
401	#define __NR_rseq 387	401	#define __NR_rseq 387
		402	#define __NR_io_pgetevents 388
402		403
403	#endif /* _UAPI_ASM_POWERPC_UNISTD_H_ */	404	#endif /* _UAPI_ASM_POWERPC_UNISTD_H_ */

arch/powerpc/kernel/pci_32.c+0−4

  * Note that the returned IO or memory base is a physical address
  */
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpragmas"
-#pragma GCC diagnostic ignored "-Wattribute-alias"
 SYSCALL_DEFINE3(pciconfig_iobase, long, which,
 		unsigned long, bus, unsigned long, devfn)
 {
 	return result;
 }
-#pragma GCC diagnostic pop

arch/powerpc/kernel/pci_64.c+0−4

 #define IOBASE_ISA_IO		3
 #define IOBASE_ISA_MEM		4
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpragmas"
-#pragma GCC diagnostic ignored "-Wattribute-alias"
 SYSCALL_DEFINE3(pciconfig_iobase, long, which, unsigned long, in_bus,
 			  unsigned long, in_devfn)
 {
 	return -EOPNOTSUPP;
 }
-#pragma GCC diagnostic pop
 #ifdef CONFIG_NUMA
 int pcibus_to_node(struct pci_bus *bus)

arch/powerpc/kernel/rtas.c+0−4

 }
 /* We assume to be passed big endian arguments */
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpragmas"
-#pragma GCC diagnostic ignored "-Wattribute-alias"
 SYSCALL_DEFINE1(rtas, struct rtas_args __user *, uargs)
 {
 	struct rtas_args args;
 	return 0;
 }
-#pragma GCC diagnostic pop
 /*
  * Call early during boot, before mem init, to retrieve the RTAS

arch/powerpc/kernel/signal_32.c+0−8

 }
 #endif
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpragmas"
-#pragma GCC diagnostic ignored "-Wattribute-alias"
 #ifdef CONFIG_PPC64
 COMPAT_SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
 		       struct ucontext __user *, new_ctx, int, ctx_size)
 	set_thread_flag(TIF_RESTOREALL);
 	return 0;
 }
-#pragma GCC diagnostic pop
 #ifdef CONFIG_PPC64
 COMPAT_SYSCALL_DEFINE0(rt_sigreturn)
 	return 0;
 }
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpragmas"
-#pragma GCC diagnostic ignored "-Wattribute-alias"
 #ifdef CONFIG_PPC32
 SYSCALL_DEFINE3(debug_setcontext, struct ucontext __user *, ctx,
 			 int, ndbg, struct sig_dbg_op __user *, dbg)
 	return 0;
 }
 #endif
-#pragma GCC diagnostic pop
 /*
  * OK, we're invoking a handler

arch/powerpc/kernel/signal_64.c+0−4

 /*
  * Handle {get,set,swap}_context operations
  */
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpragmas"
-#pragma GCC diagnostic ignored "-Wattribute-alias"
 SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
 		struct ucontext __user *, new_ctx, long, ctx_size)
 {
 	set_thread_flag(TIF_RESTOREALL);
 	return 0;
 }
-#pragma GCC diagnostic pop
 /*

arch/powerpc/kernel/syscalls.c+0−4

 	return ret;
 }
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpragmas"
-#pragma GCC diagnostic ignored "-Wattribute-alias"
 SYSCALL_DEFINE6(mmap2, unsigned long, addr, size_t, len,
 		unsigned long, prot, unsigned long, flags,
 		unsigned long, fd, unsigned long, pgoff)
 {
 	return do_mmap2(addr, len, prot, flags, fd, offset, PAGE_SHIFT);
 }
-#pragma GCC diagnostic pop
 #ifdef CONFIG_PPC32
 /*

arch/powerpc/mm/subpage-prot.c+0−4

  * in a 2-bit field won't allow writes to a page that is otherwise
  * write-protected.
  */
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpragmas"
-#pragma GCC diagnostic ignored "-Wattribute-alias"
 SYSCALL_DEFINE3(subpage_prot, unsigned long, addr,
 		unsigned long, len, u32 __user *, map)
 {
 	up_write(&mm->mmap_sem);
 	return err;
 }
-#pragma GCC diagnostic pop

arch/powerpc/platforms/powermac/time.c+20−9

 #define DBG(x...)
 #endif
-/* Apparently the RTC stores seconds since 1 Jan 1904 */
+/*
+ * Offset between Unix time (1970-based) and Mac time (1904-based). Cuda and PMU
+ * times wrap in 2040. If we need to handle later times, the read_time functions
+ * need to be changed to interpret wrapped times as post-2040.
+ */
 #define RTC_OFFSET	2082844800
 /*
 	if (req.reply_len != 7)
 		printk(KERN_ERR "cuda_get_time: got %d byte reply\n",
 		       req.reply_len);
-	now = (req.reply[3] << 24) + (req.reply[4] << 16)
+	now = (u32)((req.reply[3] << 24) + (req.reply[4] << 16) +
-		+ (req.reply[5] << 8) + req.reply[6];
+		    (req.reply[5] << 8) + req.reply[6]);
+	/* it's either after year 2040, or the RTC has gone backwards */
+	WARN_ON(now < RTC_OFFSET);
 	return now - RTC_OFFSET;
 }
 static int cuda_set_rtc_time(struct rtc_time *tm)
 {
-	time64_t nowtime;
+	u32 nowtime;
 	struct adb_request req;
-	nowtime = rtc_tm_to_time64(tm) + RTC_OFFSET;
+	nowtime = lower_32_bits(rtc_tm_to_time64(tm) + RTC_OFFSET);
 	if (cuda_request(&req, NULL, 6, CUDA_PACKET, CUDA_SET_TIME,
 			 nowtime >> 24, nowtime >> 16, nowtime >> 8,
 			 nowtime) < 0)
 	if (req.reply_len != 4)
 		printk(KERN_ERR "pmu_get_time: got %d byte reply from PMU\n",
 		       req.reply_len);
-	now = (req.reply[0] << 24) + (req.reply[1] << 16)
+	now = (u32)((req.reply[0] << 24) + (req.reply[1] << 16)	+
-		+ (req.reply[2] << 8) + req.reply[3];
+		    (req.reply[2] << 8) + req.reply[3]);
+	/* it's either after year 2040, or the RTC has gone backwards */
+	WARN_ON(now < RTC_OFFSET);
 	return now - RTC_OFFSET;
 }
 static int pmu_set_rtc_time(struct rtc_time *tm)
 {
-	time64_t nowtime;
+	u32 nowtime;
 	struct adb_request req;
-	nowtime = rtc_tm_to_time64(tm) + RTC_OFFSET;
+	nowtime = lower_32_bits(rtc_tm_to_time64(tm) + RTC_OFFSET);
 	if (pmu_request(&req, NULL, 5, PMU_SET_RTC, nowtime >> 24,
 			nowtime >> 16, nowtime >> 8, nowtime) < 0)
 		return -ENXIO;

arch/s390/net/bpf_jit_comp.c+1−0

@@ -1286,6 +1286,7 @@ struct bpf_prog bpf_int_jit_compile(struct bpf_prog fp) · 1285 unmodified lines
1286	goto free_addrs;	1286	goto free_addrs;
1287	}	1287	}
1288	if (bpf_jit_prog(&jit, fp)) {	1288	if (bpf_jit_prog(&jit, fp)) {
		1289	bpf_jit_binary_free(header);
1289	fp = orig_fp;	1290	fp = orig_fp;
1290	goto free_addrs;	1291	goto free_addrs;
1291	}	1292	}

arch/x86/entry/entry_32.S+1−1

@@ -477,7 +477,7 @@ ENTRY(entry_SYSENTER_32) · 476 unmodified lines
477	* whereas POPF does not.)	477	* whereas POPF does not.)
478	*/	478	*/
479	addl $PT_EFLAGS-PT_DS, %esp /* point esp at pt_regs->flags */	479	addl $PT_EFLAGS-PT_DS, %esp /* point esp at pt_regs->flags */
480	btr $X86_EFLAGS_IF_BIT, (%esp)	480	btrl $X86_EFLAGS_IF_BIT, (%esp)
481	popfl	481	popfl
482		482
483	/*	483	/*

arch/x86/entry/entry_64_compat.S+8−8

@@ -84,13 +84,13 @@ ENTRY(entry_SYSENTER_compat) · 83 unmodified lines
84	pushq %rdx /* pt_regs->dx */	84	pushq %rdx /* pt_regs->dx */
85	pushq %rcx /* pt_regs->cx */	85	pushq %rcx /* pt_regs->cx */
86	pushq $-ENOSYS /* pt_regs->ax */	86	pushq $-ENOSYS /* pt_regs->ax */
87	pushq %r8 /* pt_regs->r8 */	87	pushq $0 /* pt_regs->r8 = 0 */
88	xorl %r8d, %r8d /* nospec r8 */	88	xorl %r8d, %r8d /* nospec r8 */
89	pushq %r9 /* pt_regs->r9 */	89	pushq $0 /* pt_regs->r9 = 0 */
90	xorl %r9d, %r9d /* nospec r9 */	90	xorl %r9d, %r9d /* nospec r9 */
91	pushq %r10 /* pt_regs->r10 */	91	pushq $0 /* pt_regs->r10 = 0 */
92	xorl %r10d, %r10d /* nospec r10 */	92	xorl %r10d, %r10d /* nospec r10 */
93	pushq %r11 /* pt_regs->r11 */	93	pushq $0 /* pt_regs->r11 = 0 */
94	xorl %r11d, %r11d /* nospec r11 */	94	xorl %r11d, %r11d /* nospec r11 */
95	pushq %rbx /* pt_regs->rbx */	95	pushq %rbx /* pt_regs->rbx */
96	xorl %ebx, %ebx /* nospec rbx */	96	xorl %ebx, %ebx /* nospec rbx */
@@ -374,13 +374,13 @@ ENTRY(entry_INT80_compat) · 277 unmodified lines
374	pushq %rcx /* pt_regs->cx */	374	pushq %rcx /* pt_regs->cx */
375	xorl %ecx, %ecx /* nospec cx */	375	xorl %ecx, %ecx /* nospec cx */
376	pushq $-ENOSYS /* pt_regs->ax */	376	pushq $-ENOSYS /* pt_regs->ax */
377	pushq $0 /* pt_regs->r8 = 0 */	377	pushq %r8 /* pt_regs->r8 */
378	xorl %r8d, %r8d /* nospec r8 */	378	xorl %r8d, %r8d /* nospec r8 */
379	pushq $0 /* pt_regs->r9 = 0 */	379	pushq %r9 /* pt_regs->r9 */
380	xorl %r9d, %r9d /* nospec r9 */	380	xorl %r9d, %r9d /* nospec r9 */
381	pushq $0 /* pt_regs->r10 = 0 */	381	pushq %r10 /* pt_regs->r10*/
382	xorl %r10d, %r10d /* nospec r10 */	382	xorl %r10d, %r10d /* nospec r10 */
383	pushq $0 /* pt_regs->r11 = 0 */	383	pushq %r11 /* pt_regs->r11 */
384	xorl %r11d, %r11d /* nospec r11 */	384	xorl %r11d, %r11d /* nospec r11 */
385	pushq %rbx /* pt_regs->rbx */	385	pushq %rbx /* pt_regs->rbx */
386	xorl %ebx, %ebx /* nospec rbx */	386	xorl %ebx, %ebx /* nospec rbx */

arch/x86/include/asm/pgalloc.h+3−0

@@ -184,6 +184,9 @@ static inline p4d_t p4d_alloc_one(struct mm_struct mm, unsigned long addr) · 183 unmodified lines
184		184
185	static inline void p4d_free(struct mm_struct mm, p4d_t p4d)	185	static inline void p4d_free(struct mm_struct mm, p4d_t p4d)
186	{	186	{
		187	if (!pgtable_l5_enabled())
		188	return;
		189
187	BUG_ON((unsigned long)p4d & (PAGE_SIZE-1));	190	BUG_ON((unsigned long)p4d & (PAGE_SIZE-1));
188	free_page((unsigned long)p4d);	191	free_page((unsigned long)p4d);
189	}	192	}

arch/x86/include/asm/pgtable.h+1−1

@@ -898,7 +898,7 @@ static inline unsigned long pgd_page_vaddr(pgd_t pgd) · 897 unmodified lines
898	#define pgd_page(pgd) pfn_to_page(pgd_pfn(pgd))	898	#define pgd_page(pgd) pfn_to_page(pgd_pfn(pgd))
899		899
900	/* to find an entry in a page-table-directory. */	900	/* to find an entry in a page-table-directory. */
901	static __always_inline p4d_t p4d_offset(pgd_t pgd, unsigned long address)	901	static inline p4d_t p4d_offset(pgd_t pgd, unsigned long address)
902	{	902	{
903	if (!pgtable_l5_enabled())	903	if (!pgtable_l5_enabled())
904	return (p4d_t *)pgd;	904	return (p4d_t *)pgd;

arch/x86/include/asm/pgtable_64.h+2−2

@@ -216,7 +216,7 @@ static inline pgd_t pti_set_user_pgd(pgd_t *pgdp, pgd_t pgd) · 215 unmodified lines
216	}	216	}
217	#endif	217	#endif
218		218
219	static __always_inline void native_set_p4d(p4d_t *p4dp, p4d_t p4d)	219	static inline void native_set_p4d(p4d_t *p4dp, p4d_t p4d)
220	{	220	{
221	pgd_t pgd;	221	pgd_t pgd;
222		222
@@ -230,7 +230,7 @@ static __always_inline void native_set_p4d(p4d_t *p4dp, p4d_t p4d) · 7 unmodified lines
230	*p4dp = native_make_p4d(native_pgd_val(pgd));	230	*p4dp = native_make_p4d(native_pgd_val(pgd));
231	}	231	}
232		232
233	static __always_inline void native_p4d_clear(p4d_t *p4d)	233	static inline void native_p4d_clear(p4d_t *p4d)
234	{	234	{
235	native_set_p4d(p4d, native_make_p4d(0));	235	native_set_p4d(p4d, native_make_p4d(0));
236	}	236	}

arch/x86/kernel/e820.c+12−3

@@ -1248,6 +1248,7 @@ void __init e820__memblock_setup(void) · 1247 unmodified lines
1248	{	1248	{
1249	int i;	1249	int i;
1250	u64 end;	1250	u64 end;
		1251	u64 addr = 0;
1251		1252
1252	/*	1253	/*
1253	* The bootstrap memblock region count maximum is 128 entries	1254	* The bootstrap memblock region count maximum is 128 entries
@@ -1264,13 +1265,21 @@ void __init e820__memblock_setup(void) · 10 unmodified lines
1264	struct e820_entry *entry = &e820_table->entries[i];	1265	struct e820_entry *entry = &e820_table->entries[i];
1265		1266
1266	end = entry->addr + entry->size;	1267	end = entry->addr + entry->size;
		1268	if (addr < entry->addr)
		1269	memblock_reserve(addr, entry->addr - addr);
		1270	addr = end;
1267	if (end != (resource_size_t)end)	1271	if (end != (resource_size_t)end)
1268	continue;	1272	continue;
1269		1273
		1274	/*
		1275	* all !E820_TYPE_RAM ranges (including gap ranges) are put
		1276	* into memblock.reserved to make sure that struct pages in
		1277	* such regions are not left uninitialized after bootup.
		1278	*/
1270	if (entry->type != E820_TYPE_RAM && entry->type != E820_TYPE_RESERVED_KERN)	1279	if (entry->type != E820_TYPE_RAM && entry->type != E820_TYPE_RESERVED_KERN)
1271	continue;	1280	memblock_reserve(entry->addr, entry->size);
1272		1281	else
1273	memblock_add(entry->addr, entry->size);	1282	memblock_add(entry->addr, entry->size);
1274	}	1283	}
1275		1284
1276	/* Throw away partial pages: */	1285	/* Throw away partial pages: */

arch/x86/mm/fault.c+7−14

 	return 0;
 }
-static const char nx_warning[] = KERN_CRIT
-"kernel tried to execute NX-protected page - exploit attempt? (uid: %d)\n";
-static const char smep_warning[] = KERN_CRIT
-"unable to execute userspace code (SMEP?) (uid: %d)\n";
 static void
 show_fault_oops(struct pt_regs *regs, unsigned long error_code,
 		unsigned long address)
 		pte = lookup_address_in_pgd(pgd, address, &level);
 		if (pte && pte_present(*pte) && !pte_exec(*pte))
-			printk(nx_warning, from_kuid(&init_user_ns, current_uid()));
+			pr_crit("kernel tried to execute NX-protected page - exploit attempt? (uid: %d)\n",
+				from_kuid(&init_user_ns, current_uid()));
 		if (pte && pte_present(*pte) && pte_exec(*pte) &&
 				(pgd_flags(*pgd) & _PAGE_USER) &&
 				(__read_cr4() & X86_CR4_SMEP))
-			printk(smep_warning, from_kuid(&init_user_ns, current_uid()));
+			pr_crit("unable to execute userspace code (SMEP?) (uid: %d)\n",
+				from_kuid(&init_user_ns, current_uid()));
 	}
-	printk(KERN_ALERT "BUG: unable to handle kernel ");
+	pr_alert("BUG: unable to handle kernel %s at %px\n",
-	if (address < PAGE_SIZE)
+		 address < PAGE_SIZE ? "NULL pointer dereference" : "paging request",
-		printk(KERN_CONT "NULL pointer dereference");
+		 (void *)address);
-	else
-		printk(KERN_CONT "paging request");
-	printk(KERN_CONT " at %px\n", (void *) address);
 	dump_pagetable(address);
 }

arch/x86/platform/efi/efi_64.c+2−2

@@ -166,14 +166,14 @@ void __init efi_call_phys_epilog(pgd_t *save_pgd) · 165 unmodified lines
166	pgd = pgd_offset_k(pgd_idx * PGDIR_SIZE);	166	pgd = pgd_offset_k(pgd_idx * PGDIR_SIZE);
167	set_pgd(pgd_offset_k(pgd_idx * PGDIR_SIZE), save_pgd[pgd_idx]);	167	set_pgd(pgd_offset_k(pgd_idx * PGDIR_SIZE), save_pgd[pgd_idx]);
168		168
169	if (!(pgd_val(*pgd) & _PAGE_PRESENT))	169	if (!pgd_present(*pgd))
170	continue;	170	continue;
171		171
172	for (i = 0; i < PTRS_PER_P4D; i++) {	172	for (i = 0; i < PTRS_PER_P4D; i++) {
173	p4d = p4d_offset(pgd,	173	p4d = p4d_offset(pgd,
174	pgd_idx * PGDIR_SIZE + i * P4D_SIZE);	174	pgd_idx * PGDIR_SIZE + i * P4D_SIZE);
175		175
176	if (!(p4d_val(*p4d) & _PAGE_PRESENT))	176	if (!p4d_present(*p4d))
177	continue;	177	continue;
178		178
179	pud = (pud_t )p4d_page_vaddr(p4d);	179	pud = (pud_t )p4d_page_vaddr(p4d);

block/blk-core.c+4−0

 	dst->cpu = src->cpu;
 	dst->__sector = blk_rq_pos(src);
 	dst->__data_len = blk_rq_bytes(src);
+	if (src->rq_flags & RQF_SPECIAL_PAYLOAD) {
+		dst->rq_flags |= RQF_SPECIAL_PAYLOAD;
+		dst->special_vec = src->special_vec;
+	}
 	dst->nr_phys_segments = src->nr_phys_segments;
 	dst->ioprio = src->ioprio;
 	dst->extra_len = src->extra_len;

block/blk-mq.c+12−0

 #define BLK_MQ_RESOURCE_DELAY	3		/* ms units */
+/*
+ * Returns true if we did some work AND can potentially do more.
+ */
 bool blk_mq_dispatch_rq_list(struct request_queue *q, struct list_head *list,
 			     bool got_budget)
 {
 			blk_mq_run_hw_queue(hctx, true);
 		else if (needs_restart && (ret == BLK_STS_RESOURCE))
 			blk_mq_delay_run_hw_queue(hctx, BLK_MQ_RESOURCE_DELAY);
+		return false;
 	}
+	/*
+	 * If the host/device is unable to accept more work, inform the
+	 * caller of that.
+	 */
+	if (ret == BLK_STS_RESOURCE || ret == BLK_STS_DEV_RESOURCE)
+		return false;
 	return (queued + errors) != 0;
 }

certs/blacklist.h+1−1

@@ -1,3 +1,3 @@
1	#include <linux/kernel.h>	1	#include <linux/kernel.h>
2		2
3	extern const char __initdata *const blacklist_hashes[];	3	extern const char __initconst *const blacklist_hashes[];

crypto/af_alg.c+10−3

 }
 EXPORT_SYMBOL_GPL(af_alg_async_cb);
-__poll_t af_alg_poll_mask(struct socket *sock, __poll_t events)
+/**
+ * af_alg_poll - poll system call handler
+ */
+__poll_t af_alg_poll(struct file *file, struct socket *sock,
+			 poll_table *wait)
 {
 	struct sock *sk = sock->sk;
 	struct alg_sock *ask = alg_sk(sk);
 	struct af_alg_ctx *ctx = ask->private;
-	__poll_t mask = 0;
+	__poll_t mask;
+	sock_poll_wait(file, sk_sleep(sk), wait);
+	mask = 0;
 	if (!ctx->more || ctx->used)
 		mask |= EPOLLIN | EPOLLRDNORM;
 	return mask;
 }
-EXPORT_SYMBOL_GPL(af_alg_poll_mask);
+EXPORT_SYMBOL_GPL(af_alg_poll);
 /**
  * af_alg_alloc_areq - allocate struct af_alg_async_req

crypto/algif_aead.c+2−2

@@ -375,7 +375,7 @@ static struct proto_ops algif_aead_ops = { · 374 unmodified lines
375	.sendmsg = aead_sendmsg,	375	.sendmsg = aead_sendmsg,
376	.sendpage = af_alg_sendpage,	376	.sendpage = af_alg_sendpage,
377	.recvmsg = aead_recvmsg,	377	.recvmsg = aead_recvmsg,
378	.poll_mask = af_alg_poll_mask,	378	.poll = af_alg_poll,
379	};	379	};
380		380
381	static int aead_check_key(struct socket *sock)	381	static int aead_check_key(struct socket *sock)
@@ -471,7 +471,7 @@ static struct proto_ops algif_aead_ops_nokey = { · 89 unmodified lines
471	.sendmsg = aead_sendmsg_nokey,	471	.sendmsg = aead_sendmsg_nokey,
472	.sendpage = aead_sendpage_nokey,	472	.sendpage = aead_sendpage_nokey,
473	.recvmsg = aead_recvmsg_nokey,	473	.recvmsg = aead_recvmsg_nokey,
474	.poll_mask = af_alg_poll_mask,	474	.poll = af_alg_poll,
475	};	475	};
476		476
477	static void aead_bind(const char name, u32 type, u32 mask)	477	static void aead_bind(const char name, u32 type, u32 mask)

crypto/algif_skcipher.c+2−2

@@ -206,7 +206,7 @@ static struct proto_ops algif_skcipher_ops = { · 205 unmodified lines
206	.sendmsg = skcipher_sendmsg,	206	.sendmsg = skcipher_sendmsg,
207	.sendpage = af_alg_sendpage,	207	.sendpage = af_alg_sendpage,
208	.recvmsg = skcipher_recvmsg,	208	.recvmsg = skcipher_recvmsg,
209	.poll_mask = af_alg_poll_mask,	209	.poll = af_alg_poll,
210	};	210	};
211		211
212	static int skcipher_check_key(struct socket *sock)	212	static int skcipher_check_key(struct socket *sock)
@@ -302,7 +302,7 @@ static struct proto_ops algif_skcipher_ops_nokey = { · 89 unmodified lines
302	.sendmsg = skcipher_sendmsg_nokey,	302	.sendmsg = skcipher_sendmsg_nokey,
303	.sendpage = skcipher_sendpage_nokey,	303	.sendpage = skcipher_sendpage_nokey,
304	.recvmsg = skcipher_recvmsg_nokey,	304	.recvmsg = skcipher_recvmsg_nokey,
305	.poll_mask = af_alg_poll_mask,	305	.poll = af_alg_poll,
306	};	306	};
307		307
308	static void skcipher_bind(const char name, u32 type, u32 mask)	308	static void skcipher_bind(const char name, u32 type, u32 mask)

crypto/asymmetric_keys/x509_cert_parser.c+9−0

@@ -249,6 +249,15 @@ int x509_note_signature(void *context, size_t hdrlen, · 248 unmodified lines
249	return -EINVAL;	249	return -EINVAL;
250	}	250	}
251		251
		252	if (strcmp(ctx->cert->sig->pkey_algo, "rsa") == 0) {
		253	/* Discard the BIT STRING metadata */
		254	if (vlen < 1 \|\| (const u8 )value != 0)
		255	return -EBADMSG;
		256
		257	value++;
		258	vlen--;
		259	}
		260
252	ctx->cert->raw_sig = value;	261	ctx->cert->raw_sig = value;
253	ctx->cert->raw_sig_size = vlen;	262	ctx->cert->raw_sig_size = vlen;
254	return 0;	263	return 0;

drivers/acpi/osl.c+72−0

@@ -45,6 +45,8 @@ · 44 unmodified lines
45	#include <linux/uaccess.h>	45	#include <linux/uaccess.h>
46	#include <linux/io-64-nonatomic-lo-hi.h>	46	#include <linux/io-64-nonatomic-lo-hi.h>
47		47
		48	#include "acpica/accommon.h"
		49	#include "acpica/acnamesp.h"
48	#include "internal.h"	50	#include "internal.h"
49		51
50	#define _COMPONENT ACPI_OS_SERVICES	52	#define _COMPONENT ACPI_OS_SERVICES
@@ -1490,6 +1492,76 @@ int acpi_check_region(resource_size_t start, resource_size_t n, · 1439 unmodified lines
1490	}	1492	}
1491	EXPORT_SYMBOL(acpi_check_region);	1493	EXPORT_SYMBOL(acpi_check_region);
1492		1494
		1495	static acpi_status acpi_deactivate_mem_region(acpi_handle handle, u32 level,
		1496	void _res, void *return_value)
		1497	{
		1498	struct acpi_mem_space_context **mem_ctx;
		1499	union acpi_operand_object *handler_obj;
		1500	union acpi_operand_object *region_obj2;
		1501	union acpi_operand_object *region_obj;
		1502	struct resource *res = _res;
		1503	acpi_status status;
		1504
		1505	region_obj = acpi_ns_get_attached_object(handle);
		1506	if (!region_obj)
		1507	return AE_OK;
		1508
		1509	handler_obj = region_obj->region.handler;
		1510	if (!handler_obj)
		1511	return AE_OK;
		1512
		1513	if (region_obj->region.space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
		1514	return AE_OK;
		1515
		1516	if (!(region_obj->region.flags & AOPOBJ_SETUP_COMPLETE))
		1517	return AE_OK;
		1518
		1519	region_obj2 = acpi_ns_get_secondary_object(region_obj);
		1520	if (!region_obj2)
		1521	return AE_OK;
		1522
		1523	mem_ctx = (void *)&region_obj2->extra.region_context;
		1524
		1525	if (!(mem_ctx[0]->address >= res->start &&
		1526	mem_ctx[0]->address < res->end))
		1527	return AE_OK;
		1528
		1529	status = handler_obj->address_space.setup(region_obj,
		1530	ACPI_REGION_DEACTIVATE,
		1531	NULL, (void **)mem_ctx);
		1532	if (ACPI_SUCCESS(status))
		1533	region_obj->region.flags &= ~(AOPOBJ_SETUP_COMPLETE);
		1534
		1535	return status;
		1536	}
		1537
		1538	/**
		1539	* acpi_release_memory - Release any mappings done to a memory region
		1540	* @handle: Handle to namespace node
		1541	* @res: Memory resource
		1542	* @level: A level that terminates the search
		1543	*
		1544	* Walks through @handle and unmaps all SystemMemory Operation Regions that
		1545	* overlap with @res and that have already been activated (mapped).
		1546	*
		1547	* This is a helper that allows drivers to place special requirements on memory
		1548	* region that may overlap with operation regions, primarily allowing them to
		1549	* safely map the region as non-cached memory.
		1550	*
		1551	* The unmapped Operation Regions will be automatically remapped next time they
		1552	* are called, so the drivers do not need to do anything else.
		1553	*/
		1554	acpi_status acpi_release_memory(acpi_handle handle, struct resource *res,
		1555	u32 level)
		1556	{
		1557	if (!(res->flags & IORESOURCE_MEM))
		1558	return AE_TYPE;
		1559
		1560	return acpi_walk_namespace(ACPI_TYPE_REGION, handle, level,
		1561	acpi_deactivate_mem_region, NULL, res, NULL);
		1562	}
		1563	EXPORT_SYMBOL_GPL(acpi_release_memory);
		1564
1493	/*	1565	/*
1494	* Let drivers know whether the resource checks are effective	1566	* Let drivers know whether the resource checks are effective
1495	*/	1567	*/

drivers/atm/iphase.c+1−1

@@ -1618,7 +1618,7 @@ static int rx_init(struct atm_dev *dev) · 1617 unmodified lines
1618	skb_queue_head_init(&iadev->rx_dma_q);	1618	skb_queue_head_init(&iadev->rx_dma_q);
1619	iadev->rx_free_desc_qhead = NULL;	1619	iadev->rx_free_desc_qhead = NULL;
1620		1620
1621	iadev->rx_open = kcalloc(4, iadev->num_vc, GFP_KERNEL);	1621	iadev->rx_open = kcalloc(iadev->num_vc, sizeof(void *), GFP_KERNEL);
1622	if (!iadev->rx_open) {	1622	if (!iadev->rx_open) {
1623	printk(KERN_ERR DEV_LABEL "itf %d couldn't get free page\n",	1623	printk(KERN_ERR DEV_LABEL "itf %d couldn't get free page\n",
1624	dev->number);	1624	dev->number);

drivers/atm/zatm.c+2−0

 					return -EFAULT;
 				if (pool < 0 || pool > ZATM_LAST_POOL)
 					return -EINVAL;
+				pool = array_index_nospec(pool,
+							  ZATM_LAST_POOL + 1);
 				if (copy_from_user(&info,
 				    &((struct zatm_pool_req __user *) arg)->info,
 				    sizeof(info))) return -EFAULT;

drivers/base/power/domain.c+3−4

  * power domain corresponding to a DT node's "required-opps" property.
  *
  * @dev: Device for which the performance-state needs to be found.
- * @opp_node: DT node where the "required-opps" property is present. This can be
+ * @np: DT node where the "required-opps" property is present. This can be
  *	the device node itself (if it doesn't have an OPP table) or a node
  *	within the OPP table of a device (if device has an OPP table).
- * @state: Pointer to return performance state.
  *
  * Returns performance state corresponding to the "required-opps" property of
  * a DT node. This calls platform specific genpd->opp_to_performance_state()
  * Returns performance state on success and 0 on failure.
  */
 unsigned int of_genpd_opp_to_performance_state(struct device *dev,
-					       struct device_node *opp_node)
+					       struct device_node *np)
 {
 	struct generic_pm_domain *genpd;
 	struct dev_pm_opp *opp;
 	genpd_lock(genpd);
-	opp = of_dev_pm_opp_find_required_opp(&genpd->dev, opp_node);
+	opp = of_dev_pm_opp_find_required_opp(&genpd->dev, np);
 	if (IS_ERR(opp)) {
 		dev_err(dev, "Failed to find required OPP: %ld\n",
 			PTR_ERR(opp));

drivers/block/drbd/drbd_req.c+2−2

@@ -1244,8 +1244,8 @@ drbd_request_prepare(struct drbd_device device, struct bio bio, unsigned long · 1243 unmodified lines
1244	_drbd_start_io_acct(device, req);	1244	_drbd_start_io_acct(device, req);
1245		1245
1246	/* process discards always from our submitter thread */	1246	/* process discards always from our submitter thread */
1247	if ((bio_op(bio) & REQ_OP_WRITE_ZEROES) \|\|	1247	if (bio_op(bio) == REQ_OP_WRITE_ZEROES \|\|
1248	(bio_op(bio) & REQ_OP_DISCARD))	1248	bio_op(bio) == REQ_OP_DISCARD)
1249	goto queue_for_submitter_thread;	1249	goto queue_for_submitter_thread;
1250		1250
1251	if (rw == WRITE && req->private_bio && req->i.size	1251	if (rw == WRITE && req->private_bio && req->i.size

drivers/char/random.c+13−16

 /*
  * Static global variables
  */
-static DECLARE_WAIT_QUEUE_HEAD(random_wait);
+static DECLARE_WAIT_QUEUE_HEAD(random_read_wait);
+static DECLARE_WAIT_QUEUE_HEAD(random_write_wait);
 static struct fasync_struct *fasync;
 static DEFINE_SPINLOCK(random_ready_list_lock);
 		/* should we wake readers? */
 		if (entropy_bits >= random_read_wakeup_bits &&
-		    wq_has_sleeper(&random_wait)) {
+		    wq_has_sleeper(&random_read_wait)) {
-			wake_up_interruptible_poll(&random_wait, POLLIN);
+			wake_up_interruptible(&random_read_wait);
 			kill_fasync(&fasync, SIGIO, POLL_IN);
 		}
 		/* If the input pool is getting full, send some
 	trace_debit_entropy(r->name, 8 * ibytes);
 	if (ibytes &&
 	    (r->entropy_count >> ENTROPY_SHIFT) < random_write_wakeup_bits) {
-		wake_up_interruptible_poll(&random_wait, POLLOUT);
+		wake_up_interruptible(&random_write_wait);
 		kill_fasync(&fasync, SIGIO, POLL_OUT);
 	}
 		if (nonblock)
 			return -EAGAIN;
-		wait_event_interruptible(random_wait,
+		wait_event_interruptible(random_read_wait,
 			ENTROPY_BITS(&input_pool) >=
 			random_read_wakeup_bits);
 		if (signal_pending(current))
 	return ret;
 }
-static struct wait_queue_head *
-random_get_poll_head(struct file *file, __poll_t events)
-{
-	return &random_wait;
-}
 static __poll_t
-random_poll_mask(struct file *file, __poll_t events)
+random_poll(struct file *file, poll_table * wait)
 {
-	__poll_t mask = 0;
+	__poll_t mask;
+	poll_wait(file, &random_read_wait, wait);
+	poll_wait(file, &random_write_wait, wait);
+	mask = 0;
 	if (ENTROPY_BITS(&input_pool) >= random_read_wakeup_bits)
 		mask |= EPOLLIN | EPOLLRDNORM;
 	if (ENTROPY_BITS(&input_pool) < random_write_wakeup_bits)
 const struct file_operations random_fops = {
 	.read  = random_read,
 	.write = random_write,
-	.get_poll_head  = random_get_poll_head,
+	.poll  = random_poll,
-	.poll_mask  = random_poll_mask,
 	.unlocked_ioctl = random_ioctl,
 	.fasync = random_fasync,
 	.llseek = noop_llseek,
 	 * We'll be woken up again once below random_write_wakeup_thresh,
 	 * or when the calling thread is about to terminate.
 	 */
-	wait_event_interruptible(random_wait, kthread_should_stop() ||
+	wait_event_interruptible(random_write_wait, kthread_should_stop() ||
 			ENTROPY_BITS(&input_pool) <= random_write_wakeup_bits);
 	mix_pool_bytes(poolp, buffer, count);
 	credit_entropy_bits(poolp, entropy);

drivers/cpufreq/qcom-cpufreq-kryo.c+4−4

@@ -87,8 +87,8 @@ static int qcom_cpufreq_kryo_probe(struct platform_device *pdev) · 86 unmodified lines
87	int ret;	87	int ret;
88		88
89	cpu_dev = get_cpu_device(0);	89	cpu_dev = get_cpu_device(0);
90	if (NULL == cpu_dev)	90	if (!cpu_dev)
91	ret = -ENODEV;	91	return -ENODEV;
92		92
93	msm8996_version = qcom_cpufreq_kryo_get_msm_id();	93	msm8996_version = qcom_cpufreq_kryo_get_msm_id();
94	if (NUM_OF_MSM8996_VERSIONS == msm8996_version) {	94	if (NUM_OF_MSM8996_VERSIONS == msm8996_version) {
@@ -97,8 +97,8 @@ static int qcom_cpufreq_kryo_probe(struct platform_device *pdev) · 2 unmodified lines
97	}	97	}
98		98
99	np = dev_pm_opp_of_get_opp_desc_node(cpu_dev);	99	np = dev_pm_opp_of_get_opp_desc_node(cpu_dev);
100	if (IS_ERR(np))	100	if (!np)
101	return PTR_ERR(np);	101	return -ENOENT;
102		102
103	ret = of_device_is_compatible(np, "operating-points-v2-kryo-cpu");	103	ret = of_device_is_compatible(np, "operating-points-v2-kryo-cpu");
104	if (!ret) {	104	if (!ret) {

drivers/dax/super.c+8−0

 {
 	struct dax_device *dax_dev;
 	bool dax_enabled = false;
+	struct request_queue *q;
 	pgoff_t pgoff;
 	int err, id;
 	void *kaddr;
 		return false;
 	}
+	q = bdev_get_queue(bdev);
+	if (!q || !blk_queue_dax(q)) {
+		pr_debug("%s: error: request queue doesn't support dax\n",
+				bdevname(bdev, buf));
+		return false;
+	}
 	err = bdev_dax_pgoff(bdev, 0, PAGE_SIZE, &pgoff);
 	if (err) {
 		pr_debug("%s: error: unaligned partition for dax\n",

drivers/gpu/drm/amd/amdgpu/amdgpu_fence.c+1−1

@@ -376,7 +376,7 @@ int amdgpu_fence_driver_start_ring(struct amdgpu_ring *ring, · 375 unmodified lines
376	struct amdgpu_device *adev = ring->adev;	376	struct amdgpu_device *adev = ring->adev;
377	uint64_t index;	377	uint64_t index;
378		378
379	if (ring != &adev->uvd.inst[ring->me].ring) {	379	if (ring->funcs->type != AMDGPU_RING_TYPE_UVD) {
380	ring->fence_drv.cpu_addr = &adev->wb.wb[ring->fence_offs];	380	ring->fence_drv.cpu_addr = &adev->wb.wb[ring->fence_offs];
381	ring->fence_drv.gpu_addr = adev->wb.gpu_addr + (ring->fence_offs * 4);	381	ring->fence_drv.gpu_addr = adev->wb.gpu_addr + (ring->fence_offs * 4);
382	} else {	382	} else {

drivers/gpu/drm/amd/amdgpu/amdgpu_vcn.c+27−6

@@ -52,7 +52,7 @@ int amdgpu_vcn_sw_init(struct amdgpu_device *adev) · 51 unmodified lines
52	unsigned long bo_size;	52	unsigned long bo_size;
53	const char *fw_name;	53	const char *fw_name;
54	const struct common_firmware_header *hdr;	54	const struct common_firmware_header *hdr;
55	unsigned version_major, version_minor, family_id;	55	unsigned char fw_check;
56	int r;	56	int r;
57		57
58	INIT_DELAYED_WORK(&adev->vcn.idle_work, amdgpu_vcn_idle_work_handler);	58	INIT_DELAYED_WORK(&adev->vcn.idle_work, amdgpu_vcn_idle_work_handler);
@@ -83,12 +83,33 @@ int amdgpu_vcn_sw_init(struct amdgpu_device *adev) · 24 unmodified lines
83		83
84	hdr = (const struct common_firmware_header *)adev->vcn.fw->data;	84	hdr = (const struct common_firmware_header *)adev->vcn.fw->data;
85	adev->vcn.fw_version = le32_to_cpu(hdr->ucode_version);	85	adev->vcn.fw_version = le32_to_cpu(hdr->ucode_version);
86	family_id = le32_to_cpu(hdr->ucode_version) & 0xff;
87	version_major = (le32_to_cpu(hdr->ucode_version) >> 24) & 0xff;
88	version_minor = (le32_to_cpu(hdr->ucode_version) >> 8) & 0xff;
89	DRM_INFO("Found VCN firmware Version: %hu.%hu Family ID: %hu\n",
90	version_major, version_minor, family_id);
91		86
		87	/* Bit 20-23, it is encode major and non-zero for new naming convention.
		88	* This field is part of version minor and DRM_DISABLED_FLAG in old naming
		89	* convention. Since the l:wq!atest version minor is 0x5B and DRM_DISABLED_FLAG
		90	* is zero in old naming convention, this field is always zero so far.
		91	* These four bits are used to tell which naming convention is present.
		92	*/
		93	fw_check = (le32_to_cpu(hdr->ucode_version) >> 20) & 0xf;
		94	if (fw_check) {
		95	unsigned int dec_ver, enc_major, enc_minor, vep, fw_rev;
		96
		97	fw_rev = le32_to_cpu(hdr->ucode_version) & 0xfff;
		98	enc_minor = (le32_to_cpu(hdr->ucode_version) >> 12) & 0xff;
		99	enc_major = fw_check;
		100	dec_ver = (le32_to_cpu(hdr->ucode_version) >> 24) & 0xf;
		101	vep = (le32_to_cpu(hdr->ucode_version) >> 28) & 0xf;
		102	DRM_INFO("Found VCN firmware Version ENC: %hu.%hu DEC: %hu VEP: %hu Revision: %hu\n",
		103	enc_major, enc_minor, dec_ver, vep, fw_rev);
		104	} else {
		105	unsigned int version_major, version_minor, family_id;
		106
		107	family_id = le32_to_cpu(hdr->ucode_version) & 0xff;
		108	version_major = (le32_to_cpu(hdr->ucode_version) >> 24) & 0xff;
		109	version_minor = (le32_to_cpu(hdr->ucode_version) >> 8) & 0xff;
		110	DRM_INFO("Found VCN firmware Version: %hu.%hu Family ID: %hu\n",
		111	version_major, version_minor, family_id);
		112	}
92		113
93	bo_size = AMDGPU_GPU_PAGE_ALIGN(le32_to_cpu(hdr->ucode_size_bytes) + 8)	114	bo_size = AMDGPU_GPU_PAGE_ALIGN(le32_to_cpu(hdr->ucode_size_bytes) + 8)
94	+ AMDGPU_VCN_STACK_SIZE + AMDGPU_VCN_HEAP_SIZE	115	+ AMDGPU_VCN_STACK_SIZE + AMDGPU_VCN_HEAP_SIZE

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c+5−3

 			uint64_t count;
 			max_entries = min(max_entries, 16ull * 1024ull);
-			for (count = 1; count < max_entries; ++count) {
+			for (count = 1;
+			     count < max_entries / (PAGE_SIZE / AMDGPU_GPU_PAGE_SIZE);
+			     ++count) {
 				uint64_t idx = pfn + count;
 				if (pages_addr[idx] !=
 				dma_addr = pages_addr;
 			} else {
 				addr = pages_addr[pfn];
-				max_entries = count;
+				max_entries = count * (PAGE_SIZE / AMDGPU_GPU_PAGE_SIZE);
 			}
 		} else if (flags & AMDGPU_PTE_VALID) {
 		if (r)
 			return r;
-		pfn += last - start + 1;
+		pfn += (last - start + 1) / (PAGE_SIZE / AMDGPU_GPU_PAGE_SIZE);
 		if (nodes && nodes->size == pfn) {
 			pfn = 0;
 			++nodes;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c+8−8

 	if (acrtc->base.state->event)
 		prepare_flip_isr(acrtc);
+	spin_unlock_irqrestore(&crtc->dev->event_lock, flags);
 	surface_updates->surface = dc_stream_get_status(acrtc_state->stream)->plane_states[0];
 	surface_updates->flip_addr = &addr;
 	dc_commit_updates_for_stream(adev->dm.dc,
 					     surface_updates,
 					     1,
 			 __func__,
 			 addr.address.grph.addr.high_part,
 			 addr.address.grph.addr.low_part);
-	spin_unlock_irqrestore(&crtc->dev->event_lock, flags);
 }
 /*
 	struct drm_connector *connector;
 	struct drm_connector_state *old_con_state, *new_con_state;
 	struct dm_crtc_state *dm_old_crtc_state, *dm_new_crtc_state;
+	int crtc_disable_count = 0;
 	drm_atomic_helper_update_legacy_modeset_state(dev, state);
 		struct amdgpu_crtc *acrtc = to_amdgpu_crtc(crtc);
 		bool modeset_needed;
+		if (old_crtc_state->active && !new_crtc_state->active)
+			crtc_disable_count++;
 		dm_new_crtc_state = to_dm_crtc_state(new_crtc_state);
 		dm_old_crtc_state = to_dm_crtc_state(old_crtc_state);
 		modeset_needed = modeset_required(
 	 * so we can put the GPU into runtime suspend if we're not driving any
 	 * displays anymore
 	 */
+	for (i = 0; i < crtc_disable_count; i++)
+		pm_runtime_put_autosuspend(dev->dev);
 	pm_runtime_mark_last_busy(dev->dev);
-	for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
-		if (old_crtc_state->active && !new_crtc_state->active)
-			pm_runtime_put_autosuspend(dev->dev);
-	}
 }

drivers/gpu/drm/arm/malidp_drv.c+2−1

 static void malidp_fini(struct drm_device *drm)
 {
-	drm_atomic_helper_shutdown(drm);
 	drm_mode_config_cleanup(drm);
 }
 	malidp_de_irq_fini(drm);
 	drm->irq_enabled = false;
 irq_init_fail:
+	drm_atomic_helper_shutdown(drm);
 	component_unbind_all(dev, drm);
 bind_fail:
 	of_node_put(malidp->crtc.port);
 	malidp_se_irq_fini(drm);
 	malidp_de_irq_fini(drm);
 	drm->irq_enabled = false;
+	drm_atomic_helper_shutdown(drm);
 	component_unbind_all(dev, drm);
 	of_node_put(malidp->crtc.port);
 	malidp->crtc.port = NULL;

drivers/gpu/drm/arm/malidp_hw.c+2−1

 				.vsync_irq = MALIDP500_DE_IRQ_VSYNC,
 			},
 			.se_irq_map = {
-				.irq_mask = MALIDP500_SE_IRQ_CONF_MODE,
+				.irq_mask = MALIDP500_SE_IRQ_CONF_MODE |
+					    MALIDP500_SE_IRQ_GLOBAL,
 				.vsync_irq = 0,
 			},
 			.dc_irq_map = {

drivers/gpu/drm/arm/malidp_planes.c+6−3

 /* Layer specific register offsets */
 #define MALIDP_LAYER_FORMAT		0x000
+#define   LAYER_FORMAT_MASK		0x3f
 #define MALIDP_LAYER_CONTROL		0x004
 #define   LAYER_ENABLE			(1 << 0)
 #define   LAYER_FLOWCFG_MASK		7
 	if (state->rotation & MALIDP_ROTATED_MASK) {
 		int val;
-		val = mp->hwdev->hw->rotmem_required(mp->hwdev, state->crtc_h,
+		val = mp->hwdev->hw->rotmem_required(mp->hwdev, state->crtc_w,
-						     state->crtc_w,
+						     state->crtc_h,
 						     fb->format->format);
 		if (val < 0)
 			return val;
 	dest_w = plane->state->crtc_w;
 	dest_h = plane->state->crtc_h;
-	malidp_hw_write(mp->hwdev, ms->format, mp->layer->base);
+	val = malidp_hw_read(mp->hwdev, mp->layer->base);
+	val = (val & ~LAYER_FORMAT_MASK) | ms->format;
+	malidp_hw_write(mp->hwdev, val, mp->layer->base);
 	for (i = 0; i < ms->n_planes; i++) {
 		/* calculate the offset for the layer's plane registers */

drivers/gpu/drm/i915/i915_drv.h+0−3

  **/
 static inline struct scatterlist *__sg_next(struct scatterlist *sg)
 {
-#ifdef CONFIG_DEBUG_SG
-	BUG_ON(sg->sg_magic != SG_MAGIC);
-#endif
 	return sg_is_last(sg) ? NULL : ____sg_next(sg);
 }

drivers/gpu/drm/meson/meson_drv.c+8−4

 	priv->io_base = regs;
 	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "hhi");
-	if (!res)
+	if (!res) {
-		return -EINVAL;
+		ret = -EINVAL;
+		goto free_drm;
+	}
 	/* Simply ioremap since it may be a shared register zone */
 	regs = devm_ioremap(dev, res->start, resource_size(res));
 	if (!regs) {
 	}
 	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dmc");
-	if (!res)
+	if (!res) {
-		return -EINVAL;
+		ret = -EINVAL;
+		goto free_drm;
+	}
 	/* Simply ioremap since it may be a shared register zone */
 	regs = devm_ioremap(dev, res->start, resource_size(res));
 	if (!regs) {

drivers/i2c/algos/i2c-algo-bit.c+4−4

@@ -647,10 +647,10 @@ static int __i2c_bit_add_bus(struct i2c_adapter *adap, · 646 unmodified lines
647	if (bit_adap->getscl == NULL)	647	if (bit_adap->getscl == NULL)
648	adap->quirks = &i2c_bit_quirk_no_clk_stretch;	648	adap->quirks = &i2c_bit_quirk_no_clk_stretch;
649		649
650	/* Bring bus to a known state. Looks like STOP if bus is not free yet */	650	/*
651	setscl(bit_adap, 1);	651	* We tried forcing SCL/SDA to an initial state here. But that caused a
652	udelay(bit_adap->udelay);	652	* regression, sadly. Check Bugzilla #200045 for details.
653	setsda(bit_adap, 1);	653	*/
654		654
655	ret = add_adapter(adap);	655	ret = add_adapter(adap);
656	if (ret < 0)	656	if (ret < 0)

drivers/i2c/busses/i2c-gpio.c+2−2

@@ -279,9 +279,9 @@ static int i2c_gpio_probe(struct platform_device *pdev) · 278 unmodified lines
279	* required for an I2C bus.	279	* required for an I2C bus.
280	*/	280	*/
281	if (pdata->scl_is_open_drain)	281	if (pdata->scl_is_open_drain)
282	gflags = GPIOD_OUT_LOW;	282	gflags = GPIOD_OUT_HIGH;
283	else	283	else
284	gflags = GPIOD_OUT_LOW_OPEN_DRAIN;	284	gflags = GPIOD_OUT_HIGH_OPEN_DRAIN;
285	priv->scl = i2c_gpio_get_desc(dev, "scl", 1, gflags);	285	priv->scl = i2c_gpio_get_desc(dev, "scl", 1, gflags);
286	if (IS_ERR(priv->scl))	286	if (IS_ERR(priv->scl))
287	return PTR_ERR(priv->scl);	287	return PTR_ERR(priv->scl);

drivers/i2c/i2c-core-smbus.c+9−5

 	status = i2c_transfer(adapter, msg, num);
 	if (status < 0)
-		return status;
+		goto cleanup;
-	if (status != num)
+	if (status != num) {
-		return -EIO;
+		status = -EIO;
+		goto cleanup;
+	}
+	status = 0;
 	/* Check PEC if last message is a read */
 	if (i && (msg[num-1].flags & I2C_M_RD)) {
 		status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
 		if (status < 0)
-			return status;
+			goto cleanup;
 	}
 	if (read_write == I2C_SMBUS_READ)
 			break;
 		}
+cleanup:
 	if (msg[0].flags & I2C_M_DMA_SAFE)
 		kfree(msg[0].buf);
 	if (msg[1].flags & I2C_M_DMA_SAFE)
 		kfree(msg[1].buf);
-	return 0;
+	return status;
 }
 /**

drivers/iio/accel/mma8452.c+1−1

@@ -1053,7 +1053,7 @@ static irqreturn_t mma8452_interrupt(int irq, void *p) · 1052 unmodified lines
1053	if (src < 0)	1053	if (src < 0)
1054	return IRQ_NONE;	1054	return IRQ_NONE;
1055		1055
1056	if (!(src & data->chip_info->enabled_events))	1056	if (!(src & (data->chip_info->enabled_events \| MMA8452_INT_DRDY)))
1057	return IRQ_NONE;	1057	return IRQ_NONE;
1058		1058
1059	if (src & MMA8452_INT_DRDY) {	1059	if (src & MMA8452_INT_DRDY) {

drivers/iio/imu/inv_mpu6050/inv_mpu_core.c+2−0

@@ -959,6 +959,8 @@ int inv_mpu_core_probe(struct regmap regmap, int irq, const char name, · 958 unmodified lines
959	}	959	}
960		960
961	irq_type = irqd_get_trigger_type(desc);	961	irq_type = irqd_get_trigger_type(desc);
		962	if (!irq_type)
		963	irq_type = IRQF_TRIGGER_RISING;
962	if (irq_type == IRQF_TRIGGER_RISING)	964	if (irq_type == IRQF_TRIGGER_RISING)
963	st->irq_mask = INV_MPU6050_ACTIVE_HIGH;	965	st->irq_mask = INV_MPU6050_ACTIVE_HIGH;
964	else if (irq_type == IRQF_TRIGGER_FALLING)	966	else if (irq_type == IRQF_TRIGGER_FALLING)

drivers/iio/light/tsl2772.c+2−0

@@ -582,6 +582,8 @@ static int tsl2772_als_calibrate(struct iio_dev *indio_dev) · 581 unmodified lines
582	"%s: failed to get lux\n", __func__);	582	"%s: failed to get lux\n", __func__);
583	return lux_val;	583	return lux_val;
584	}	584	}
		585	if (lux_val == 0)
		586	return -ERANGE;
585		587
586	ret = (chip->settings.als_cal_target * chip->settings.als_gain_trim) /	588	ret = (chip->settings.als_cal_target * chip->settings.als_gain_trim) /
587	lux_val;	589	lux_val;

drivers/iio/pressure/bmp280-core.c+2−3

@@ -415,10 +415,9 @@ static int bmp280_read_humid(struct bmp280_data data, int val, int *val2) · 414 unmodified lines
415	}	415	}
416	comp_humidity = bmp280_compensate_humidity(data, adc_humidity);	416	comp_humidity = bmp280_compensate_humidity(data, adc_humidity);
417		417
418	*val = comp_humidity;	418	val = comp_humidity 1000 / 1024;
419	*val2 = 1024;
420		419
421	return IIO_VAL_FRACTIONAL;	420	return IIO_VAL_INT;
422	}	421	}
423		422
424	static int bmp280_read_raw(struct iio_dev *indio_dev,	423	static int bmp280_read_raw(struct iio_dev *indio_dev,

drivers/infiniband/hw/mlx5/main.c+1−1

@@ -6113,7 +6113,7 @@ static void mlx5_ib_add(struct mlx5_core_dev mdev) · 6112 unmodified lines
6113	dev->num_ports = max(MLX5_CAP_GEN(mdev, num_ports),	6113	dev->num_ports = max(MLX5_CAP_GEN(mdev, num_ports),
6114	MLX5_CAP_GEN(mdev, num_vhca_ports));	6114	MLX5_CAP_GEN(mdev, num_vhca_ports));
6115		6115
6116	if (MLX5_VPORT_MANAGER(mdev) &&	6116	if (MLX5_ESWITCH_MANAGER(mdev) &&
6117	mlx5_ib_eswitch_mode(mdev->priv.eswitch) == SRIOV_OFFLOADS) {	6117	mlx5_ib_eswitch_mode(mdev->priv.eswitch) == SRIOV_OFFLOADS) {
6118	dev->rep = mlx5_ib_vport_rep(mdev->priv.eswitch, 0);	6118	dev->rep = mlx5_ib_vport_rep(mdev->priv.eswitch, 0);
6119		6119

drivers/input/input-mt.c+8−4

  * inactive, or if the tool type is changed, a new tracking id is
  * assigned to the slot. The tool type is only reported if the
  * corresponding absbit field is set.
+ *
+ * Returns true if contact is active.
  */
-void input_mt_report_slot_state(struct input_dev *dev,
+bool input_mt_report_slot_state(struct input_dev *dev,
 				unsigned int tool_type, bool active)
 {
 	struct input_mt *mt = dev->mt;
 	int id;
 	if (!mt)
-		return;
+		return false;
 	slot = &mt->slots[mt->slot];
 	slot->frame = mt->frame;
 	if (!active) {
 		input_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
-		return;
+		return false;
 	}
 	id = input_mt_get_value(slot, ABS_MT_TRACKING_ID);
-	if (id < 0 || input_mt_get_value(slot, ABS_MT_TOOL_TYPE) != tool_type)
+	if (id < 0)
 		id = input_mt_new_trkid(mt);
 	input_event(dev, EV_ABS, ABS_MT_TRACKING_ID, id);
 	input_event(dev, EV_ABS, ABS_MT_TOOL_TYPE, tool_type);
+	return true;
 }
 EXPORT_SYMBOL(input_mt_report_slot_state);

drivers/input/joystick/xpad.c+1−1

@@ -125,7 +125,7 @@ static const struct xpad_device { · 124 unmodified lines
125	u8 mapping;	125	u8 mapping;
126	u8 xtype;	126	u8 xtype;
127	} xpad_device[] = {	127	} xpad_device[] = {
128	{ 0x0079, 0x18d4, "GPD Win 2 Controller", 0, XTYPE_XBOX360 },	128	{ 0x0079, 0x18d4, "GPD Win 2 X-Box Controller", 0, XTYPE_XBOX360 },
129	{ 0x044f, 0x0f00, "Thrustmaster Wheel", 0, XTYPE_XBOX },	129	{ 0x044f, 0x0f00, "Thrustmaster Wheel", 0, XTYPE_XBOX },
130	{ 0x044f, 0x0f03, "Thrustmaster Wheel", 0, XTYPE_XBOX },	130	{ 0x044f, 0x0f03, "Thrustmaster Wheel", 0, XTYPE_XBOX },
131	{ 0x044f, 0x0f07, "Thrustmaster, Inc. Controller", 0, XTYPE_XBOX },	131	{ 0x044f, 0x0f07, "Thrustmaster, Inc. Controller", 0, XTYPE_XBOX },

drivers/input/keyboard/goldfish_events.c+5−4

@@ -45,7 +45,7 @@ struct event_dev { · 44 unmodified lines
45	static irqreturn_t events_interrupt(int irq, void *dev_id)	45	static irqreturn_t events_interrupt(int irq, void *dev_id)
46	{	46	{
47	struct event_dev *edev = dev_id;	47	struct event_dev *edev = dev_id;
48	unsigned type, code, value;	48	unsigned int type, code, value;
49		49
50	type = __raw_readl(edev->addr + REG_READ);	50	type = __raw_readl(edev->addr + REG_READ);
51	code = __raw_readl(edev->addr + REG_READ);	51	code = __raw_readl(edev->addr + REG_READ);
@@ -57,7 +57,7 @@ static irqreturn_t events_interrupt(int irq, void *dev_id) · 5 unmodified lines
57	}	57	}
58		58
59	static void events_import_bits(struct event_dev *edev,	59	static void events_import_bits(struct event_dev *edev,
60	unsigned long bits[], unsigned type, size_t count)	60	unsigned long bits[], unsigned int type, size_t count)
61	{	61	{
62	void __iomem *addr = edev->addr;	62	void __iomem *addr = edev->addr;
63	int i, j;	63	int i, j;
@@ -99,6 +99,7 @@ static void events_import_abs_params(struct event_dev *edev) · 35 unmodified lines
99		99
100	for (j = 0; j < ARRAY_SIZE(val); j++) {	100	for (j = 0; j < ARRAY_SIZE(val); j++) {
101	int offset = (i * ARRAY_SIZE(val) + j) * sizeof(u32);	101	int offset = (i * ARRAY_SIZE(val) + j) * sizeof(u32);
		102
102	val[j] = __raw_readl(edev->addr + REG_DATA + offset);	103	val[j] = __raw_readl(edev->addr + REG_DATA + offset);
103	}	104	}
104		105
@@ -112,7 +113,7 @@ static int events_probe(struct platform_device *pdev) · 7 unmodified lines
112	struct input_dev *input_dev;	113	struct input_dev *input_dev;
113	struct event_dev *edev;	114	struct event_dev *edev;
114	struct resource *res;	115	struct resource *res;
115	unsigned keymapnamelen;	116	unsigned int keymapnamelen;
116	void __iomem *addr;	117	void __iomem *addr;
117	int irq;	118	int irq;
118	int i;	119	int i;
@@ -150,7 +151,7 @@ static int events_probe(struct platform_device *pdev) · 31 unmodified lines
150	for (i = 0; i < keymapnamelen; i++)	151	for (i = 0; i < keymapnamelen; i++)
151	edev->name[i] = __raw_readb(edev->addr + REG_DATA + i);	152	edev->name[i] = __raw_readb(edev->addr + REG_DATA + i);
152		153
153	pr_debug("events_probe() keymap=%s\n", edev->name);	154	pr_debug("%s: keymap=%s\n", __func__, edev->name);
154		155
155	input_dev->name = edev->name;	156	input_dev->name = edev->name;
156	input_dev->id.bustype = BUS_HOST;	157	input_dev->id.bustype = BUS_HOST;

drivers/input/misc/Kconfig+10−0

@@ -841,4 +841,14 @@ config INPUT_RAVE_SP_PWRBUTTON · 840 unmodified lines
841	To compile this driver as a module, choose M here: the	841	To compile this driver as a module, choose M here: the
842	module will be called rave-sp-pwrbutton.	842	module will be called rave-sp-pwrbutton.
843		843
		844	config INPUT_SC27XX_VIBRA
		845	tristate "Spreadtrum sc27xx vibrator support"
		846	depends on MFD_SC27XX_PMIC \|\| COMPILE_TEST
		847	select INPUT_FF_MEMLESS
		848	help
		849	This option enables support for Spreadtrum sc27xx vibrator driver.
		850
		851	To compile this driver as a module, choose M here. The module will
		852	be called sc27xx_vibra.
		853
844	endif	854	endif

drivers/input/misc/Makefile+1−0

@@ -66,6 +66,7 @@ obj-$(CONFIG_INPUT_RETU_PWRBUTTON) += retu-pwrbutton.o · 65 unmodified lines
66	obj-$(CONFIG_INPUT_AXP20X_PEK) += axp20x-pek.o	66	obj-$(CONFIG_INPUT_AXP20X_PEK) += axp20x-pek.o
67	obj-$(CONFIG_INPUT_GPIO_ROTARY_ENCODER) += rotary_encoder.o	67	obj-$(CONFIG_INPUT_GPIO_ROTARY_ENCODER) += rotary_encoder.o
68	obj-$(CONFIG_INPUT_RK805_PWRKEY) += rk805-pwrkey.o	68	obj-$(CONFIG_INPUT_RK805_PWRKEY) += rk805-pwrkey.o
		69	obj-$(CONFIG_INPUT_SC27XX_VIBRA) += sc27xx-vibra.o
69	obj-$(CONFIG_INPUT_SGI_BTNS) += sgi_btns.o	70	obj-$(CONFIG_INPUT_SGI_BTNS) += sgi_btns.o
70	obj-$(CONFIG_INPUT_SIRFSOC_ONKEY) += sirfsoc-onkey.o	71	obj-$(CONFIG_INPUT_SIRFSOC_ONKEY) += sirfsoc-onkey.o
71	obj-$(CONFIG_INPUT_SOC_BUTTON_ARRAY) += soc_button_array.o	72	obj-$(CONFIG_INPUT_SOC_BUTTON_ARRAY) += soc_button_array.o

drivers/input/misc/sc27xx-vibra.c+154−0

@@ -0,0 +1,154 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Copyright (C) 2018 Spreadtrum Communications Inc.
	4	*/
	5
	6	#include <linux/module.h>
	7	#include <linux/of_address.h>
	8	#include <linux/platform_device.h>
	9	#include <linux/regmap.h>
	10	#include <linux/input.h>
	11	#include <linux/workqueue.h>
	12
	13	#define CUR_DRV_CAL_SEL GENMASK(13, 12)
	14	#define SLP_LDOVIBR_PD_EN BIT(9)
	15	#define LDO_VIBR_PD BIT(8)
	16
	17	struct vibra_info {
	18	struct input_dev *input_dev;
	19	struct work_struct play_work;
	20	struct regmap *regmap;
	21	u32 base;
	22	u32 strength;
	23	bool enabled;
	24	};
	25
	26	static void sc27xx_vibra_set(struct vibra_info *info, bool on)
	27	{
	28	if (on) {
	29	regmap_update_bits(info->regmap, info->base, LDO_VIBR_PD, 0);
	30	regmap_update_bits(info->regmap, info->base,
	31	SLP_LDOVIBR_PD_EN, 0);
	32	info->enabled = true;
	33	} else {
	34	regmap_update_bits(info->regmap, info->base, LDO_VIBR_PD,
	35	LDO_VIBR_PD);
	36	regmap_update_bits(info->regmap, info->base,
	37	SLP_LDOVIBR_PD_EN, SLP_LDOVIBR_PD_EN);
	38	info->enabled = false;
	39	}
	40	}
	41
	42	static int sc27xx_vibra_hw_init(struct vibra_info *info)
	43	{
	44	return regmap_update_bits(info->regmap, info->base, CUR_DRV_CAL_SEL, 0);
	45	}
	46
	47	static void sc27xx_vibra_play_work(struct work_struct *work)
	48	{
	49	struct vibra_info *info = container_of(work, struct vibra_info,
	50	play_work);
	51
	52	if (info->strength && !info->enabled)
	53	sc27xx_vibra_set(info, true);
	54	else if (info->strength == 0 && info->enabled)
	55	sc27xx_vibra_set(info, false);
	56	}
	57
	58	static int sc27xx_vibra_play(struct input_dev input, void data,
	59	struct ff_effect *effect)
	60	{
	61	struct vibra_info *info = input_get_drvdata(input);
	62
	63	info->strength = effect->u.rumble.weak_magnitude;
	64	schedule_work(&info->play_work);
	65
	66	return 0;
	67	}
	68
	69	static void sc27xx_vibra_close(struct input_dev *input)
	70	{
	71	struct vibra_info *info = input_get_drvdata(input);
	72
	73	cancel_work_sync(&info->play_work);
	74	if (info->enabled)
	75	sc27xx_vibra_set(info, false);
	76	}
	77
	78	static int sc27xx_vibra_probe(struct platform_device *pdev)
	79	{
	80	struct vibra_info *info;
	81	int error;
	82
	83	info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
	84	if (!info)
	85	return -ENOMEM;
	86
	87	info->regmap = dev_get_regmap(pdev->dev.parent, NULL);
	88	if (!info->regmap) {
	89	dev_err(&pdev->dev, "failed to get vibrator regmap.\n");
	90	return -ENODEV;
	91	}
	92
	93	error = device_property_read_u32(&pdev->dev, "reg", &info->base);
	94	if (error) {
	95	dev_err(&pdev->dev, "failed to get vibrator base address.\n");
	96	return error;
	97	}
	98
	99	info->input_dev = devm_input_allocate_device(&pdev->dev);
	100	if (!info->input_dev) {
	101	dev_err(&pdev->dev, "failed to allocate input device.\n");
	102	return -ENOMEM;
	103	}
	104
	105	info->input_dev->name = "sc27xx:vibrator";
	106	info->input_dev->id.version = 0;
	107	info->input_dev->close = sc27xx_vibra_close;
	108
	109	input_set_drvdata(info->input_dev, info);
	110	input_set_capability(info->input_dev, EV_FF, FF_RUMBLE);
	111	INIT_WORK(&info->play_work, sc27xx_vibra_play_work);
	112	info->enabled = false;
	113
	114	error = sc27xx_vibra_hw_init(info);
	115	if (error) {
	116	dev_err(&pdev->dev, "failed to initialize the vibrator.\n");
	117	return error;
	118	}
	119
	120	error = input_ff_create_memless(info->input_dev, NULL,
	121	sc27xx_vibra_play);
	122	if (error) {
	123	dev_err(&pdev->dev, "failed to register vibrator to FF.\n");
	124	return error;
	125	}
	126
	127	error = input_register_device(info->input_dev);
	128	if (error) {
	129	dev_err(&pdev->dev, "failed to register input device.\n");
	130	return error;
	131	}
	132
	133	return 0;
	134	}
	135
	136	static const struct of_device_id sc27xx_vibra_of_match[] = {
	137	{ .compatible = "sprd,sc2731-vibrator", },
	138	{}
	139	};
	140	MODULE_DEVICE_TABLE(of, sc27xx_vibra_of_match);
	141
	142	static struct platform_driver sc27xx_vibra_driver = {
	143	.driver = {
	144	.name = "sc27xx-vibrator",
	145	.of_match_table = sc27xx_vibra_of_match,
	146	},
	147	.probe = sc27xx_vibra_probe,
	148	};
	149
	150	module_platform_driver(sc27xx_vibra_driver);
	151
	152	MODULE_DESCRIPTION("Spreadtrum SC27xx Vibrator Driver");
	153	MODULE_LICENSE("GPL v2");
	154	MODULE_AUTHOR("Xiaotong Lu <xiaotong.lu@spreadtrum.com>");

drivers/input/mouse/elan_i2c.h+2−0

@@ -27,6 +27,8 @@ · 26 unmodified lines
27	#define ETP_DISABLE_POWER 0x0001	27	#define ETP_DISABLE_POWER 0x0001
28	#define ETP_PRESSURE_OFFSET 25	28	#define ETP_PRESSURE_OFFSET 25
29		29
		30	#define ETP_CALIBRATE_MAX_LEN 3
		31
30	/* IAP Firmware handling */	32	/* IAP Firmware handling */
31	#define ETP_PRODUCT_ID_FORMAT_STRING "%d.0"	33	#define ETP_PRODUCT_ID_FORMAT_STRING "%d.0"
32	#define ETP_FW_NAME "elan_i2c_" ETP_PRODUCT_ID_FORMAT_STRING ".bin"	34	#define ETP_FW_NAME "elan_i2c_" ETP_PRODUCT_ID_FORMAT_STRING ".bin"

drivers/input/mouse/elan_i2c_core.c+2−1

 	int tries = 20;
 	int retval;
 	int error;
-	u8 val[3];
+	u8 val[ETP_CALIBRATE_MAX_LEN];
 	retval = mutex_lock_interruptible(&data->sysfs_mutex);
 	if (retval)
 	{ "ELAN060C", 0 },
 	{ "ELAN0611", 0 },
 	{ "ELAN0612", 0 },
+	{ "ELAN0618", 0 },
 	{ "ELAN1000", 0 },
 	{ }
 };

drivers/input/mouse/elan_i2c_smbus.c+8−2

 static int elan_smbus_initialize(struct i2c_client *client)
 {
 	u8 check[ETP_SMBUS_HELLOPACKET_LEN] = { 0x55, 0x55, 0x55, 0x55, 0x55 };
-	u8 values[ETP_SMBUS_HELLOPACKET_LEN] = { 0, 0, 0, 0, 0 };
+	u8 values[I2C_SMBUS_BLOCK_MAX] = {0};
 	int len, error;
 	/* Get hello packet */
 static int elan_smbus_calibrate_result(struct i2c_client *client, u8 *val)
 {
 	int error;
+	u8 buf[I2C_SMBUS_BLOCK_MAX] = {0};
+	BUILD_BUG_ON(ETP_CALIBRATE_MAX_LEN > sizeof(buf));
 	error = i2c_smbus_read_block_data(client,
-					  ETP_SMBUS_CALIBRATE_QUERY, val);
+					  ETP_SMBUS_CALIBRATE_QUERY, buf);
 	if (error < 0)
 		return error;
+	memcpy(val, buf, ETP_CALIBRATE_MAX_LEN);
 	return 0;
 }
 {
 	int len;
+	BUILD_BUG_ON(I2C_SMBUS_BLOCK_MAX > ETP_SMBUS_REPORT_LEN);
 	len = i2c_smbus_read_block_data(client,
 					ETP_SMBUS_PACKET_QUERY,
 					&report[ETP_SMBUS_REPORT_OFFSET]);

drivers/input/mouse/elantech.c+9−2

 	else if (ic_version == 7 && etd->info.samples[1] == 0x2A)
 		sanity_check = ((packet[3] & 0x1c) == 0x10);
 	else
-		sanity_check = ((packet[0] & 0x0c) == 0x04 &&
+		sanity_check = ((packet[0] & 0x08) == 0x00 &&
 				(packet[3] & 0x1c) == 0x10);
 	if (!sanity_check)
 	{ }
 };
+static const char * const middle_button_pnp_ids[] = {
+	"LEN2131", /* ThinkPad P52 w/ NFC */
+	"LEN2132", /* ThinkPad P52 */
+	NULL
+};
 /*
  * Set the appropriate event bits for the input subsystem
  */
 	__clear_bit(EV_REL, dev->evbit);
 	__set_bit(BTN_LEFT, dev->keybit);
-	if (dmi_check_system(elantech_dmi_has_middle_button))
+	if (dmi_check_system(elantech_dmi_has_middle_button) ||
+			psmouse_matches_pnp_id(psmouse, middle_button_pnp_ids))
 		__set_bit(BTN_MIDDLE, dev->keybit);
 	__set_bit(BTN_RIGHT, dev->keybit);

drivers/input/mouse/psmouse-base.c+6−6

@@ -192,8 +192,8 @@ psmouse_ret_t psmouse_process_byte(struct psmouse *psmouse) · 191 unmodified lines
192	else	192	else
193	input_report_rel(dev, REL_WHEEL, -wheel);	193	input_report_rel(dev, REL_WHEEL, -wheel);
194		194
195	input_report_key(dev, BTN_SIDE, BIT(4));	195	input_report_key(dev, BTN_SIDE, packet[3] & BIT(4));
196	input_report_key(dev, BTN_EXTRA, BIT(5));	196	input_report_key(dev, BTN_EXTRA, packet[3] & BIT(5));
197	break;	197	break;
198	}	198	}
199	break;	199	break;
@@ -203,13 +203,13 @@ psmouse_ret_t psmouse_process_byte(struct psmouse *psmouse) · 3 unmodified lines
203	input_report_rel(dev, REL_WHEEL, -(s8) packet[3]);	203	input_report_rel(dev, REL_WHEEL, -(s8) packet[3]);
204		204
205	/* Extra buttons on Genius NewNet 3D */	205	/* Extra buttons on Genius NewNet 3D */
206	input_report_key(dev, BTN_SIDE, BIT(6));	206	input_report_key(dev, BTN_SIDE, packet[0] & BIT(6));
207	input_report_key(dev, BTN_EXTRA, BIT(7));	207	input_report_key(dev, BTN_EXTRA, packet[0] & BIT(7));
208	break;	208	break;
209		209
210	case PSMOUSE_THINKPS:	210	case PSMOUSE_THINKPS:
211	/* Extra button on ThinkingMouse */	211	/* Extra button on ThinkingMouse */
212	input_report_key(dev, BTN_EXTRA, BIT(3));	212	input_report_key(dev, BTN_EXTRA, packet[0] & BIT(3));
213		213
214	/*	214	/*
215	* Without this bit of weirdness moving up gives wildly	215	* Without this bit of weirdness moving up gives wildly
@@ -223,7 +223,7 @@ psmouse_ret_t psmouse_process_byte(struct psmouse *psmouse) · 7 unmodified lines
223	* Cortron PS2 Trackball reports SIDE button in the	223	* Cortron PS2 Trackball reports SIDE button in the
224	* 4th bit of the first byte.	224	* 4th bit of the first byte.
225	*/	225	*/
226	input_report_key(dev, BTN_SIDE, BIT(3));	226	input_report_key(dev, BTN_SIDE, packet[0] & BIT(3));
227	packet[0] \|= BIT(3);	227	packet[0] \|= BIT(3);
228	break;	228	break;
229		229

drivers/input/rmi4/Kconfig+1−0

@@ -3,6 +3,7 @@ · 2 unmodified lines
3	#	3	#
4	config RMI4_CORE	4	config RMI4_CORE
5	tristate "Synaptics RMI4 bus support"	5	tristate "Synaptics RMI4 bus support"
		6	select IRQ_DOMAIN
6	help	7	help
7	Say Y here if you want to support the Synaptics RMI4 bus. This is	8	Say Y here if you want to support the Synaptics RMI4 bus. This is
8	required for all RMI4 device support.	9	required for all RMI4 device support.

drivers/input/rmi4/rmi_2d_sensor.c+16−18

@@ -32,15 +32,15 @@ void rmi_2d_sensor_abs_process(struct rmi_2d_sensor *sensor, · 31 unmodified lines
32	if (obj->type == RMI_2D_OBJECT_NONE)	32	if (obj->type == RMI_2D_OBJECT_NONE)
33	return;	33	return;
34		34
35	if (axis_align->swap_axes)
36	swap(obj->x, obj->y);
37
38	if (axis_align->flip_x)	35	if (axis_align->flip_x)
39	obj->x = sensor->max_x - obj->x;	36	obj->x = sensor->max_x - obj->x;
40		37
41	if (axis_align->flip_y)	38	if (axis_align->flip_y)
42	obj->y = sensor->max_y - obj->y;	39	obj->y = sensor->max_y - obj->y;
43		40
		41	if (axis_align->swap_axes)
		42	swap(obj->x, obj->y);
		43
44	/*	44	/*
45	* Here checking if X offset or y offset are specified is	45	* Here checking if X offset or y offset are specified is
46	* redundant. We just add the offsets or clip the values.	46	* redundant. We just add the offsets or clip the values.
@@ -120,15 +120,15 @@ void rmi_2d_sensor_rel_report(struct rmi_2d_sensor *sensor, int x, int y) · 73 unmodified lines
120	x = min(RMI_2D_REL_POS_MAX, max(RMI_2D_REL_POS_MIN, (int)x));	120	x = min(RMI_2D_REL_POS_MAX, max(RMI_2D_REL_POS_MIN, (int)x));
121	y = min(RMI_2D_REL_POS_MAX, max(RMI_2D_REL_POS_MIN, (int)y));	121	y = min(RMI_2D_REL_POS_MAX, max(RMI_2D_REL_POS_MIN, (int)y));
122		122
123	if (axis_align->swap_axes)
124	swap(x, y);
125
126	if (axis_align->flip_x)	123	if (axis_align->flip_x)
127	x = min(RMI_2D_REL_POS_MAX, -x);	124	x = min(RMI_2D_REL_POS_MAX, -x);
128		125
129	if (axis_align->flip_y)	126	if (axis_align->flip_y)
130	y = min(RMI_2D_REL_POS_MAX, -y);	127	y = min(RMI_2D_REL_POS_MAX, -y);
131		128
		129	if (axis_align->swap_axes)
		130	swap(x, y);
		131
132	if (x \|\| y) {	132	if (x \|\| y) {
133	input_report_rel(sensor->input, REL_X, x);	133	input_report_rel(sensor->input, REL_X, x);
134	input_report_rel(sensor->input, REL_Y, y);	134	input_report_rel(sensor->input, REL_Y, y);
@@ -141,17 +141,10 @@ static void rmi_2d_sensor_set_input_params(struct rmi_2d_sensor *sensor) · 6 unmodified lines
141	struct input_dev *input = sensor->input;	141	struct input_dev *input = sensor->input;
142	int res_x;	142	int res_x;
143	int res_y;	143	int res_y;
		144	int max_x, max_y;
144	int input_flags = 0;	145	int input_flags = 0;
145		146
146	if (sensor->report_abs) {	147	if (sensor->report_abs) {
147	if (sensor->axis_align.swap_axes) {
148	swap(sensor->max_x, sensor->max_y);
149	swap(sensor->axis_align.clip_x_low,
150	sensor->axis_align.clip_y_low);
151	swap(sensor->axis_align.clip_x_high,
152	sensor->axis_align.clip_y_high);
153	}
154
155	sensor->min_x = sensor->axis_align.clip_x_low;	148	sensor->min_x = sensor->axis_align.clip_x_low;
156	if (sensor->axis_align.clip_x_high)	149	if (sensor->axis_align.clip_x_high)
157	sensor->max_x = min(sensor->max_x,	150	sensor->max_x = min(sensor->max_x,
@@ -163,14 +156,19 @@ static void rmi_2d_sensor_set_input_params(struct rmi_2d_sensor *sensor) · 5 unmodified lines
163	sensor->axis_align.clip_y_high);	156	sensor->axis_align.clip_y_high);
164		157
165	set_bit(EV_ABS, input->evbit);	158	set_bit(EV_ABS, input->evbit);
166	input_set_abs_params(input, ABS_MT_POSITION_X, 0, sensor->max_x,	159
167	0, 0);	160	max_x = sensor->max_x;
168	input_set_abs_params(input, ABS_MT_POSITION_Y, 0, sensor->max_y,	161	max_y = sensor->max_y;
169	0, 0);	162	if (sensor->axis_align.swap_axes)
		163	swap(max_x, max_y);
		164	input_set_abs_params(input, ABS_MT_POSITION_X, 0, max_x, 0, 0);
		165	input_set_abs_params(input, ABS_MT_POSITION_Y, 0, max_y, 0, 0);
170		166
171	if (sensor->x_mm && sensor->y_mm) {	167	if (sensor->x_mm && sensor->y_mm) {
172	res_x = (sensor->max_x - sensor->min_x) / sensor->x_mm;	168	res_x = (sensor->max_x - sensor->min_x) / sensor->x_mm;
173	res_y = (sensor->max_y - sensor->min_y) / sensor->y_mm;	169	res_y = (sensor->max_y - sensor->min_y) / sensor->y_mm;
		170	if (sensor->axis_align.swap_axes)
		171	swap(res_x, res_y);
174		172
175	input_abs_set_res(input, ABS_X, res_x);	173	input_abs_set_res(input, ABS_X, res_x);
176	input_abs_set_res(input, ABS_Y, res_y);	174	input_abs_set_res(input, ABS_Y, res_y);

drivers/input/rmi4/rmi_bus.c+49−1

@@ -9,6 +9,8 @@ · 8 unmodified lines
9		9
10	#include <linux/kernel.h>	10	#include <linux/kernel.h>
11	#include <linux/device.h>	11	#include <linux/device.h>
		12	#include <linux/irq.h>
		13	#include <linux/irqdomain.h>
12	#include <linux/list.h>	14	#include <linux/list.h>
13	#include <linux/pm.h>	15	#include <linux/pm.h>
14	#include <linux/rmi.h>	16	#include <linux/rmi.h>
@@ -167,6 +169,39 @@ static inline void rmi_function_of_probe(struct rmi_function *fn) · 152 unmodified lines
167	{}	169	{}
168	#endif	170	#endif
169		171
		172	static struct irq_chip rmi_irq_chip = {
		173	.name = "rmi4",
		174	};
		175
		176	static int rmi_create_function_irq(struct rmi_function *fn,
		177	struct rmi_function_handler *handler)
		178	{
		179	struct rmi_driver_data *drvdata = dev_get_drvdata(&fn->rmi_dev->dev);
		180	int i, error;
		181
		182	for (i = 0; i < fn->num_of_irqs; i++) {
		183	set_bit(fn->irq_pos + i, fn->irq_mask);
		184
		185	fn->irq[i] = irq_create_mapping(drvdata->irqdomain,
		186	fn->irq_pos + i);
		187
		188	irq_set_chip_data(fn->irq[i], fn);
		189	irq_set_chip_and_handler(fn->irq[i], &rmi_irq_chip,
		190	handle_simple_irq);
		191	irq_set_nested_thread(fn->irq[i], 1);
		192
		193	error = devm_request_threaded_irq(&fn->dev, fn->irq[i], NULL,
		194	handler->attention, IRQF_ONESHOT,
		195	dev_name(&fn->dev), fn);
		196	if (error) {
		197	dev_err(&fn->dev, "Error %d registering IRQ\n", error);
		198	return error;
		199	}
		200	}
		201
		202	return 0;
		203	}
		204
170	static int rmi_function_probe(struct device *dev)	205	static int rmi_function_probe(struct device *dev)
171	{	206	{
172	struct rmi_function *fn = to_rmi_function(dev);	207	struct rmi_function *fn = to_rmi_function(dev);
@@ -178,7 +213,14 @@ static int rmi_function_probe(struct device *dev) · 5 unmodified lines
178		213
179	if (handler->probe) {	214	if (handler->probe) {
180	error = handler->probe(fn);	215	error = handler->probe(fn);
181	return error;	216	if (error)
		217	return error;
		218	}
		219
		220	if (fn->num_of_irqs && handler->attention) {
		221	error = rmi_create_function_irq(fn, handler);
		222	if (error)
		223	return error;
182	}	224	}
183		225
184	return 0;	226	return 0;
@@ -230,12 +272,18 @@ err_put_device: · 45 unmodified lines
230		272
231	void rmi_unregister_function(struct rmi_function *fn)	273	void rmi_unregister_function(struct rmi_function *fn)
232	{	274	{
		275	int i;
		276
233	rmi_dbg(RMI_DEBUG_CORE, &fn->dev, "Unregistering F%02X.\n",	277	rmi_dbg(RMI_DEBUG_CORE, &fn->dev, "Unregistering F%02X.\n",
234	fn->fd.function_number);	278	fn->fd.function_number);
235		279
236	device_del(&fn->dev);	280	device_del(&fn->dev);
237	of_node_put(fn->dev.of_node);	281	of_node_put(fn->dev.of_node);
238	put_device(&fn->dev);	282	put_device(&fn->dev);
		283
		284	for (i = 0; i < fn->num_of_irqs; i++)
		285	irq_dispose_mapping(fn->irq[i]);
		286
239	}	287	}
240		288
241	/**	289	/**

drivers/input/rmi4/rmi_bus.h+9−1

 struct rmi_device;
+/*
+ * The interrupt source count in the function descriptor can represent up to
+ * 6 interrupt sources in the normal manner.
+ */
+#define RMI_FN_MAX_IRQS	6
 /**
  * struct rmi_function - represents the implementation of an RMI4
  * function for a particular device (basically, a driver for that RMI4 function)
  * @irq_pos: The position in the irq bitfield this function holds
  * @irq_mask: For convenience, can be used to mask IRQ bits off during ATTN
  * interrupt handling.
+ * @irqs: assigned virq numbers (up to num_of_irqs)
  *
  * @node: entry in device's list of functions
  */
 	struct list_head node;
 	unsigned int num_of_irqs;
+	int irq[RMI_FN_MAX_IRQS];
 	unsigned int irq_pos;
 	unsigned long irq_mask[];
 };
 	void (*remove)(struct rmi_function *fn);
 	int (*config)(struct rmi_function *fn);
 	int (*reset)(struct rmi_function *fn);
-	int (*attention)(struct rmi_function *fn, unsigned long *irq_bits);
+	irqreturn_t (*attention)(int irq, void *ctx);
 	int (*suspend)(struct rmi_function *fn);
 	int (*resume)(struct rmi_function *fn);
 };

drivers/input/rmi4/rmi_driver.c+20−32

 #include <linux/pm.h>
 #include <linux/slab.h>
 #include <linux/of.h>
+#include <linux/irqdomain.h>
 #include <uapi/linux/input.h>
 #include <linux/rmi.h>
 #include "rmi_bus.h"
 	return 0;
 }
-static void process_one_interrupt(struct rmi_driver_data *data,
-				  struct rmi_function *fn)
-{
-	struct rmi_function_handler *fh;
-	if (!fn || !fn->dev.driver)
-		return;
-	fh = to_rmi_function_handler(fn->dev.driver);
-	if (fh->attention) {
-		bitmap_and(data->fn_irq_bits, data->irq_status, fn->irq_mask,
-				data->irq_count);
-		if (!bitmap_empty(data->fn_irq_bits, data->irq_count))
-			fh->attention(fn, data->fn_irq_bits);
-	}
-}
 static int rmi_process_interrupt_requests(struct rmi_device *rmi_dev)
 {
 	struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
 	struct device *dev = &rmi_dev->dev;
-	struct rmi_function *entry;
+	int i;
 	int error;
 	if (!data)
 	 */
 	mutex_unlock(&data->irq_mutex);
-	/*
+	for_each_set_bit(i, data->irq_status, data->irq_count)
-	 * It would be nice to be able to use irq_chip to handle these
+		handle_nested_irq(irq_find_mapping(data->irqdomain, i));
-	 * nested IRQs.  Unfortunately, most of the current customers for
-	 * this driver are using older kernels (3.0.x) that don't support
-	 * the features required for that.  Once they've shifted to more
-	 * recent kernels (say, 3.3 and higher), this should be switched to
-	 * use irq_chip.
-	 */
-	list_for_each_entry(entry, &data->function_list, node)
-		process_one_interrupt(data, entry);
 	if (data->input)
 		input_sync(data->input);
 static int rmi_driver_remove(struct device *dev)
 {
 	struct rmi_device *rmi_dev = to_rmi_device(dev);
+	struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
 	rmi_disable_irq(rmi_dev, false);
+	irq_domain_remove(data->irqdomain);
+	data->irqdomain = NULL;
 	rmi_f34_remove_sysfs(rmi_dev);
 	rmi_free_function_list(rmi_dev);
 {
 	struct rmi_device *rmi_dev = data->rmi_dev;
 	struct device *dev = &rmi_dev->dev;
-	int irq_count;
+	struct fwnode_handle *fwnode = rmi_dev->xport->dev->fwnode;
+	int irq_count = 0;
 	size_t size;
 	int retval;
 	 * being accessed.
 	 */
 	rmi_dbg(RMI_DEBUG_CORE, dev, "%s: Counting IRQs.\n", __func__);
-	irq_count = 0;
 	data->bootloader_mode = false;
 	retval = rmi_scan_pdt(rmi_dev, &irq_count, rmi_count_irqs);
 	if (data->bootloader_mode)
 		dev_warn(dev, "Device in bootloader mode.\n");
+	/* Allocate and register a linear revmap irq_domain */
+	data->irqdomain = irq_domain_create_linear(fwnode, irq_count,
+						   &irq_domain_simple_ops,
+						   data);
+	if (!data->irqdomain) {
+		dev_err(&rmi_dev->dev, "Failed to create IRQ domain\n");
+		return -ENOMEM;
+	}
 	data->irq_count = irq_count;
 	data->num_of_irq_regs = (data->irq_count + 7) / 8;
 {
 	struct rmi_device *rmi_dev = data->rmi_dev;
 	struct device *dev = &rmi_dev->dev;
-	int irq_count;
+	int irq_count = 0;
 	int retval;
-	irq_count = 0;
 	rmi_dbg(RMI_DEBUG_CORE, dev, "%s: Creating functions.\n", __func__);
 	retval = rmi_scan_pdt(rmi_dev, &irq_count, rmi_create_function);
 	if (retval < 0) {

drivers/input/rmi4/rmi_f01.c+5−5

 	return 0;
 }
-static int rmi_f01_attention(struct rmi_function *fn,
+static irqreturn_t rmi_f01_attention(int irq, void *ctx)
-			     unsigned long *irq_bits)
 {
+	struct rmi_function *fn = ctx;
 	struct rmi_device *rmi_dev = fn->rmi_dev;
 	int error;
 	u8 device_status;
 	if (error) {
 		dev_err(&fn->dev,
 			"Failed to read device status: %d.\n", error);
-		return error;
+		return IRQ_RETVAL(error);
 	}
 	if (RMI_F01_STATUS_BOOTLOADER(device_status))
 		error = rmi_dev->driver->reset_handler(rmi_dev);
 		if (error) {
 			dev_err(&fn->dev, "Device reset failed: %d\n", error);
-			return error;
+			return IRQ_RETVAL(error);
 		}
 	}
-	return 0;
+	return IRQ_HANDLED;
 }
 struct rmi_function_handler rmi_f01_handler = {

drivers/input/rmi4/rmi_f03.c+5−4

 	return 0;
 }
-static int rmi_f03_attention(struct rmi_function *fn, unsigned long *irq_bits)
+static irqreturn_t rmi_f03_attention(int irq, void *ctx)
 {
+	struct rmi_function *fn = ctx;
 	struct rmi_device *rmi_dev = fn->rmi_dev;
 	struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
 	struct f03_data *f03 = dev_get_drvdata(&fn->dev);
 		/* First grab the data passed by the transport device */
 		if (drvdata->attn_data.size < ob_len) {
 			dev_warn(&fn->dev, "F03 interrupted, but data is missing!\n");
-			return 0;
+			return IRQ_HANDLED;
 		}
 		memcpy(obs, drvdata->attn_data.data, ob_len);
 				"%s: Failed to read F03 output buffers: %d\n",
 				__func__, error);
 			serio_interrupt(f03->serio, 0, SERIO_TIMEOUT);
-			return error;
+			return IRQ_RETVAL(error);
 		}
 	}
 		serio_interrupt(f03->serio, ob_data, serio_flags);
 	}
-	return 0;
+	return IRQ_HANDLED;
 }
 static void rmi_f03_remove(struct rmi_function *fn)

drivers/input/rmi4/rmi_f11.c+16−26

 }
 static void rmi_f11_finger_handler(struct f11_data *f11,
-				   struct rmi_2d_sensor *sensor,
+				   struct rmi_2d_sensor *sensor, int size)
-				   unsigned long *irq_bits, int num_irq_regs,
-				   int size)
 {
 	const u8 *f_state = f11->data.f_state;
 	u8 finger_state;
 	int rel_fingers;
 	int abs_size = sensor->nbr_fingers * RMI_F11_ABS_BYTES;
-	int abs_bits = bitmap_and(f11->result_bits, irq_bits, f11->abs_mask,
+	if (sensor->report_abs) {
-				  num_irq_regs * 8);
-	int rel_bits = bitmap_and(f11->result_bits, irq_bits, f11->rel_mask,
-				  num_irq_regs * 8);
-	if (abs_bits) {
 		if (abs_size > size)
 			abs_fingers = size / RMI_F11_ABS_BYTES;
 		else
 			rmi_f11_abs_pos_process(f11, sensor, &sensor->objs[i],
 							finger_state, i);
 		}
-	}
-	if (rel_bits) {
-		if ((abs_size + sensor->nbr_fingers * RMI_F11_REL_BYTES) > size)
-			rel_fingers = (size - abs_size) / RMI_F11_REL_BYTES;
-		else
-			rel_fingers = sensor->nbr_fingers;
-		for (i = 0; i < rel_fingers; i++)
-			rmi_f11_rel_pos_report(f11, i);
-	}
-	if (abs_bits) {
 		/*
 		 * the absolute part is made in 2 parts to allow the kernel
 		 * tracking to take place.
 		}
 		input_mt_sync_frame(sensor->input);
+	} else if (sensor->report_rel) {
+		if ((abs_size + sensor->nbr_fingers * RMI_F11_REL_BYTES) > size)
+			rel_fingers = (size - abs_size) / RMI_F11_REL_BYTES;
+		else
+			rel_fingers = sensor->nbr_fingers;
+		for (i = 0; i < rel_fingers; i++)
+			rmi_f11_rel_pos_report(f11, i);
 	}
 }
 static int f11_2d_construct_data(struct f11_data *f11)
 	return 0;
 }
-static int rmi_f11_attention(struct rmi_function *fn, unsigned long *irq_bits)
+static irqreturn_t rmi_f11_attention(int irq, void *ctx)
 {
+	struct rmi_function *fn = ctx;
 	struct rmi_device *rmi_dev = fn->rmi_dev;
 	struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
 	struct f11_data *f11 = dev_get_drvdata(&fn->dev);
 				data_base_addr, f11->sensor.data_pkt,
 				f11->sensor.pkt_size);
 		if (error < 0)
-			return error;
+			return IRQ_RETVAL(error);
 	}
-	rmi_f11_finger_handler(f11, &f11->sensor, irq_bits,
+	rmi_f11_finger_handler(f11, &f11->sensor, valid_bytes);
-				drvdata->num_of_irq_regs, valid_bytes);
-	return 0;
+	return IRQ_HANDLED;
 }
 static int rmi_f11_resume(struct rmi_function *fn)

drivers/input/rmi4/rmi_f12.c+4−4

 		rmi_2d_sensor_abs_report(sensor, &sensor->objs[i], i);
 }
-static int rmi_f12_attention(struct rmi_function *fn,
+static irqreturn_t rmi_f12_attention(int irq, void *ctx)
-			     unsigned long *irq_nr_regs)
 {
 	int retval;
+	struct rmi_function *fn = ctx;
 	struct rmi_device *rmi_dev = fn->rmi_dev;
 	struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
 	struct f12_data *f12 = dev_get_drvdata(&fn->dev);
 		if (retval < 0) {
 			dev_err(&fn->dev, "Failed to read object data. Code: %d.\n",
 				retval);
-			return retval;
+			return IRQ_RETVAL(retval);
 		}
 	}
 	input_mt_sync_frame(sensor->input);
-	return 0;
+	return IRQ_HANDLED;
 }
 static int rmi_f12_write_control_regs(struct rmi_function *fn)

drivers/input/rmi4/rmi_f30.c+5−4

 	}
 }
-static int rmi_f30_attention(struct rmi_function *fn, unsigned long *irq_bits)
+static irqreturn_t rmi_f30_attention(int irq, void *ctx)
 {
+	struct rmi_function *fn = ctx;
 	struct f30_data *f30 = dev_get_drvdata(&fn->dev);
 	struct rmi_driver_data *drvdata = dev_get_drvdata(&fn->rmi_dev->dev);
 	int error;
 		if (drvdata->attn_data.size < f30->register_count) {
 			dev_warn(&fn->dev,
 				 "F30 interrupted, but data is missing\n");
-			return 0;
+			return IRQ_HANDLED;
 		}
 		memcpy(f30->data_regs, drvdata->attn_data.data,
 			f30->register_count);
 			dev_err(&fn->dev,
 				"%s: Failed to read F30 data registers: %d\n",
 				__func__, error);
-			return error;
+			return IRQ_RETVAL(error);
 		}
 	}
 			rmi_f03_commit_buttons(f30->f03);
 	}
-	return 0;
+	return IRQ_HANDLED;
 }
 static int rmi_f30_config(struct rmi_function *fn)

drivers/input/rmi4/rmi_f34.c+3−2

 	return 0;
 }
-static int rmi_f34_attention(struct rmi_function *fn, unsigned long *irq_bits)
+static irqreturn_t rmi_f34_attention(int irq, void *ctx)
 {
+	struct rmi_function *fn = ctx;
 	struct f34_data *f34 = dev_get_drvdata(&fn->dev);
 	int ret;
 	u8 status;
 			complete(&f34->v7.cmd_done);
 	}
-	return 0;
+	return IRQ_HANDLED;
 }
 static int rmi_f34_write_blocks(struct f34_data *f34, const void *data,

drivers/input/rmi4/rmi_f54.c+0−6

 	mutex_unlock(&f54->data_mutex);
 }
-static int rmi_f54_attention(struct rmi_function *fn, unsigned long *irqbits)
-{
-	return 0;
-}
 static int rmi_f54_config(struct rmi_function *fn)
 {
 	struct rmi_driver *drv = fn->rmi_dev->driver;
 	.func = 0x54,
 	.probe = rmi_f54_probe,
 	.config = rmi_f54_config,
-	.attention = rmi_f54_attention,
 	.remove = rmi_f54_remove,
 };

drivers/input/touchscreen/silead.c+1−0

@@ -603,6 +603,7 @@ static const struct acpi_device_id silead_ts_acpi_match[] = { · 602 unmodified lines
603	{ "GSL3692", 0 },	603	{ "GSL3692", 0 },
604	{ "MSSL1680", 0 },	604	{ "MSSL1680", 0 },
605	{ "MSSL0001", 0 },	605	{ "MSSL0001", 0 },
		606	{ "MSSL0002", 0 },
606	{ }	607	{ }
607	};	608	};
608	MODULE_DEVICE_TABLE(acpi, silead_ts_acpi_match);	609	MODULE_DEVICE_TABLE(acpi, silead_ts_acpi_match);

drivers/isdn/mISDN/socket.c+1−1

@@ -588,7 +588,7 @@ static const struct proto_ops data_sock_ops = { · 587 unmodified lines
588	.getname = data_sock_getname,	588	.getname = data_sock_getname,
589	.sendmsg = mISDN_sock_sendmsg,	589	.sendmsg = mISDN_sock_sendmsg,
590	.recvmsg = mISDN_sock_recvmsg,	590	.recvmsg = mISDN_sock_recvmsg,
591	.poll_mask = datagram_poll_mask,	591	.poll = datagram_poll,
592	.listen = sock_no_listen,	592	.listen = sock_no_listen,
593	.shutdown = sock_no_shutdown,	593	.shutdown = sock_no_shutdown,
594	.setsockopt = data_sock_setsockopt,	594	.setsockopt = data_sock_setsockopt,

drivers/md/dm-raid.c+1−1

@@ -588,7 +588,7 @@ static const char *raid10_md_layout_to_format(int layout) · 587 unmodified lines
588	}	588	}
589		589
590	/* Return md raid10 algorithm for @name */	590	/* Return md raid10 algorithm for @name */
591	static const int raid10_name_to_format(const char *name)	591	static int raid10_name_to_format(const char *name)
592	{	592	{
593	if (!strcasecmp(name, "near"))	593	if (!strcasecmp(name, "near"))
594	return ALGORITHM_RAID10_NEAR;	594	return ALGORITHM_RAID10_NEAR;

drivers/md/dm-table.c+4−3

 static int device_supports_dax(struct dm_target *ti, struct dm_dev *dev,
 			       sector_t start, sector_t len, void *data)
 {
-	struct request_queue *q = bdev_get_queue(dev->bdev);
+	return bdev_dax_supported(dev->bdev, PAGE_SIZE);
-	return q && blk_queue_dax(q);
 }
 static bool dm_table_supports_dax(struct dm_table *t)
 	if (dm_table_supports_dax(t))
 		blk_queue_flag_set(QUEUE_FLAG_DAX, q);
+	else
+		blk_queue_flag_clear(QUEUE_FLAG_DAX, q);
 	if (dm_table_supports_dax_write_cache(t))
 		dax_write_cache(t->md->dax_dev, true);

drivers/md/dm-thin-metadata.c+0−9

 static int __commit_transaction(struct dm_pool_metadata *pmd)
 {
 	int r;
-	size_t metadata_len, data_len;
 	struct thin_disk_superblock *disk_super;
 	struct dm_block *sblock;
 	if (r < 0)
 		return r;
-	r = dm_sm_root_size(pmd->metadata_sm, &metadata_len);
-	if (r < 0)
-		return r;
-	r = dm_sm_root_size(pmd->data_sm, &data_len);
-	if (r < 0)
-		return r;
 	r = save_sm_roots(pmd);
 	if (r < 0)
 		return r;

drivers/md/dm-thin.c+9−2

 static void set_pool_mode(struct pool *pool, enum pool_mode new_mode);
+static void requeue_bios(struct pool *pool);
 static void check_for_space(struct pool *pool)
 {
 	int r;
 	if (r)
 		return;
-	if (nr_free)
+	if (nr_free) {
 		set_pool_mode(pool, PM_WRITE);
+		requeue_bios(pool);
+	}
 }
 /*
 	r = dm_pool_alloc_data_block(pool->pmd, result);
 	if (r) {
-		metadata_operation_failed(pool, "dm_pool_alloc_data_block", r);
+		if (r == -ENOSPC)
+			set_pool_mode(pool, PM_OUT_OF_DATA_SPACE);
+		else
+			metadata_operation_failed(pool, "dm_pool_alloc_data_block", r);
 		return r;
 	}

drivers/md/dm-writecache.c+5−5

@@ -259,7 +259,7 @@ static int persistent_memory_claim(struct dm_writecache *wc) · 258 unmodified lines
259	if (da != p) {	259	if (da != p) {
260	long i;	260	long i;
261	wc->memory_map = NULL;	261	wc->memory_map = NULL;
262	pages = kvmalloc(p * sizeof(struct page *), GFP_KERNEL);	262	pages = kvmalloc_array(p, sizeof(struct page *), GFP_KERNEL);
263	if (!pages) {	263	if (!pages) {
264	r = -ENOMEM;	264	r = -ENOMEM;
265	goto err2;	265	goto err2;
@@ -859,7 +859,7 @@ static int writecache_alloc_entries(struct dm_writecache *wc) · 593 unmodified lines
859		859
860	if (wc->entries)	860	if (wc->entries)
861	return 0;	861	return 0;
862	wc->entries = vmalloc(sizeof(struct wc_entry) * wc->n_blocks);	862	wc->entries = vmalloc(array_size(sizeof(struct wc_entry), wc->n_blocks));
863	if (!wc->entries)	863	if (!wc->entries)
864	return -ENOMEM;	864	return -ENOMEM;
865	for (b = 0; b < wc->n_blocks; b++) {	865	for (b = 0; b < wc->n_blocks; b++) {
@@ -1481,9 +1481,9 @@ static void __writecache_writeback_pmem(struct dm_writecache *wc, struct writeba · 615 unmodified lines
1481	wb->bio.bi_iter.bi_sector = read_original_sector(wc, e);	1481	wb->bio.bi_iter.bi_sector = read_original_sector(wc, e);
1482	wb->page_offset = PAGE_SIZE;	1482	wb->page_offset = PAGE_SIZE;
1483	if (max_pages <= WB_LIST_INLINE \|\|	1483	if (max_pages <= WB_LIST_INLINE \|\|
1484	unlikely(!(wb->wc_list = kmalloc(max_pages * sizeof(struct wc_entry *),	1484	unlikely(!(wb->wc_list = kmalloc_array(max_pages, sizeof(struct wc_entry *),
1485	GFP_NOIO \| __GFP_NORETRY \|	1485	GFP_NOIO \| __GFP_NORETRY \|
1486	__GFP_NOMEMALLOC \| __GFP_NOWARN)))) {	1486	__GFP_NOMEMALLOC \| __GFP_NOWARN)))) {
1487	wb->wc_list = wb->wc_list_inline;	1487	wb->wc_list = wb->wc_list_inline;
1488	max_pages = WB_LIST_INLINE;	1488	max_pages = WB_LIST_INLINE;
1489	}	1489	}

drivers/md/dm-zoned-target.c+1−1

@@ -787,7 +787,7 @@ static int dmz_ctr(struct dm_target ti, unsigned int argc, char *argv) · 786 unmodified lines
787		787
788	/* Chunk BIO work */	788	/* Chunk BIO work */
789	mutex_init(&dmz->chunk_lock);	789	mutex_init(&dmz->chunk_lock);
790	INIT_RADIX_TREE(&dmz->chunk_rxtree, GFP_KERNEL);	790	INIT_RADIX_TREE(&dmz->chunk_rxtree, GFP_NOIO);
791	dmz->chunk_wq = alloc_workqueue("dmz_cwq_%s", WQ_MEM_RECLAIM \| WQ_UNBOUND,	791	dmz->chunk_wq = alloc_workqueue("dmz_cwq_%s", WQ_MEM_RECLAIM \| WQ_UNBOUND,
792	0, dev->name);	792	0, dev->name);
793	if (!dmz->chunk_wq) {	793	if (!dmz->chunk_wq) {

drivers/md/dm.c+3−5

 	if (len < 1)
 		goto out;
 	nr_pages = min(len, nr_pages);
-	if (ti->type->direct_access)
+	ret = ti->type->direct_access(ti, pgoff, nr_pages, kaddr, pfn);
-		ret = ti->type->direct_access(ti, pgoff, nr_pages, kaddr, pfn);
  out:
 	dm_put_live_table(md, srcu_idx);
 				 * the usage of io->orig_bio in dm_remap_zone_report()
 				 * won't be affected by this reassignment.
 				 */
-				struct bio *b = bio_clone_bioset(bio, GFP_NOIO,
+				struct bio *b = bio_split(bio, bio_sectors(bio) - ci.sector_count,
-								 &md->queue->bio_split);
+							  GFP_NOIO, &md->queue->bio_split);
 				ci.io->orig_bio = b;
-				bio_advance(bio, (bio_sectors(bio) - ci.sector_count) << 9);
 				bio_chain(b, bio);
 				ret = generic_make_request(bio);
 				break;

drivers/md/md.c+5−3

 		else
 			pr_warn("md: personality for level %s is not loaded!\n",
 				mddev->clevel);
-		return -EINVAL;
+		err = -EINVAL;
+		goto abort;
 	}
 	spin_unlock(&pers_lock);
 	if (mddev->level != pers->level) {
 	    pers->start_reshape == NULL) {
 		/* This personality cannot handle reshaping... */
 		module_put(pers->owner);
-		return -EINVAL;
+		err = -EINVAL;
+		goto abort;
 	}
 	if (pers->sync_request) {
 		mddev->private = NULL;
 		module_put(pers->owner);
 		bitmap_destroy(mddev);
-		return err;
+		goto abort;
 	}
 	if (mddev->queue) {
 		bool nonrot = true;

drivers/md/raid10.c+7−0

@@ -3893,6 +3893,13 @@ static int raid10_run(struct mddev *mddev) · 3892 unmodified lines
3893	disk->rdev->saved_raid_disk < 0)	3893	disk->rdev->saved_raid_disk < 0)
3894	conf->fullsync = 1;	3894	conf->fullsync = 1;
3895	}	3895	}
		3896
		3897	if (disk->replacement &&
		3898	!test_bit(In_sync, &disk->replacement->flags) &&
		3899	disk->replacement->saved_raid_disk < 0) {
		3900	conf->fullsync = 1;
		3901	}
		3902
3896	disk->recovery_disabled = mddev->recovery_disabled - 1;	3903	disk->recovery_disabled = mddev->recovery_disabled - 1;
3897	}	3904	}
3898		3905

drivers/media/rc/bpf-lirc.c+2−12

 	bpf_prog_array_free(rcdev->raw->progs);
 }
-int lirc_prog_attach(const union bpf_attr *attr)
+int lirc_prog_attach(const union bpf_attr *attr, struct bpf_prog *prog)
 {
-	struct bpf_prog *prog;
 	struct rc_dev *rcdev;
 	int ret;
 	if (attr->attach_flags)
 		return -EINVAL;
-	prog = bpf_prog_get_type(attr->attach_bpf_fd,
-				 BPF_PROG_TYPE_LIRC_MODE2);
-	if (IS_ERR(prog))
-		return PTR_ERR(prog);
 	rcdev = rc_dev_get_from_fd(attr->target_fd);
-	if (IS_ERR(rcdev)) {
+	if (IS_ERR(rcdev))
-		bpf_prog_put(prog);
 		return PTR_ERR(rcdev);
-	}
 	ret = lirc_bpf_attach(rcdev, prog);
-	if (ret)
-		bpf_prog_put(prog);
 	put_device(&rcdev->dev);

drivers/mtd/chips/cfi_cmdset_0002.c+11−8

 struct ppb_lock {
 	struct flchip *chip;
-	loff_t offset;
+	unsigned long adr;
 	int locked;
 };
 	unsigned long timeo;
 	int ret;
+	adr += chip->start;
 	mutex_lock(&chip->mutex);
-	ret = get_chip(map, chip, adr + chip->start, FL_LOCKING);
+	ret = get_chip(map, chip, adr, FL_LOCKING);
 	if (ret) {
 		mutex_unlock(&chip->mutex);
 		return ret;
 	if (thunk == DO_XXLOCK_ONEBLOCK_LOCK) {
 		chip->state = FL_LOCKING;
-		map_write(map, CMD(0xA0), chip->start + adr);
+		map_write(map, CMD(0xA0), adr);
-		map_write(map, CMD(0x00), chip->start + adr);
+		map_write(map, CMD(0x00), adr);
 	} else if (thunk == DO_XXLOCK_ONEBLOCK_UNLOCK) {
 		/*
 		 * Unlocking of one specific sector is not supported, so we
 	map_write(map, CMD(0x00), chip->start);
 	chip->state = FL_READY;
-	put_chip(map, chip, adr + chip->start);
+	put_chip(map, chip, adr);
 	mutex_unlock(&chip->mutex);
 	return ret;
 		 * sectors shall be unlocked, so lets keep their locking
 		 * status at "unlocked" (locked=0) for the final re-locking.
 		 */
-		if ((adr < ofs) || (adr >= (ofs + len))) {
+		if ((offset < ofs) || (offset >= (ofs + len))) {
 			sect[sectors].chip = &cfi->chips[chipnum];
-			sect[sectors].offset = offset;
+			sect[sectors].adr = adr;
 			sect[sectors].locked = do_ppb_xxlock(
 				map, &cfi->chips[chipnum], adr, 0,
 				DO_XXLOCK_ONEBLOCK_GETLOCK);
 			i++;
 		if (adr >> cfi->chipshift) {
+			if (offset >= (ofs + len))
+				break;
 			adr = 0;
 			chipnum++;
 	 */
 	for (i = 0; i < sectors; i++) {
 		if (sect[i].locked)
-			do_ppb_xxlock(map, sect[i].chip, sect[i].offset, 0,
+			do_ppb_xxlock(map, sect[i].chip, sect[i].adr, 0,
 				      DO_XXLOCK_ONEBLOCK_LOCK);
 	}

drivers/mtd/devices/mtd_dataflash.c+2−2

@@ -733,8 +733,8 @@ static struct flash_info dataflash_data[] = { · 732 unmodified lines
733	{ "AT45DB642x", 0x1f2800, 8192, 1056, 11, SUP_POW2PS},	733	{ "AT45DB642x", 0x1f2800, 8192, 1056, 11, SUP_POW2PS},
734	{ "at45db642d", 0x1f2800, 8192, 1024, 10, SUP_POW2PS \| IS_POW2PS},	734	{ "at45db642d", 0x1f2800, 8192, 1024, 10, SUP_POW2PS \| IS_POW2PS},
735		735
736	{ "AT45DB641E", 0x1f28000100, 32768, 264, 9, SUP_EXTID \| SUP_POW2PS},	736	{ "AT45DB641E", 0x1f28000100ULL, 32768, 264, 9, SUP_EXTID \| SUP_POW2PS},
737	{ "at45db641e", 0x1f28000100, 32768, 256, 8, SUP_EXTID \| SUP_POW2PS \| IS_POW2PS},	737	{ "at45db641e", 0x1f28000100ULL, 32768, 256, 8, SUP_EXTID \| SUP_POW2PS \| IS_POW2PS},
738	};	738	};
739		739
740	static struct flash_info jedec_lookup(struct spi_device spi,	740	static struct flash_info jedec_lookup(struct spi_device spi,

drivers/mtd/nand/raw/denali_dt.c+5−1

 	if (ret)
 		return ret;
-	denali->clk_x_rate = clk_get_rate(dt->clk);
+	/*
+	 * Hardcode the clock rate for the backward compatibility.
+	 * This works for both SOCFPGA and UniPhier.
+	 */
+	denali->clk_x_rate = 200000000;
 	ret = denali_init(denali);
 	if (ret)

drivers/mtd/nand/raw/mxc_nand.c+4−1

 #define NFC_V1_V2_CONFIG		(host->regs + 0x0a)
 #define NFC_V1_V2_ECC_STATUS_RESULT	(host->regs + 0x0c)
 #define NFC_V1_V2_RSLTMAIN_AREA		(host->regs + 0x0e)
-#define NFC_V1_V2_RSLTSPARE_AREA	(host->regs + 0x10)
+#define NFC_V21_RSLTSPARE_AREA		(host->regs + 0x10)
 #define NFC_V1_V2_WRPROT		(host->regs + 0x12)
 #define NFC_V1_UNLOCKSTART_BLKADDR	(host->regs + 0x14)
 #define NFC_V1_UNLOCKEND_BLKADDR	(host->regs + 0x16)
 	writew(config1, NFC_V1_V2_CONFIG1);
 	/* preset operation */
+	/* spare area size in 16-bit half-words */
+	writew(mtd->oobsize / 2, NFC_V21_RSLTSPARE_AREA);
 	/* Unlock the internal RAM Buffer */
 	writew(0x2, NFC_V1_V2_CONFIG);

drivers/mtd/nand/raw/nand_base.c+1−1

@@ -440,7 +440,7 @@ static int nand_block_bad(struct mtd_info *mtd, loff_t ofs) · 439 unmodified lines
440		440
441	for (; page < page_end; page++) {	441	for (; page < page_end; page++) {
442	res = chip->ecc.read_oob(mtd, chip, page);	442	res = chip->ecc.read_oob(mtd, chip, page);
443	if (res)	443	if (res < 0)
444	return res;	444	return res;
445		445
446	bad = chip->oob_poi[chip->badblockpos];	446	bad = chip->oob_poi[chip->badblockpos];

drivers/mtd/nand/raw/nand_macronix.c+36−12

@@ -17,23 +17,47 @@ · 16 unmodified lines
17		17
18	#include <linux/mtd/rawnand.h>	18	#include <linux/mtd/rawnand.h>
19		19
		20	/*
		21	* Macronix AC series does not support using SET/GET_FEATURES to change
		22	* the timings unlike what is declared in the parameter page. Unflag
		23	* this feature to avoid unnecessary downturns.
		24	*/
		25	static void macronix_nand_fix_broken_get_timings(struct nand_chip *chip)
		26	{
		27	unsigned int i;
		28	static const char * const broken_get_timings[] = {
		29	"MX30LF1G18AC",
		30	"MX30LF1G28AC",
		31	"MX30LF2G18AC",
		32	"MX30LF2G28AC",
		33	"MX30LF4G18AC",
		34	"MX30LF4G28AC",
		35	"MX60LF8G18AC",
		36	};
		37
		38	if (!chip->parameters.supports_set_get_features)
		39	return;
		40
		41	for (i = 0; i < ARRAY_SIZE(broken_get_timings); i++) {
		42	if (!strcmp(broken_get_timings[i], chip->parameters.model))
		43	break;
		44	}
		45
		46	if (i == ARRAY_SIZE(broken_get_timings))
		47	return;
		48
		49	bitmap_clear(chip->parameters.get_feature_list,
		50	ONFI_FEATURE_ADDR_TIMING_MODE, 1);
		51	bitmap_clear(chip->parameters.set_feature_list,
		52	ONFI_FEATURE_ADDR_TIMING_MODE, 1);
		53	}
		54
20	static int macronix_nand_init(struct nand_chip *chip)	55	static int macronix_nand_init(struct nand_chip *chip)
21	{	56	{
22	if (nand_is_slc(chip))	57	if (nand_is_slc(chip))
23	chip->bbt_options \|= NAND_BBT_SCAN2NDPAGE;	58	chip->bbt_options \|= NAND_BBT_SCAN2NDPAGE;
24		59
25	/*	60	macronix_nand_fix_broken_get_timings(chip);
26	* MX30LF2G18AC chip does not support using SET/GET_FEATURES to change
27	* the timings unlike what is declared in the parameter page. Unflag
28	* this feature to avoid unnecessary downturns.
29	*/
30	if (chip->parameters.supports_set_get_features &&
31	!strcmp("MX30LF2G18AC", chip->parameters.model)) {
32	bitmap_clear(chip->parameters.get_feature_list,
33	ONFI_FEATURE_ADDR_TIMING_MODE, 1);
34	bitmap_clear(chip->parameters.set_feature_list,
35	ONFI_FEATURE_ADDR_TIMING_MODE, 1);
36	}
37		61
38	return 0;	62	return 0;
39	}	63	}

drivers/mtd/nand/raw/nand_micron.c+2−0

@@ -66,7 +66,9 @@ static int micron_nand_onfi_init(struct nand_chip *chip) · 65 unmodified lines
66		66
67	if (p->supports_set_get_features) {	67	if (p->supports_set_get_features) {
68	set_bit(ONFI_FEATURE_ADDR_READ_RETRY, p->set_feature_list);	68	set_bit(ONFI_FEATURE_ADDR_READ_RETRY, p->set_feature_list);
		69	set_bit(ONFI_FEATURE_ON_DIE_ECC, p->set_feature_list);
69	set_bit(ONFI_FEATURE_ADDR_READ_RETRY, p->get_feature_list);	70	set_bit(ONFI_FEATURE_ADDR_READ_RETRY, p->get_feature_list);
		71	set_bit(ONFI_FEATURE_ON_DIE_ECC, p->get_feature_list);
70	}	72	}
71		73
72	return 0;	74	return 0;

drivers/net/ethernet/atheros/alx/main.c+7−1

@@ -1897,13 +1897,19 @@ static int alx_resume(struct device *dev) · 1896 unmodified lines
1897	struct pci_dev *pdev = to_pci_dev(dev);	1897	struct pci_dev *pdev = to_pci_dev(dev);
1898	struct alx_priv *alx = pci_get_drvdata(pdev);	1898	struct alx_priv *alx = pci_get_drvdata(pdev);
1899	struct alx_hw *hw = &alx->hw;	1899	struct alx_hw *hw = &alx->hw;
		1900	int err;
1900		1901
1901	alx_reset_phy(hw);	1902	alx_reset_phy(hw);
1902		1903
1903	if (!netif_running(alx->dev))	1904	if (!netif_running(alx->dev))
1904	return 0;	1905	return 0;
1905	netif_device_attach(alx->dev);	1906	netif_device_attach(alx->dev);
1906	return __alx_open(alx, true);	1907
		1908	rtnl_lock();
		1909	err = __alx_open(alx, true);
		1910	rtnl_unlock();
		1911
		1912	return err;
1907	}	1913	}
1908		1914
1909	static SIMPLE_DEV_PM_OPS(alx_pm_ops, alx_suspend, alx_resume);	1915	static SIMPLE_DEV_PM_OPS(alx_pm_ops, alx_suspend, alx_resume);

drivers/net/ethernet/broadcom/bnx2x/bnx2x.h+1−0

@@ -1533,6 +1533,7 @@ struct bnx2x { · 1532 unmodified lines
1533	struct link_vars link_vars;	1533	struct link_vars link_vars;
1534	u32 link_cnt;	1534	u32 link_cnt;
1535	struct bnx2x_link_report_data last_reported_link;	1535	struct bnx2x_link_report_data last_reported_link;
		1536	bool force_link_down;
1536		1537
1537	struct mdio_if_info mdio;	1538	struct mdio_if_info mdio;
1538		1539

drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c+6−0

 {
 	struct bnx2x_link_report_data cur_data;
+	if (bp->force_link_down) {
+		bp->link_vars.link_up = 0;
+		return;
+	}
 	/* reread mf_cfg */
 	if (IS_PF(bp) && !CHIP_IS_E1(bp))
 		bnx2x_read_mf_cfg(bp);
 		bp->pending_max = 0;
 	}
+	bp->force_link_down = false;
 	if (bp->port.pmf) {
 		rc = bnx2x_initial_phy_init(bp, load_mode);
 		if (rc)

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c+6−0

 		bp->sp_rtnl_state = 0;
 		smp_mb();
+		/* Immediately indicate link as down */
+		bp->link_vars.link_up = 0;
+		bp->force_link_down = true;
+		netif_carrier_off(bp->dev);
+		BNX2X_ERR("Indicating link is down due to Tx-timeout\n");
 		bnx2x_nic_unload(bp, UNLOAD_NORMAL, true);
 		/* When ret value shows failure of allocation failure,
 		 * the nic is rebooted again. If open still fails, a error

drivers/net/ethernet/broadcom/cnic.c+1−1

@@ -660,7 +660,7 @@ static int cnic_init_id_tbl(struct cnic_id_tbl *id_tbl, u32 size, u32 start_id, · 659 unmodified lines
660	id_tbl->max = size;	660	id_tbl->max = size;
661	id_tbl->next = next;	661	id_tbl->next = next;
662	spin_lock_init(&id_tbl->lock);	662	spin_lock_init(&id_tbl->lock);
663	id_tbl->table = kcalloc(DIV_ROUND_UP(size, 32), 4, GFP_KERNEL);	663	id_tbl->table = kcalloc(BITS_TO_LONGS(size), sizeof(long), GFP_KERNEL);
664	if (!id_tbl->table)	664	if (!id_tbl->table)
665	return -ENOMEM;	665	return -ENOMEM;
666		666

drivers/net/ethernet/cadence/macb_main.c+2−0

@@ -3726,6 +3726,8 @@ static int at91ether_init(struct platform_device *pdev) · 3725 unmodified lines
3726	int err;	3726	int err;
3727	u32 reg;	3727	u32 reg;
3728		3728
		3729	bp->queues[0].bp = bp;
		3730
3729	dev->netdev_ops = &at91ether_netdev_ops;	3731	dev->netdev_ops = &at91ether_netdev_ops;
3730	dev->ethtool_ops = &macb_ethtool_ops;	3732	dev->ethtool_ops = &macb_ethtool_ops;
3731		3733

drivers/net/ethernet/freescale/dpaa/dpaa_eth.c+8−7

 /* Default alignment for start of data in an Rx FD */
 #define DPAA_FD_DATA_ALIGNMENT  16
+/* The DPAA requires 256 bytes reserved and mapped for the SGT */
+#define DPAA_SGT_SIZE 256
 /* Values for the L3R field of the FM Parse Results
  */
 /* L3 Type field: First IP Present IPv4 */
 	if (unlikely(qm_fd_get_format(fd) == qm_fd_sg)) {
 		nr_frags = skb_shinfo(skb)->nr_frags;
-		dma_unmap_single(dev, addr, qm_fd_get_offset(fd) +
+		dma_unmap_single(dev, addr,
-				 sizeof(struct qm_sg_entry) * (1 + nr_frags),
+				 qm_fd_get_offset(fd) + DPAA_SGT_SIZE,
 				 dma_dir);
 		/* The sgt buffer has been allocated with netdev_alloc_frag(),
 	void *sgt_buf;
 	/* get a page frag to store the SGTable */
-	sz = SKB_DATA_ALIGN(priv->tx_headroom +
+	sz = SKB_DATA_ALIGN(priv->tx_headroom + DPAA_SGT_SIZE);
-		sizeof(struct qm_sg_entry) * (1 + nr_frags));
 	sgt_buf = netdev_alloc_frag(sz);
 	if (unlikely(!sgt_buf)) {
 		netdev_err(net_dev, "netdev_alloc_frag() failed for size %d\n",
 	skbh = (struct sk_buff **)buffer_start;
 	*skbh = skb;
-	addr = dma_map_single(dev, buffer_start, priv->tx_headroom +
+	addr = dma_map_single(dev, buffer_start,
-			      sizeof(struct qm_sg_entry) * (1 + nr_frags),
+			      priv->tx_headroom + DPAA_SGT_SIZE, dma_dir);
-			      dma_dir);
 	if (unlikely(dma_mapping_error(dev, addr))) {
 		dev_err(dev, "DMA mapping failed");
 		err = -EINVAL;

drivers/net/ethernet/freescale/fman/fman_port.c+8−0

 #define HWP_HXS_PHE_REPORT 0x00000800
 #define HWP_HXS_PCAC_PSTAT 0x00000100
 #define HWP_HXS_PCAC_PSTOP 0x00000001
+#define HWP_HXS_TCP_OFFSET 0xA
+#define HWP_HXS_UDP_OFFSET 0xB
+#define HWP_HXS_SH_PAD_REM 0x80000000
 struct fman_port_hwp_regs {
 	struct {
 		u32 ssa; /* Soft Sequence Attachment */
 		iowrite32be(0xffffffff, &regs->pmda[i].lcv);
 	}
+	/* Short packet padding removal from checksum calculation */
+	iowrite32be(HWP_HXS_SH_PAD_REM, &regs->pmda[HWP_HXS_TCP_OFFSET].ssa);
+	iowrite32be(HWP_HXS_SH_PAD_REM, &regs->pmda[HWP_HXS_UDP_OFFSET].ssa);
 	start_port_hwp(port);
 }

drivers/net/ethernet/huawei/hinic/hinic_rx.c+1−0

@@ -439,6 +439,7 @@ static void rx_free_irq(struct hinic_rxq *rxq) · 438 unmodified lines
439	{	439	{
440	struct hinic_rq *rq = rxq->rq;	440	struct hinic_rq *rq = rxq->rq;
441		441
		442	irq_set_affinity_hint(rq->irq, NULL);
442	free_irq(rq->irq, rxq);	443	free_irq(rq->irq, rxq);
443	rx_del_napi(rxq);	444	rx_del_napi(rxq);
444	}	445	}

drivers/net/ethernet/intel/i40e/i40e_txrx.c+15−9

@@ -2199,9 +2199,10 @@ static bool i40e_is_non_eop(struct i40e_ring *rx_ring, · 2198 unmodified lines
2199	return true;	2199	return true;
2200	}	2200	}
2201		2201
2202	#define I40E_XDP_PASS 0	2202	#define I40E_XDP_PASS 0
2203	#define I40E_XDP_CONSUMED 1	2203	#define I40E_XDP_CONSUMED BIT(0)
2204	#define I40E_XDP_TX 2	2204	#define I40E_XDP_TX BIT(1)
		2205	#define I40E_XDP_REDIR BIT(2)
2205		2206
2206	static int i40e_xmit_xdp_ring(struct xdp_frame *xdpf,	2207	static int i40e_xmit_xdp_ring(struct xdp_frame *xdpf,
2207	struct i40e_ring *xdp_ring);	2208	struct i40e_ring *xdp_ring);
@@ -2248,7 +2249,7 @@ static struct sk_buff i40e_run_xdp(struct i40e_ring rx_ring, · 40 unmodified lines
2248	break;	2249	break;
2249	case XDP_REDIRECT:	2250	case XDP_REDIRECT:
2250	err = xdp_do_redirect(rx_ring->netdev, xdp, xdp_prog);	2251	err = xdp_do_redirect(rx_ring->netdev, xdp, xdp_prog);
2251	result = !err ? I40E_XDP_TX : I40E_XDP_CONSUMED;	2252	result = !err ? I40E_XDP_REDIR : I40E_XDP_CONSUMED;
2252	break;	2253	break;
2253	default:	2254	default:
2254	bpf_warn_invalid_xdp_action(act);	2255	bpf_warn_invalid_xdp_action(act);
@@ -2311,7 +2312,8 @@ static int i40e_clean_rx_irq(struct i40e_ring *rx_ring, int budget) · 56 unmodified lines
2311	unsigned int total_rx_bytes = 0, total_rx_packets = 0;	2312	unsigned int total_rx_bytes = 0, total_rx_packets = 0;
2312	struct sk_buff *skb = rx_ring->skb;	2313	struct sk_buff *skb = rx_ring->skb;
2313	u16 cleaned_count = I40E_DESC_UNUSED(rx_ring);	2314	u16 cleaned_count = I40E_DESC_UNUSED(rx_ring);
2314	bool failure = false, xdp_xmit = false;	2315	unsigned int xdp_xmit = 0;
		2316	bool failure = false;
2315	struct xdp_buff xdp;	2317	struct xdp_buff xdp;
2316		2318
2317	xdp.rxq = &rx_ring->xdp_rxq;	2319	xdp.rxq = &rx_ring->xdp_rxq;
@@ -2372,8 +2374,10 @@ static int i40e_clean_rx_irq(struct i40e_ring *rx_ring, int budget) · 54 unmodified lines
2372	}	2374	}
2373		2375
2374	if (IS_ERR(skb)) {	2376	if (IS_ERR(skb)) {
2375	if (PTR_ERR(skb) == -I40E_XDP_TX) {	2377	unsigned int xdp_res = -PTR_ERR(skb);
2376	xdp_xmit = true;	2378
		2379	if (xdp_res & (I40E_XDP_TX \| I40E_XDP_REDIR)) {
		2380	xdp_xmit \|= xdp_res;
2377	i40e_rx_buffer_flip(rx_ring, rx_buffer, size);	2381	i40e_rx_buffer_flip(rx_ring, rx_buffer, size);
2378	} else {	2382	} else {
2379	rx_buffer->pagecnt_bias++;	2383	rx_buffer->pagecnt_bias++;
@@ -2427,12 +2431,14 @@ static int i40e_clean_rx_irq(struct i40e_ring *rx_ring, int budget) · 47 unmodified lines
2427	total_rx_packets++;	2431	total_rx_packets++;
2428	}	2432	}
2429		2433
2430	if (xdp_xmit) {	2434	if (xdp_xmit & I40E_XDP_REDIR)
		2435	xdp_do_flush_map();
		2436
		2437	if (xdp_xmit & I40E_XDP_TX) {
2431	struct i40e_ring *xdp_ring =	2438	struct i40e_ring *xdp_ring =
2432	rx_ring->vsi->xdp_rings[rx_ring->queue_index];	2439	rx_ring->vsi->xdp_rings[rx_ring->queue_index];
2433		2440
2434	i40e_xdp_ring_update_tail(xdp_ring);	2441	i40e_xdp_ring_update_tail(xdp_ring);
2435	xdp_do_flush_map();
2436	}	2442	}
2437		2443
2438	rx_ring->skb = skb;	2444	rx_ring->skb = skb;

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c+14−10

@@ -2186,9 +2186,10 @@ static struct sk_buff ixgbe_build_skb(struct ixgbe_ring rx_ring, · 2185 unmodified lines
2186	return skb;	2186	return skb;
2187	}	2187	}
2188		2188
2189	#define IXGBE_XDP_PASS 0	2189	#define IXGBE_XDP_PASS 0
2190	#define IXGBE_XDP_CONSUMED 1	2190	#define IXGBE_XDP_CONSUMED BIT(0)
2191	#define IXGBE_XDP_TX 2	2191	#define IXGBE_XDP_TX BIT(1)
		2192	#define IXGBE_XDP_REDIR BIT(2)
2192		2193
2193	static int ixgbe_xmit_xdp_ring(struct ixgbe_adapter *adapter,	2194	static int ixgbe_xmit_xdp_ring(struct ixgbe_adapter *adapter,
2194	struct xdp_frame *xdpf);	2195	struct xdp_frame *xdpf);
@@ -2225,7 +2226,7 @@ static struct sk_buff ixgbe_run_xdp(struct ixgbe_adapter adapter, · 30 unmodified lines
2225	case XDP_REDIRECT:	2226	case XDP_REDIRECT:
2226	err = xdp_do_redirect(adapter->netdev, xdp, xdp_prog);	2227	err = xdp_do_redirect(adapter->netdev, xdp, xdp_prog);
2227	if (!err)	2228	if (!err)
2228	result = IXGBE_XDP_TX;	2229	result = IXGBE_XDP_REDIR;
2229	else	2230	else
2230	result = IXGBE_XDP_CONSUMED;	2231	result = IXGBE_XDP_CONSUMED;
2231	break;	2232	break;
@@ -2285,7 +2286,7 @@ static int ixgbe_clean_rx_irq(struct ixgbe_q_vector *q_vector, · 53 unmodified lines
2285	unsigned int mss = 0;	2286	unsigned int mss = 0;
2286	#endif /* IXGBE_FCOE */	2287	#endif /* IXGBE_FCOE */
2287	u16 cleaned_count = ixgbe_desc_unused(rx_ring);	2288	u16 cleaned_count = ixgbe_desc_unused(rx_ring);
2288	bool xdp_xmit = false;	2289	unsigned int xdp_xmit = 0;
2289	struct xdp_buff xdp;	2290	struct xdp_buff xdp;
2290		2291
2291	xdp.rxq = &rx_ring->xdp_rxq;	2292	xdp.rxq = &rx_ring->xdp_rxq;
@@ -2328,8 +2329,10 @@ static int ixgbe_clean_rx_irq(struct ixgbe_q_vector *q_vector, · 36 unmodified lines
2328	}	2329	}
2329		2330
2330	if (IS_ERR(skb)) {	2331	if (IS_ERR(skb)) {
2331	if (PTR_ERR(skb) == -IXGBE_XDP_TX) {	2332	unsigned int xdp_res = -PTR_ERR(skb);
2332	xdp_xmit = true;	2333
		2334	if (xdp_res & (IXGBE_XDP_TX \| IXGBE_XDP_REDIR)) {
		2335	xdp_xmit \|= xdp_res;
2333	ixgbe_rx_buffer_flip(rx_ring, rx_buffer, size);	2336	ixgbe_rx_buffer_flip(rx_ring, rx_buffer, size);
2334	} else {	2337	} else {
2335	rx_buffer->pagecnt_bias++;	2338	rx_buffer->pagecnt_bias++;
@@ -2401,7 +2404,10 @@ static int ixgbe_clean_rx_irq(struct ixgbe_q_vector *q_vector, · 65 unmodified lines
2401	total_rx_packets++;	2404	total_rx_packets++;
2402	}	2405	}
2403		2406
2404	if (xdp_xmit) {	2407	if (xdp_xmit & IXGBE_XDP_REDIR)
		2408	xdp_do_flush_map();
		2409
		2410	if (xdp_xmit & IXGBE_XDP_TX) {
2405	struct ixgbe_ring *ring = adapter->xdp_ring[smp_processor_id()];	2411	struct ixgbe_ring *ring = adapter->xdp_ring[smp_processor_id()];
2406		2412
2407	/* Force memory writes to complete before letting h/w	2413	/* Force memory writes to complete before letting h/w
@@ -2409,8 +2415,6 @@ static int ixgbe_clean_rx_irq(struct ixgbe_q_vector *q_vector, · 1 unmodified line
2409	*/	2415	*/
2410	wmb();	2416	wmb();
2411	writel(ring->next_to_use, ring->tail);	2417	writel(ring->next_to_use, ring->tail);
2412
2413	xdp_do_flush_map();
2414	}	2418	}
2415		2419
2416	u64_stats_update_begin(&rx_ring->syncp);	2420	u64_stats_update_begin(&rx_ring->syncp);

drivers/net/ethernet/mellanox/mlx5/core/cmd.c+4−4

 	unsigned long flags;
 	bool poll_cmd = ent->polling;
 	int alloc_ret;
+	int cmd_mode;
 	sem = ent->page_queue ? &cmd->pages_sem : &cmd->sem;
 	down(sem);
 	set_signature(ent, !cmd->checksum_disabled);
 	dump_command(dev, ent, 1);
 	ent->ts1 = ktime_get_ns();
+	cmd_mode = cmd->mode;
 	if (ent->callback)
 		schedule_delayed_work(&ent->cb_timeout_work, cb_timeout);
 	iowrite32be(1 << ent->idx, &dev->iseg->cmd_dbell);
 	mmiowb();
 	/* if not in polling don't use ent after this point */
-	if (cmd->mode == CMD_MODE_POLLING || poll_cmd) {
+	if (cmd_mode == CMD_MODE_POLLING || poll_cmd) {
 		poll_timeout(ent);
 		/* make sure we read the descriptor after ownership is SW */
 		rmb();
 {
 	struct mlx5_core_dev *dev = filp->private_data;
 	struct mlx5_cmd_debug *dbg = &dev->cmd.dbg;
-	char outlen_str[8];
+	char outlen_str[8] = {0};
 	int outlen;
 	void *ptr;
 	int err;
 	if (copy_from_user(outlen_str, buf, count))
 		return -EFAULT;
-	outlen_str[7] = 0;
 	err = sscanf(outlen_str, "%d", &outlen);
 	if (err < 0)
 		return err;

drivers/net/ethernet/mellanox/mlx5/core/en_main.c+6−6

@@ -2843,7 +2843,7 @@ void mlx5e_activate_priv_channels(struct mlx5e_priv *priv) · 2842 unmodified lines
2843	mlx5e_activate_channels(&priv->channels);	2843	mlx5e_activate_channels(&priv->channels);
2844	netif_tx_start_all_queues(priv->netdev);	2844	netif_tx_start_all_queues(priv->netdev);
2845		2845
2846	if (MLX5_VPORT_MANAGER(priv->mdev))	2846	if (MLX5_ESWITCH_MANAGER(priv->mdev))
2847	mlx5e_add_sqs_fwd_rules(priv);	2847	mlx5e_add_sqs_fwd_rules(priv);
2848		2848
2849	mlx5e_wait_channels_min_rx_wqes(&priv->channels);	2849	mlx5e_wait_channels_min_rx_wqes(&priv->channels);
@@ -2854,7 +2854,7 @@ void mlx5e_deactivate_priv_channels(struct mlx5e_priv *priv) · 4 unmodified lines
2854	{	2854	{
2855	mlx5e_redirect_rqts_to_drop(priv);	2855	mlx5e_redirect_rqts_to_drop(priv);
2856		2856
2857	if (MLX5_VPORT_MANAGER(priv->mdev))	2857	if (MLX5_ESWITCH_MANAGER(priv->mdev))
2858	mlx5e_remove_sqs_fwd_rules(priv);	2858	mlx5e_remove_sqs_fwd_rules(priv);
2859		2859
2860	/* FIXME: This is a W/A only for tx timeout watch dog false alarm when	2860	/* FIXME: This is a W/A only for tx timeout watch dog false alarm when
@@ -4600,7 +4600,7 @@ static void mlx5e_build_nic_netdev(struct net_device *netdev) · 1739 unmodified lines
4600	mlx5e_set_netdev_dev_addr(netdev);	4600	mlx5e_set_netdev_dev_addr(netdev);
4601		4601
4602	#if IS_ENABLED(CONFIG_MLX5_ESWITCH)	4602	#if IS_ENABLED(CONFIG_MLX5_ESWITCH)
4603	if (MLX5_VPORT_MANAGER(mdev))	4603	if (MLX5_ESWITCH_MANAGER(mdev))
4604	netdev->switchdev_ops = &mlx5e_switchdev_ops;	4604	netdev->switchdev_ops = &mlx5e_switchdev_ops;
4605	#endif	4605	#endif
4606		4606
@@ -4756,7 +4756,7 @@ static void mlx5e_nic_enable(struct mlx5e_priv *priv) · 149 unmodified lines
4756		4756
4757	mlx5e_enable_async_events(priv);	4757	mlx5e_enable_async_events(priv);
4758		4758
4759	if (MLX5_VPORT_MANAGER(priv->mdev))	4759	if (MLX5_ESWITCH_MANAGER(priv->mdev))
4760	mlx5e_register_vport_reps(priv);	4760	mlx5e_register_vport_reps(priv);
4761		4761
4762	if (netdev->reg_state != NETREG_REGISTERED)	4762	if (netdev->reg_state != NETREG_REGISTERED)
@@ -4791,7 +4791,7 @@ static void mlx5e_nic_disable(struct mlx5e_priv *priv) · 28 unmodified lines
4791		4791
4792	queue_work(priv->wq, &priv->set_rx_mode_work);	4792	queue_work(priv->wq, &priv->set_rx_mode_work);
4793		4793
4794	if (MLX5_VPORT_MANAGER(priv->mdev))	4794	if (MLX5_ESWITCH_MANAGER(priv->mdev))
4795	mlx5e_unregister_vport_reps(priv);	4795	mlx5e_unregister_vport_reps(priv);
4796		4796
4797	mlx5e_disable_async_events(priv);	4797	mlx5e_disable_async_events(priv);
@@ -4975,7 +4975,7 @@ static void mlx5e_add(struct mlx5_core_dev mdev) · 177 unmodified lines
4975	return NULL;	4975	return NULL;
4976		4976
4977	#ifdef CONFIG_MLX5_ESWITCH	4977	#ifdef CONFIG_MLX5_ESWITCH
4978	if (MLX5_VPORT_MANAGER(mdev)) {	4978	if (MLX5_ESWITCH_MANAGER(mdev)) {
4979	rpriv = mlx5e_alloc_nic_rep_priv(mdev);	4979	rpriv = mlx5e_alloc_nic_rep_priv(mdev);
4980	if (!rpriv) {	4980	if (!rpriv) {
4981	mlx5_core_warn(mdev, "Failed to alloc NIC rep priv data\n");	4981	mlx5_core_warn(mdev, "Failed to alloc NIC rep priv data\n");

drivers/net/ethernet/mellanox/mlx5/core/en_rep.c+6−2

 	struct mlx5e_rep_priv *rpriv = priv->ppriv;
 	struct mlx5_eswitch_rep *rep;
-	if (!MLX5_CAP_GEN(priv->mdev, vport_group_manager))
+	if (!MLX5_ESWITCH_MANAGER(priv->mdev))
 		return false;
 	rep = rpriv->rep;
 static bool mlx5e_is_vf_vport_rep(struct mlx5e_priv *priv)
 {
 	struct mlx5e_rep_priv *rpriv = priv->ppriv;
-	struct mlx5_eswitch_rep *rep = rpriv->rep;
+	struct mlx5_eswitch_rep *rep;
+	if (!MLX5_ESWITCH_MANAGER(priv->mdev))
+		return false;
+	rep = rpriv->rep;
 	if (rep && rep->vport != FDB_UPLINK_VPORT)
 		return true;

drivers/net/ethernet/mellanox/mlx5/core/eswitch.c+5−7

 }
 /* Public E-Switch API */
-#define ESW_ALLOWED(esw) ((esw) && MLX5_VPORT_MANAGER((esw)->dev))
+#define ESW_ALLOWED(esw) ((esw) && MLX5_ESWITCH_MANAGER((esw)->dev))
 int mlx5_eswitch_enable_sriov(struct mlx5_eswitch *esw, int nvfs, int mode)
 {
 	int err;
 	int i, enabled_events;
-	if (!ESW_ALLOWED(esw))
+	if (!ESW_ALLOWED(esw) ||
-		return 0;
-	if (!MLX5_CAP_GEN(esw->dev, eswitch_flow_table) ||
 	    !MLX5_CAP_ESW_FLOWTABLE_FDB(esw->dev, ft_support)) {
 		esw_warn(esw->dev, "E-Switch FDB is not supported, aborting ...\n");
 		return -EOPNOTSUPP;
 	u64 node_guid;
 	int err = 0;
-	if (!ESW_ALLOWED(esw))
+	if (!MLX5_CAP_GEN(esw->dev, vport_group_manager))
 		return -EPERM;
 	if (!LEGAL_VPORT(esw, vport) || is_multicast_ether_addr(mac))
 		return -EINVAL;
 {
 	struct mlx5_vport *evport;
-	if (!ESW_ALLOWED(esw))
+	if (!MLX5_CAP_GEN(esw->dev, vport_group_manager))
 		return -EPERM;
 	if (!LEGAL_VPORT(esw, vport))
 		return -EINVAL;

drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c+2−2

@@ -1079,8 +1079,8 @@ static int mlx5_devlink_eswitch_check(struct devlink *devlink) · 1078 unmodified lines
1079	if (MLX5_CAP_GEN(dev, port_type) != MLX5_CAP_PORT_TYPE_ETH)	1079	if (MLX5_CAP_GEN(dev, port_type) != MLX5_CAP_PORT_TYPE_ETH)
1080	return -EOPNOTSUPP;	1080	return -EOPNOTSUPP;
1081		1081
1082	if (!MLX5_CAP_GEN(dev, vport_group_manager))	1082	if(!MLX5_ESWITCH_MANAGER(dev))
1083	return -EOPNOTSUPP;	1083	return -EPERM;
1084		1084
1085	if (dev->priv.eswitch->mode == SRIOV_NONE)	1085	if (dev->priv.eswitch->mode == SRIOV_NONE)
1086	return -EOPNOTSUPP;	1086	return -EOPNOTSUPP;

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c+2−1

 #include <linux/mutex.h>
 #include <linux/mlx5/driver.h>
+#include <linux/mlx5/eswitch.h>
 #include "mlx5_core.h"
 #include "fs_core.h"
 			goto err;
 	}
-	if (MLX5_CAP_GEN(dev, eswitch_flow_table)) {
+	if (MLX5_ESWITCH_MANAGER(dev)) {
 		if (MLX5_CAP_ESW_FLOWTABLE_FDB(dev, ft_support)) {
 			err = init_fdb_root_ns(steering);
 			if (err)

drivers/net/ethernet/mellanox/mlx5/core/fw.c+3−2

 #include <linux/mlx5/driver.h>
 #include <linux/mlx5/cmd.h>
+#include <linux/mlx5/eswitch.h>
 #include <linux/module.h>
 #include "mlx5_core.h"
 #include "../../mlxfw/mlxfw.h"
 	}
 	if (MLX5_CAP_GEN(dev, vport_group_manager) &&
-	    MLX5_CAP_GEN(dev, eswitch_flow_table)) {
+	    MLX5_ESWITCH_MANAGER(dev)) {
 		err = mlx5_core_get_caps(dev, MLX5_CAP_ESWITCH_FLOW_TABLE);
 		if (err)
 			return err;
 	}
-	if (MLX5_CAP_GEN(dev, eswitch_flow_table)) {
+	if (MLX5_ESWITCH_MANAGER(dev)) {
 		err = mlx5_core_get_caps(dev, MLX5_CAP_ESWITCH);
 		if (err)
 			return err;

drivers/net/ethernet/mellanox/mlx5/core/lib/mpfs.c+5−4

 #include <linux/etherdevice.h>
 #include <linux/mlx5/driver.h>
 #include <linux/mlx5/mlx5_ifc.h>
+#include <linux/mlx5/eswitch.h>
 #include "mlx5_core.h"
 #include "lib/mpfs.h"
 	int l2table_size = 1 << MLX5_CAP_GEN(dev, log_max_l2_table);
 	struct mlx5_mpfs *mpfs;
-	if (!MLX5_VPORT_MANAGER(dev))
+	if (!MLX5_ESWITCH_MANAGER(dev))
 		return 0;
 	mpfs = kzalloc(sizeof(*mpfs), GFP_KERNEL);
 {
 	struct mlx5_mpfs *mpfs = dev->priv.mpfs;
-	if (!MLX5_VPORT_MANAGER(dev))
+	if (!MLX5_ESWITCH_MANAGER(dev))
 		return;
 	WARN_ON(!hlist_empty(mpfs->hash));
 	u32 index;
 	int err;
-	if (!MLX5_VPORT_MANAGER(dev))
+	if (!MLX5_ESWITCH_MANAGER(dev))
 		return 0;
 	mutex_lock(&mpfs->lock);
 	int err = 0;
 	u32 index;
-	if (!MLX5_VPORT_MANAGER(dev))
+	if (!MLX5_ESWITCH_MANAGER(dev))
 		return 0;
 	mutex_lock(&mpfs->lock);

drivers/net/ethernet/mellanox/mlx5/core/port.c+2−2

@@ -701,7 +701,7 @@ EXPORT_SYMBOL_GPL(mlx5_query_port_prio_tc); · 700 unmodified lines
701	static int mlx5_set_port_qetcr_reg(struct mlx5_core_dev mdev, u32 in,	701	static int mlx5_set_port_qetcr_reg(struct mlx5_core_dev mdev, u32 in,
702	int inlen)	702	int inlen)
703	{	703	{
704	u32 out[MLX5_ST_SZ_DW(qtct_reg)];	704	u32 out[MLX5_ST_SZ_DW(qetc_reg)];
705		705
706	if (!MLX5_CAP_GEN(mdev, ets))	706	if (!MLX5_CAP_GEN(mdev, ets))
707	return -EOPNOTSUPP;	707	return -EOPNOTSUPP;
@@ -713,7 +713,7 @@ static int mlx5_set_port_qetcr_reg(struct mlx5_core_dev mdev, u32 in, · 5 unmodified lines
713	static int mlx5_query_port_qetcr_reg(struct mlx5_core_dev mdev, u32 out,	713	static int mlx5_query_port_qetcr_reg(struct mlx5_core_dev mdev, u32 out,
714	int outlen)	714	int outlen)
715	{	715	{
716	u32 in[MLX5_ST_SZ_DW(qtct_reg)];	716	u32 in[MLX5_ST_SZ_DW(qetc_reg)];
717		717
718	if (!MLX5_CAP_GEN(mdev, ets))	718	if (!MLX5_CAP_GEN(mdev, ets))
719	return -EOPNOTSUPP;	719	return -EOPNOTSUPP;

drivers/net/ethernet/mellanox/mlx5/core/sriov.c+6−1

 		return -EBUSY;
 	}
+	if (!MLX5_ESWITCH_MANAGER(dev))
+		goto enable_vfs_hca;
 	err = mlx5_eswitch_enable_sriov(dev->priv.eswitch, num_vfs, SRIOV_LEGACY);
 	if (err) {
 		mlx5_core_warn(dev,
 		return err;
 	}
+enable_vfs_hca:
 	for (vf = 0; vf < num_vfs; vf++) {
 		err = mlx5_core_enable_hca(dev, vf + 1);
 		if (err) {
 	}
 out:
-	mlx5_eswitch_disable_sriov(dev->priv.eswitch);
+	if (MLX5_ESWITCH_MANAGER(dev))
+		mlx5_eswitch_disable_sriov(dev->priv.eswitch);
 	if (mlx5_wait_for_vf_pages(dev))
 		mlx5_core_warn(dev, "timeout reclaiming VFs pages\n");

drivers/net/ethernet/mellanox/mlx5/core/vport.c+0−2

@@ -549,8 +549,6 @@ int mlx5_modify_nic_vport_node_guid(struct mlx5_core_dev *mdev, · 548 unmodified lines
549	return -EINVAL;	549	return -EINVAL;
550	if (!MLX5_CAP_GEN(mdev, vport_group_manager))	550	if (!MLX5_CAP_GEN(mdev, vport_group_manager))
551	return -EACCES;	551	return -EACCES;
552	if (!MLX5_CAP_ESW(mdev, nic_vport_node_guid_modify))
553	return -EOPNOTSUPP;
554		552
555	in = kvzalloc(inlen, GFP_KERNEL);	553	in = kvzalloc(inlen, GFP_KERNEL);
556	if (!in)	554	if (!in)

drivers/net/ethernet/netronome/nfp/bpf/main.c+6−3

 	ret = nfp_net_bpf_offload(nn, prog, running, extack);
 	/* Stop offload if replace not possible */
-	if (ret && prog)
+	if (ret)
-		nfp_bpf_xdp_offload(app, nn, NULL, extack);
+		return ret;
-	nn->dp.bpf_offload_xdp = prog && !ret;
+	nn->dp.bpf_offload_xdp = !!prog;
 	return ret;
 }
 	if (f->binder_type != TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS)
 		return -EOPNOTSUPP;
+	if (tcf_block_shared(f->block))
+		return -EOPNOTSUPP;
 	switch (f->command) {
 	case TC_BLOCK_BIND:
 		return tcf_block_cb_register(f->block,

drivers/net/ethernet/netronome/nfp/flower/match.c+14−0

@@ -123,6 +123,20 @@ nfp_flower_compile_mac(struct nfp_flower_mac_mpls *frame, · 122 unmodified lines
123	NFP_FLOWER_MASK_MPLS_Q;	123	NFP_FLOWER_MASK_MPLS_Q;
124		124
125	frame->mpls_lse = cpu_to_be32(t_mpls);	125	frame->mpls_lse = cpu_to_be32(t_mpls);
		126	} else if (dissector_uses_key(flow->dissector,
		127	FLOW_DISSECTOR_KEY_BASIC)) {
		128	/* Check for mpls ether type and set NFP_FLOWER_MASK_MPLS_Q
		129	* bit, which indicates an mpls ether type but without any
		130	* mpls fields.
		131	*/
		132	struct flow_dissector_key_basic *key_basic;
		133
		134	key_basic = skb_flow_dissector_target(flow->dissector,
		135	FLOW_DISSECTOR_KEY_BASIC,
		136	flow->key);
		137	if (key_basic->n_proto == cpu_to_be16(ETH_P_MPLS_UC) \|\|
		138	key_basic->n_proto == cpu_to_be16(ETH_P_MPLS_MC))
		139	frame->mpls_lse = cpu_to_be32(NFP_FLOWER_MASK_MPLS_Q);
126	}	140	}
127	}	141	}
128		142

drivers/net/ethernet/netronome/nfp/flower/offload.c+11−0

 		case cpu_to_be16(ETH_P_ARP):
 			return -EOPNOTSUPP;
+		case cpu_to_be16(ETH_P_MPLS_UC):
+		case cpu_to_be16(ETH_P_MPLS_MC):
+			if (!(key_layer & NFP_FLOWER_LAYER_MAC)) {
+				key_layer |= NFP_FLOWER_LAYER_MAC;
+				key_size += sizeof(struct nfp_flower_mac_mpls);
+			}
+			break;
 		/* Will be included in layer 2. */
 		case cpu_to_be16(ETH_P_8021Q):
 			break;
 	if (f->binder_type != TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS)
 		return -EOPNOTSUPP;
+	if (tcf_block_shared(f->block))
+		return -EOPNOTSUPP;
 	switch (f->command) {
 	case TC_BLOCK_BIND:
 		return tcf_block_cb_register(f->block,

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nffw.c+1−1

@@ -232,7 +232,7 @@ struct nfp_nffw_info nfp_nffw_info_open(struct nfp_cpp cpp) · 231 unmodified lines
232	err = nfp_cpp_read(cpp, nfp_resource_cpp_id(state->res),	232	err = nfp_cpp_read(cpp, nfp_resource_cpp_id(state->res),
233	nfp_resource_address(state->res),	233	nfp_resource_address(state->res),
234	fwinf, sizeof(*fwinf));	234	fwinf, sizeof(*fwinf));
235	if (err < sizeof(*fwinf))	235	if (err < (int)sizeof(*fwinf))
236	goto err_release;	236	goto err_release;
237		237
238	if (!nffw_res_flg_init_get(fwinf))	238	if (!nffw_res_flg_init_get(fwinf))

drivers/net/ethernet/qlogic/qed/qed_dcbx.c+4−4

@@ -709,9 +709,9 @@ qed_dcbx_get_local_lldp_params(struct qed_hwfn *p_hwfn, · 708 unmodified lines
709	p_local = &p_hwfn->p_dcbx_info->lldp_local[LLDP_NEAREST_BRIDGE];	709	p_local = &p_hwfn->p_dcbx_info->lldp_local[LLDP_NEAREST_BRIDGE];
710		710
711	memcpy(params->lldp_local.local_chassis_id, p_local->local_chassis_id,	711	memcpy(params->lldp_local.local_chassis_id, p_local->local_chassis_id,
712	ARRAY_SIZE(p_local->local_chassis_id));	712	sizeof(p_local->local_chassis_id));
713	memcpy(params->lldp_local.local_port_id, p_local->local_port_id,	713	memcpy(params->lldp_local.local_port_id, p_local->local_port_id,
714	ARRAY_SIZE(p_local->local_port_id));	714	sizeof(p_local->local_port_id));
715	}	715	}
716		716
717	static void	717	static void
@@ -723,9 +723,9 @@ qed_dcbx_get_remote_lldp_params(struct qed_hwfn *p_hwfn, · 5 unmodified lines
723	p_remote = &p_hwfn->p_dcbx_info->lldp_remote[LLDP_NEAREST_BRIDGE];	723	p_remote = &p_hwfn->p_dcbx_info->lldp_remote[LLDP_NEAREST_BRIDGE];
724		724
725	memcpy(params->lldp_remote.peer_chassis_id, p_remote->peer_chassis_id,	725	memcpy(params->lldp_remote.peer_chassis_id, p_remote->peer_chassis_id,
726	ARRAY_SIZE(p_remote->peer_chassis_id));	726	sizeof(p_remote->peer_chassis_id));
727	memcpy(params->lldp_remote.peer_port_id, p_remote->peer_port_id,	727	memcpy(params->lldp_remote.peer_port_id, p_remote->peer_port_id,
728	ARRAY_SIZE(p_remote->peer_port_id));	728	sizeof(p_remote->peer_port_id));
729	}	729	}
730		730
731	static int	731	static int

drivers/net/ethernet/qlogic/qed/qed_dev.c+1−1

@@ -1804,7 +1804,7 @@ int qed_hw_init(struct qed_dev cdev, struct qed_hw_init_params p_params) · 1803 unmodified lines
1804	DP_INFO(p_hwfn, "Failed to update driver state\n");	1804	DP_INFO(p_hwfn, "Failed to update driver state\n");
1805		1805
1806	rc = qed_mcp_ov_update_eswitch(p_hwfn, p_hwfn->p_main_ptt,	1806	rc = qed_mcp_ov_update_eswitch(p_hwfn, p_hwfn->p_main_ptt,
1807	QED_OV_ESWITCH_VEB);	1807	QED_OV_ESWITCH_NONE);
1808	if (rc)	1808	if (rc)
1809	DP_INFO(p_hwfn, "Failed to update eswitch mode\n");	1809	DP_INFO(p_hwfn, "Failed to update eswitch mode\n");
1810	}	1810	}

drivers/net/ethernet/qlogic/qed/qed_main.c+8−0

@@ -789,6 +789,14 @@ static int qed_slowpath_setup_int(struct qed_dev *cdev, · 788 unmodified lines
789	/* We want a minimum of one slowpath and one fastpath vector per hwfn */	789	/* We want a minimum of one slowpath and one fastpath vector per hwfn */
790	cdev->int_params.in.min_msix_cnt = cdev->num_hwfns * 2;	790	cdev->int_params.in.min_msix_cnt = cdev->num_hwfns * 2;
791		791
		792	if (is_kdump_kernel()) {
		793	DP_INFO(cdev,
		794	"Kdump kernel: Limit the max number of requested MSI-X vectors to %hd\n",
		795	cdev->int_params.in.min_msix_cnt);
		796	cdev->int_params.in.num_vectors =
		797	cdev->int_params.in.min_msix_cnt;
		798	}
		799
792	rc = qed_set_int_mode(cdev, false);	800	rc = qed_set_int_mode(cdev, false);
793	if (rc) {	801	if (rc) {
794	DP_ERR(cdev, "qed_slowpath_setup_int ERR\n");	802	DP_ERR(cdev, "qed_slowpath_setup_int ERR\n");

drivers/net/ethernet/qlogic/qed/qed_sriov.c+17−2

 static int qed_sriov_enable(struct qed_dev *cdev, int num)
 {
 	struct qed_iov_vf_init_params params;
+	struct qed_hwfn *hwfn;
+	struct qed_ptt *ptt;
 	int i, j, rc;
 	if (num >= RESC_NUM(&cdev->hwfns[0], QED_VPORT)) {
 	/* Initialize HW for VF access */
 	for_each_hwfn(cdev, j) {
-		struct qed_hwfn *hwfn = &cdev->hwfns[j];
+		hwfn = &cdev->hwfns[j];
-		struct qed_ptt *ptt = qed_ptt_acquire(hwfn);
+		ptt = qed_ptt_acquire(hwfn);
 		/* Make sure not to use more than 16 queues per VF */
 		params.num_queues = min_t(int,
 		goto err;
 	}
+	hwfn = QED_LEADING_HWFN(cdev);
+	ptt = qed_ptt_acquire(hwfn);
+	if (!ptt) {
+		DP_ERR(hwfn, "Failed to acquire ptt\n");
+		rc = -EBUSY;
+		goto err;
+	}
+	rc = qed_mcp_ov_update_eswitch(hwfn, ptt, QED_OV_ESWITCH_VEB);
+	if (rc)
+		DP_INFO(cdev, "Failed to update eswitch mode\n");
+	qed_ptt_release(hwfn, ptt);
 	return num;
 err:

drivers/net/ethernet/qlogic/qede/qede_ptp.c+8−2

 {
 	struct qede_ptp *ptp = edev->ptp;
-	if (!ptp)
+	if (!ptp) {
-		return -EIO;
+		info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE |
+					SOF_TIMESTAMPING_RX_SOFTWARE |
+					SOF_TIMESTAMPING_SOFTWARE;
+		info->phc_index = -1;
+		return 0;
+	}
 	info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE |
 				SOF_TIMESTAMPING_RX_SOFTWARE |

drivers/net/ethernet/sfc/farch.c+1−0

@@ -2794,6 +2794,7 @@ int efx_farch_filter_table_probe(struct efx_nic *efx) · 2793 unmodified lines
2794	if (!state)	2794	if (!state)
2795	return -ENOMEM;	2795	return -ENOMEM;
2796	efx->filter_state = state;	2796	efx->filter_state = state;
		2797	init_rwsem(&state->lock);
2797		2798
2798	table = &state->table[EFX_FARCH_FILTER_TABLE_RX_IP];	2799	table = &state->table[EFX_FARCH_FILTER_TABLE_RX_IP];
2799	table->id = EFX_FARCH_FILTER_TABLE_RX_IP;	2800	table->id = EFX_FARCH_FILTER_TABLE_RX_IP;

drivers/net/ethernet/stmicro/stmmac/dwmac4_dma.c+12−0

 	writel(mtl_tx_op, ioaddr +  MTL_CHAN_TX_OP_MODE(channel));
 }
+static void dwmac4_set_bfsize(void __iomem *ioaddr, int bfsize, u32 chan)
+{
+	u32 value = readl(ioaddr + DMA_CHAN_RX_CONTROL(chan));
+	value &= ~DMA_RBSZ_MASK;
+	value |= (bfsize << DMA_RBSZ_SHIFT) & DMA_RBSZ_MASK;
+	writel(value, ioaddr + DMA_CHAN_RX_CONTROL(chan));
+}
 const struct stmmac_dma_ops dwmac4_dma_ops = {
 	.reset = dwmac4_dma_reset,
 	.init = dwmac4_dma_init,
 	.set_tx_tail_ptr = dwmac4_set_tx_tail_ptr,
 	.enable_tso = dwmac4_enable_tso,
 	.qmode = dwmac4_qmode,
+	.set_bfsize = dwmac4_set_bfsize,
 };
 const struct stmmac_dma_ops dwmac410_dma_ops = {
 	.set_tx_tail_ptr = dwmac4_set_tx_tail_ptr,
 	.enable_tso = dwmac4_enable_tso,
 	.qmode = dwmac4_qmode,
+	.set_bfsize = dwmac4_set_bfsize,
 };

drivers/net/ethernet/stmicro/stmmac/dwmac4_dma.h+2−0

@@ -120,6 +120,8 @@ · 119 unmodified lines
120		120
121	/* DMA Rx Channel X Control register defines */	121	/* DMA Rx Channel X Control register defines */
122	#define DMA_CONTROL_SR BIT(0)	122	#define DMA_CONTROL_SR BIT(0)
		123	#define DMA_RBSZ_MASK GENMASK(14, 1)
		124	#define DMA_RBSZ_SHIFT 1
123		125
124	/* Interrupt status per channel */	126	/* Interrupt status per channel */
125	#define DMA_CHAN_STATUS_REB GENMASK(21, 19)	127	#define DMA_CHAN_STATUS_REB GENMASK(21, 19)

drivers/net/ethernet/stmicro/stmmac/hwif.h+3−0

 	void (*set_tx_tail_ptr)(void __iomem *ioaddr, u32 tail_ptr, u32 chan);
 	void (*enable_tso)(void __iomem *ioaddr, bool en, u32 chan);
 	void (*qmode)(void __iomem *ioaddr, u32 channel, u8 qmode);
+	void (*set_bfsize)(void __iomem *ioaddr, int bfsize, u32 chan);
 };
 #define stmmac_reset(__priv, __args...) \
 	stmmac_do_void_callback(__priv, dma, enable_tso, __args)
 #define stmmac_dma_qmode(__priv, __args...) \
 	stmmac_do_void_callback(__priv, dma, qmode, __args)
+#define stmmac_set_dma_bfsize(__priv, __args...) \
+	stmmac_do_void_callback(__priv, dma, set_bfsize, __args)
 struct mac_device_info;
 struct net_device;

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c+2−0

@@ -1804,6 +1804,8 @@ static void stmmac_dma_operation_mode(struct stmmac_priv *priv) · 1803 unmodified lines
1804		1804
1805	stmmac_dma_rx_mode(priv, priv->ioaddr, rxmode, chan,	1805	stmmac_dma_rx_mode(priv, priv->ioaddr, rxmode, chan,
1806	rxfifosz, qmode);	1806	rxfifosz, qmode);
		1807	stmmac_set_dma_bfsize(priv, priv->ioaddr, priv->dma_buf_sz,
		1808	chan);
1807	}	1809	}
1808		1810
1809	for (chan = 0; chan < tx_channels_count; chan++) {	1811	for (chan = 0; chan < tx_channels_count; chan++) {

drivers/net/geneve.c+1−1

@@ -478,7 +478,7 @@ static struct sk_buff geneve_gro_receive(struct sock sk, · 477 unmodified lines
478	out_unlock:	478	out_unlock:
479	rcu_read_unlock();	479	rcu_read_unlock();
480	out:	480	out:
481	NAPI_GRO_CB(skb)->flush \|= flush;	481	skb_gro_flush_final(skb, pp, flush);
482		482
483	return pp;	483	return pp;
484	}	484	}

drivers/net/hyperv/hyperv_net.h+1−1

@@ -210,7 +210,7 @@ int netvsc_recv_callback(struct net_device *net, · 209 unmodified lines
210	void netvsc_channel_cb(void *context);	210	void netvsc_channel_cb(void *context);
211	int netvsc_poll(struct napi_struct *napi, int budget);	211	int netvsc_poll(struct napi_struct *napi, int budget);
212		212
213	void rndis_set_subchannel(struct work_struct *w);	213	int rndis_set_subchannel(struct net_device ndev, struct netvsc_device nvdev);
214	int rndis_filter_open(struct netvsc_device *nvdev);	214	int rndis_filter_open(struct netvsc_device *nvdev);
215	int rndis_filter_close(struct netvsc_device *nvdev);	215	int rndis_filter_close(struct netvsc_device *nvdev);
216	struct netvsc_device rndis_filter_device_add(struct hv_device dev,	216	struct netvsc_device rndis_filter_device_add(struct hv_device dev,

drivers/net/hyperv/netvsc.c+36−1

@@ -65,6 +65,41 @@ void netvsc_switch_datapath(struct net_device *ndev, bool vf) · 64 unmodified lines
65	VM_PKT_DATA_INBAND, 0);	65	VM_PKT_DATA_INBAND, 0);
66	}	66	}
67		67
		68	/* Worker to setup sub channels on initial setup
		69	* Initial hotplug event occurs in softirq context
		70	* and can't wait for channels.
		71	*/
		72	static void netvsc_subchan_work(struct work_struct *w)
		73	{
		74	struct netvsc_device *nvdev =
		75	container_of(w, struct netvsc_device, subchan_work);
		76	struct rndis_device *rdev;
		77	int i, ret;
		78
		79	/* Avoid deadlock with device removal already under RTNL */
		80	if (!rtnl_trylock()) {
		81	schedule_work(w);
		82	return;
		83	}
		84
		85	rdev = nvdev->extension;
		86	if (rdev) {
		87	ret = rndis_set_subchannel(rdev->ndev, nvdev);
		88	if (ret == 0) {
		89	netif_device_attach(rdev->ndev);
		90	} else {
		91	/* fallback to only primary channel */
		92	for (i = 1; i < nvdev->num_chn; i++)
		93	netif_napi_del(&nvdev->chan_table[i].napi);
		94
		95	nvdev->max_chn = 1;
		96	nvdev->num_chn = 1;
		97	}
		98	}
		99
		100	rtnl_unlock();
		101	}
		102
68	static struct netvsc_device *alloc_net_device(void)	103	static struct netvsc_device *alloc_net_device(void)
69	{	104	{
70	struct netvsc_device *net_device;	105	struct netvsc_device *net_device;
@@ -81,7 +116,7 @@ static struct netvsc_device *alloc_net_device(void) · 10 unmodified lines
81		116
82	init_completion(&net_device->channel_init_wait);	117	init_completion(&net_device->channel_init_wait);
83	init_waitqueue_head(&net_device->subchan_open);	118	init_waitqueue_head(&net_device->subchan_open);
84	INIT_WORK(&net_device->subchan_work, rndis_set_subchannel);	119	INIT_WORK(&net_device->subchan_work, netvsc_subchan_work);
85		120
86	return net_device;	121	return net_device;
87	}	122	}

drivers/net/hyperv/netvsc_drv.c+16−1

@@ -905,8 +905,20 @@ static int netvsc_attach(struct net_device *ndev, · 904 unmodified lines
905	if (IS_ERR(nvdev))	905	if (IS_ERR(nvdev))
906	return PTR_ERR(nvdev);	906	return PTR_ERR(nvdev);
907		907
908	/* Note: enable and attach happen when sub-channels setup */	908	if (nvdev->num_chn > 1) {
		909	ret = rndis_set_subchannel(ndev, nvdev);
		910
		911	/* if unavailable, just proceed with one queue */
		912	if (ret) {
		913	nvdev->max_chn = 1;
		914	nvdev->num_chn = 1;
		915	}
		916	}
		917
		918	/* In any case device is now ready */
		919	netif_device_attach(ndev);
909		920
		921	/* Note: enable and attach happen when sub-channels setup */
910	netif_carrier_off(ndev);	922	netif_carrier_off(ndev);
911		923
912	if (netif_running(ndev)) {	924	if (netif_running(ndev)) {
@@ -2089,6 +2101,9 @@ static int netvsc_probe(struct hv_device *dev, · 1176 unmodified lines
2089		2101
2090	memcpy(net->dev_addr, device_info.mac_adr, ETH_ALEN);	2102	memcpy(net->dev_addr, device_info.mac_adr, ETH_ALEN);
2091		2103
		2104	if (nvdev->num_chn > 1)
		2105	schedule_work(&nvdev->subchan_work);
		2106
2092	/* hw_features computed in rndis_netdev_set_hwcaps() */	2107	/* hw_features computed in rndis_netdev_set_hwcaps() */
2093	net->features = net->hw_features \|	2108	net->features = net->hw_features \|
2094	NETIF_F_HIGHDMA \| NETIF_F_SG \|	2109	NETIF_F_HIGHDMA \| NETIF_F_SG \|

drivers/net/hyperv/rndis_filter.c+12−49

  * This breaks overlap of processing the host message for the
  * new primary channel with the initialization of sub-channels.
  */
-void rndis_set_subchannel(struct work_struct *w)
+int rndis_set_subchannel(struct net_device *ndev, struct netvsc_device *nvdev)
 {
-	struct netvsc_device *nvdev
-		= container_of(w, struct netvsc_device, subchan_work);
 	struct nvsp_message *init_packet = &nvdev->channel_init_pkt;
-	struct net_device_context *ndev_ctx;
+	struct net_device_context *ndev_ctx = netdev_priv(ndev);
-	struct rndis_device *rdev;
+	struct hv_device *hv_dev = ndev_ctx->device_ctx;
-	struct net_device *ndev;
+	struct rndis_device *rdev = nvdev->extension;
-	struct hv_device *hv_dev;
 	int i, ret;
-	if (!rtnl_trylock()) {
+	ASSERT_RTNL();
-		schedule_work(w);
-		return;
-	}
-	rdev = nvdev->extension;
-	if (!rdev)
-		goto unlock;	/* device was removed */
-	ndev = rdev->ndev;
-	ndev_ctx = netdev_priv(ndev);
-	hv_dev = ndev_ctx->device_ctx;
 	memset(init_packet, 0, sizeof(struct nvsp_message));
 	init_packet->hdr.msg_type = NVSP_MSG5_TYPE_SUBCHANNEL;
 			       VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 	if (ret) {
 		netdev_err(ndev, "sub channel allocate send failed: %d\n", ret);
-		goto failed;
+		return ret;
 	}
 	wait_for_completion(&nvdev->channel_init_wait);
 	if (init_packet->msg.v5_msg.subchn_comp.status != NVSP_STAT_SUCCESS) {
 		netdev_err(ndev, "sub channel request failed\n");
-		goto failed;
+		return -EIO;
 	}
 	nvdev->num_chn = 1 +
 	for (i = 0; i < VRSS_SEND_TAB_SIZE; i++)
 		ndev_ctx->tx_table[i] = i % nvdev->num_chn;
-	netif_device_attach(ndev);
+	return 0;
-	rtnl_unlock();
-	return;
-failed:
-	/* fallback to only primary channel */
-	for (i = 1; i < nvdev->num_chn; i++)
-		netif_napi_del(&nvdev->chan_table[i].napi);
-	nvdev->max_chn = 1;
-	nvdev->num_chn = 1;
-	netif_device_attach(ndev);
-unlock:
-	rtnl_unlock();
 }
 static int rndis_netdev_set_hwcaps(struct rndis_device *rndis_device,
 		netif_napi_add(net, &net_device->chan_table[i].napi,
 			       netvsc_poll, NAPI_POLL_WEIGHT);
-	if (net_device->num_chn > 1)
+	return net_device;
-		schedule_work(&net_device->subchan_work);
 out:
-	/* if unavailable, just proceed with one queue */
+	/* setting up multiple channels failed */
-	if (ret) {
+	net_device->max_chn = 1;
-		net_device->max_chn = 1;
+	net_device->num_chn = 1;
-		net_device->num_chn = 1;
-	}
-	/* No sub channels, device is ready */
-	if (net_device->num_chn == 1)
-		netif_device_attach(net);
-	return net_device;
 err_dev_remv:
 	rndis_filter_device_remove(dev, net_device);

drivers/net/ipvlan/ipvlan_main.c+28−8

 {
 	struct ipvl_dev *ipvlan;
 	struct net_device *mdev = port->dev;
-	int err = 0;
+	unsigned int flags;
+	int err;
 	ASSERT_RTNL();
 	if (port->mode != nval) {
+		list_for_each_entry(ipvlan, &port->ipvlans, pnode) {
+			flags = ipvlan->dev->flags;
+			if (nval == IPVLAN_MODE_L3 || nval == IPVLAN_MODE_L3S) {
+				err = dev_change_flags(ipvlan->dev,
+						       flags | IFF_NOARP);
+			} else {
+				err = dev_change_flags(ipvlan->dev,
+						       flags & ~IFF_NOARP);
+			}
+			if (unlikely(err))
+				goto fail;
+		}
 		if (nval == IPVLAN_MODE_L3S) {
 			/* New mode is L3S */
 			err = ipvlan_register_nf_hook(read_pnet(&port->pnet));
 				mdev->l3mdev_ops = &ipvl_l3mdev_ops;
 				mdev->priv_flags |= IFF_L3MDEV_MASTER;
 			} else
-				return err;
+				goto fail;
 		} else if (port->mode == IPVLAN_MODE_L3S) {
 			/* Old mode was L3S */
 			mdev->priv_flags &= ~IFF_L3MDEV_MASTER;
 			ipvlan_unregister_nf_hook(read_pnet(&port->pnet));
 			mdev->l3mdev_ops = NULL;
 		}
-		list_for_each_entry(ipvlan, &port->ipvlans, pnode) {
-			if (nval == IPVLAN_MODE_L3 || nval == IPVLAN_MODE_L3S)
-				ipvlan->dev->flags |= IFF_NOARP;
-			else
-				ipvlan->dev->flags &= ~IFF_NOARP;
-		}
 		port->mode = nval;
 	}
+	return 0;
+fail:
+	/* Undo the flags changes that have been done so far. */
+	list_for_each_entry_continue_reverse(ipvlan, &port->ipvlans, pnode) {
+		flags = ipvlan->dev->flags;
+		if (port->mode == IPVLAN_MODE_L3 ||
+		    port->mode == IPVLAN_MODE_L3S)
+			dev_change_flags(ipvlan->dev, flags | IFF_NOARP);
+		else
+			dev_change_flags(ipvlan->dev, flags & ~IFF_NOARP);
+	}
 	return err;
 }

drivers/net/phy/dp83tc811.c+1−1

@@ -222,7 +222,7 @@ static int dp83811_config_intr(struct phy_device *phydev) · 221 unmodified lines
222	if (err < 0)	222	if (err < 0)
223	return err;	223	return err;
224		224
225	err = phy_write(phydev, MII_DP83811_INT_STAT1, 0);	225	err = phy_write(phydev, MII_DP83811_INT_STAT2, 0);
226	}	226	}
227		227
228	return err;	228	return err;

drivers/net/ppp/pppoe.c+1−1

@@ -1107,7 +1107,7 @@ static const struct proto_ops pppoe_ops = { · 1106 unmodified lines
1107	.socketpair = sock_no_socketpair,	1107	.socketpair = sock_no_socketpair,
1108	.accept = sock_no_accept,	1108	.accept = sock_no_accept,
1109	.getname = pppoe_getname,	1109	.getname = pppoe_getname,
1110	.poll_mask = datagram_poll_mask,	1110	.poll = datagram_poll,
1111	.listen = sock_no_listen,	1111	.listen = sock_no_listen,
1112	.shutdown = sock_no_shutdown,	1112	.shutdown = sock_no_shutdown,
1113	.setsockopt = sock_no_setsockopt,	1113	.setsockopt = sock_no_setsockopt,

drivers/net/usb/lan78xx.c+34−3

 #define DEFAULT_RX_CSUM_ENABLE		(true)
 #define DEFAULT_TSO_CSUM_ENABLE		(true)
 #define DEFAULT_VLAN_FILTER_ENABLE	(true)
+#define DEFAULT_VLAN_RX_OFFLOAD		(true)
 #define TX_OVERHEAD			(8)
 #define RXW_PADDING			2
 	if ((ll_mtu % dev->maxpacket) == 0)
 		return -EDOM;
-	ret = lan78xx_set_rx_max_frame_length(dev, new_mtu + ETH_HLEN);
+	ret = lan78xx_set_rx_max_frame_length(dev, new_mtu + VLAN_ETH_HLEN);
 	netdev->mtu = new_mtu;
 	}
 	if (features & NETIF_F_HW_VLAN_CTAG_RX)
+		pdata->rfe_ctl |= RFE_CTL_VLAN_STRIP_;
+	else
+		pdata->rfe_ctl &= ~RFE_CTL_VLAN_STRIP_;
+	if (features & NETIF_F_HW_VLAN_CTAG_FILTER)
 		pdata->rfe_ctl |= RFE_CTL_VLAN_FILTER_;
 	else
 		pdata->rfe_ctl &= ~RFE_CTL_VLAN_FILTER_;
 	buf |= FCT_TX_CTL_EN_;
 	ret = lan78xx_write_reg(dev, FCT_TX_CTL, buf);
-	ret = lan78xx_set_rx_max_frame_length(dev, dev->net->mtu + ETH_HLEN);
+	ret = lan78xx_set_rx_max_frame_length(dev,
+					      dev->net->mtu + VLAN_ETH_HLEN);
 	ret = lan78xx_read_reg(dev, MAC_RX, &buf);
 	buf |= MAC_RX_RXEN_;
 	if (DEFAULT_TSO_CSUM_ENABLE)
 		dev->net->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_SG;
+	if (DEFAULT_VLAN_RX_OFFLOAD)
+		dev->net->features |= NETIF_F_HW_VLAN_CTAG_RX;
+	if (DEFAULT_VLAN_FILTER_ENABLE)
+		dev->net->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
 	dev->net->hw_features = dev->net->features;
 	ret = lan78xx_setup_irq_domain(dev);
 				    struct sk_buff *skb,
 				    u32 rx_cmd_a, u32 rx_cmd_b)
 {
+	/* HW Checksum offload appears to be flawed if used when not stripping
+	 * VLAN headers. Drop back to S/W checksums under these conditions.
+	 */
 	if (!(dev->net->features & NETIF_F_RXCSUM) ||
-	    unlikely(rx_cmd_a & RX_CMD_A_ICSM_)) {
+	    unlikely(rx_cmd_a & RX_CMD_A_ICSM_) ||
+	    ((rx_cmd_a & RX_CMD_A_FVTG_) &&
+	     !(dev->net->features & NETIF_F_HW_VLAN_CTAG_RX))) {
 		skb->ip_summed = CHECKSUM_NONE;
 	} else {
 		skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT_));
 	}
 }
+static void lan78xx_rx_vlan_offload(struct lan78xx_net *dev,
+				    struct sk_buff *skb,
+				    u32 rx_cmd_a, u32 rx_cmd_b)
+{
+	if ((dev->net->features & NETIF_F_HW_VLAN_CTAG_RX) &&
+	    (rx_cmd_a & RX_CMD_A_FVTG_))
+		__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
+				       (rx_cmd_b & 0xffff));
+}
 static void lan78xx_skb_return(struct lan78xx_net *dev, struct sk_buff *skb)
 {
 	int		status;
 			if (skb->len == size) {
 				lan78xx_rx_csum_offload(dev, skb,
 							rx_cmd_a, rx_cmd_b);
+				lan78xx_rx_vlan_offload(dev, skb,
+							rx_cmd_a, rx_cmd_b);
 				skb_trim(skb, skb->len - 4); /* remove fcs */
 				skb->truesize = size + sizeof(struct sk_buff);
 			skb_set_tail_pointer(skb2, size);
 			lan78xx_rx_csum_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
+			lan78xx_rx_vlan_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
 			skb_trim(skb2, skb2->len - 4); /* remove fcs */
 			skb2->truesize = size + sizeof(struct sk_buff);

drivers/net/usb/r8152.c+2−1

 #ifdef CONFIG_PM_SLEEP
 	unregister_pm_notifier(&tp->pm_notifier);
 #endif
-	napi_disable(&tp->napi);
+	if (!test_bit(RTL8152_UNPLUG, &tp->flags))
+		napi_disable(&tp->napi);
 	clear_bit(WORK_ENABLE, &tp->flags);
 	usb_kill_urb(tp->intr_urb);
 	cancel_delayed_work_sync(&tp->schedule);

drivers/net/virtio_net.c+19−11

 /* Amount of XDP headroom to prepend to packets for use by xdp_adjust_head */
 #define VIRTIO_XDP_HEADROOM 256
+/* Separating two types of XDP xmit */
+#define VIRTIO_XDP_TX		BIT(0)
+#define VIRTIO_XDP_REDIR	BIT(1)
 /* RX packet size EWMA. The average packet size is used to determine the packet
  * buffer size when refilling RX rings. As the entire RX ring may be refilled
  * at once, the weight is chosen so that the EWMA will be insensitive to short-
 				     struct receive_queue *rq,
 				     void *buf, void *ctx,
 				     unsigned int len,
-				     bool *xdp_xmit)
+				     unsigned int *xdp_xmit)
 {
 	struct sk_buff *skb;
 	struct bpf_prog *xdp_prog;
 				trace_xdp_exception(vi->dev, xdp_prog, act);
 				goto err_xdp;
 			}
-			*xdp_xmit = true;
+			*xdp_xmit |= VIRTIO_XDP_TX;
 			rcu_read_unlock();
 			goto xdp_xmit;
 		case XDP_REDIRECT:
 			err = xdp_do_redirect(dev, &xdp, xdp_prog);
 			if (err)
 				goto err_xdp;
-			*xdp_xmit = true;
+			*xdp_xmit |= VIRTIO_XDP_REDIR;
 			rcu_read_unlock();
 			goto xdp_xmit;
 		default:
 					 void *buf,
 					 void *ctx,
 					 unsigned int len,
-					 bool *xdp_xmit)
+					 unsigned int *xdp_xmit)
 {
 	struct virtio_net_hdr_mrg_rxbuf *hdr = buf;
 	u16 num_buf = virtio16_to_cpu(vi->vdev, hdr->num_buffers);
 					put_page(xdp_page);
 				goto err_xdp;
 			}
-			*xdp_xmit = true;
+			*xdp_xmit |= VIRTIO_XDP_TX;
 			if (unlikely(xdp_page != page))
 				put_page(page);
 			rcu_read_unlock();
 					put_page(xdp_page);
 				goto err_xdp;
 			}
-			*xdp_xmit = true;
+			*xdp_xmit |= VIRTIO_XDP_REDIR;
 			if (unlikely(xdp_page != page))
 				put_page(page);
 			rcu_read_unlock();
 }
 static int receive_buf(struct virtnet_info *vi, struct receive_queue *rq,
-		       void *buf, unsigned int len, void **ctx, bool *xdp_xmit)
+		       void *buf, unsigned int len, void **ctx,
+		       unsigned int *xdp_xmit)
 {
 	struct net_device *dev = vi->dev;
 	struct sk_buff *skb;
 	}
 }
-static int virtnet_receive(struct receive_queue *rq, int budget, bool *xdp_xmit)
+static int virtnet_receive(struct receive_queue *rq, int budget,
+			   unsigned int *xdp_xmit)
 {
 	struct virtnet_info *vi = rq->vq->vdev->priv;
 	unsigned int len, received = 0, bytes = 0;
 	struct virtnet_info *vi = rq->vq->vdev->priv;
 	struct send_queue *sq;
 	unsigned int received, qp;
-	bool xdp_xmit = false;
+	unsigned int xdp_xmit = 0;
 	virtnet_poll_cleantx(rq);
 	if (received < budget)
 		virtqueue_napi_complete(napi, rq->vq, received);
-	if (xdp_xmit) {
+	if (xdp_xmit & VIRTIO_XDP_REDIR)
+		xdp_do_flush_map();
+	if (xdp_xmit & VIRTIO_XDP_TX) {
 		qp = vi->curr_queue_pairs - vi->xdp_queue_pairs +
 		     smp_processor_id();
 		sq = &vi->sq[qp];
 		virtqueue_kick(sq->vq);
-		xdp_do_flush_map();
 	}
 	return received;

drivers/net/vxlan.c+1−3

@@ -624,9 +624,7 @@ static struct sk_buff vxlan_gro_receive(struct sock sk, · 623 unmodified lines
624	flush = 0;	624	flush = 0;
625		625
626	out:	626	out:
627	skb_gro_remcsum_cleanup(skb, &grc);	627	skb_gro_flush_final_remcsum(skb, pp, flush, &grc);
628	skb->remcsum_offload = 0;
629	NAPI_GRO_CB(skb)->flush \|= flush;
630		628
631	return pp;	629	return pp;
632	}	630	}

drivers/nfc/pn533/usb.c+2−2

@@ -74,7 +74,7 @@ static void pn533_recv_response(struct urb *urb) · 73 unmodified lines
74	struct sk_buff *skb = NULL;	74	struct sk_buff *skb = NULL;
75		75
76	if (!urb->status) {	76	if (!urb->status) {
77	skb = alloc_skb(urb->actual_length, GFP_KERNEL);	77	skb = alloc_skb(urb->actual_length, GFP_ATOMIC);
78	if (!skb) {	78	if (!skb) {
79	nfc_err(&phy->udev->dev, "failed to alloc memory\n");	79	nfc_err(&phy->udev->dev, "failed to alloc memory\n");
80	} else {	80	} else {
@@ -186,7 +186,7 @@ static int pn533_usb_send_frame(struct pn533 *dev, · 105 unmodified lines
186		186
187	if (dev->protocol_type == PN533_PROTO_REQ_RESP) {	187	if (dev->protocol_type == PN533_PROTO_REQ_RESP) {
188	/* request for response for sent packet directly */	188	/* request for response for sent packet directly */
189	rc = pn533_submit_urb_for_response(phy, GFP_ATOMIC);	189	rc = pn533_submit_urb_for_response(phy, GFP_KERNEL);
190	if (rc)	190	if (rc)
191	goto error;	191	goto error;
192	} else if (dev->protocol_type == PN533_PROTO_REQ_ACK_RESP) {	192	} else if (dev->protocol_type == PN533_PROTO_REQ_ACK_RESP) {

drivers/nvdimm/pmem.c+2−1

@@ -414,7 +414,8 @@ static int pmem_attach_disk(struct device *dev, · 413 unmodified lines
414	blk_queue_logical_block_size(q, pmem_sector_size(ndns));	414	blk_queue_logical_block_size(q, pmem_sector_size(ndns));
415	blk_queue_max_hw_sectors(q, UINT_MAX);	415	blk_queue_max_hw_sectors(q, UINT_MAX);
416	blk_queue_flag_set(QUEUE_FLAG_NONROT, q);	416	blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
417	blk_queue_flag_set(QUEUE_FLAG_DAX, q);	417	if (pmem->pfn_flags & PFN_MAP)
		418	blk_queue_flag_set(QUEUE_FLAG_DAX, q);
418	q->queuedata = pmem;	419	q->queuedata = pmem;
419		420
420	disk = alloc_disk_node(0, nid);	421	disk = alloc_disk_node(0, nid);

drivers/nvme/host/rdma.c+5−2

 		blk_cleanup_queue(ctrl->ctrl.admin_q);
 		nvme_rdma_free_tagset(&ctrl->ctrl, ctrl->ctrl.admin_tagset);
 	}
-	nvme_rdma_free_qe(ctrl->device->dev, &ctrl->async_event_sqe,
+	if (ctrl->async_event_sqe.data) {
-		sizeof(struct nvme_command), DMA_TO_DEVICE);
+		nvme_rdma_free_qe(ctrl->device->dev, &ctrl->async_event_sqe,
+				sizeof(struct nvme_command), DMA_TO_DEVICE);
+		ctrl->async_event_sqe.data = NULL;
+	}
 	nvme_rdma_free_queue(&ctrl->queues[0]);
 }

drivers/pci/Makefile+3−3

 obj-$(CONFIG_PCI_ECAM)		+= ecam.o
 obj-$(CONFIG_XEN_PCIDEV_FRONTEND) += xen-pcifront.o
-obj-y				+= controller/
-obj-y				+= switch/
 # Endpoint library must be initialized before its users
 obj-$(CONFIG_PCI_ENDPOINT)	+= endpoint/
+obj-y				+= controller/
+obj-y				+= switch/
 ccflags-$(CONFIG_PCI_DEBUG) := -DDEBUG

drivers/pci/controller/Kconfig+0−3

 	depends on OF
 	select PCI_HOST_COMMON
 	select IRQ_DOMAIN
-	select PCI_DOMAINS
 	help
 	  Say Y here if you want to support a simple generic PCI host
 	  controller, such as the one emulated by kvmtool.
 config PCIE_IPROC
 	tristate
-	select PCI_DOMAINS
 	help
 	  This enables the iProc PCIe core controller support for Broadcom's
 	  iProc family of SoCs. An appropriate bus interface driver needs
 config PCIE_ALTERA
 	bool "Altera PCIe controller"
 	depends on ARM || NIOS2 || COMPILE_TEST
-	select PCI_DOMAINS
 	help
 	  Say Y here if you want to enable PCIe controller support on Altera
 	  FPGA.

drivers/pci/hotplug/acpi_pcihp.c+9−1

  * All rights reserved.
  *
  * Send feedback to <kristen.c.accardi@intel.com>
- *
  */
 #include <linux/module.h>
 		return 0;
 	/* If _OSC exists, we should not evaluate OSHP */
+	/*
+	 * If there's no ACPI host bridge (i.e., ACPI support is compiled
+	 * into the kernel but the hardware platform doesn't support ACPI),
+	 * there's nothing to do here.
+	 */
 	host = pci_find_host_bridge(pdev->bus);
 	root = acpi_pci_find_root(ACPI_HANDLE(&host->dev));
+	if (!root)
+		return 0;
 	if (root->osc_support_set)
 		goto no_control;

drivers/perf/xgene_pmu.c+1−1

@@ -1463,7 +1463,7 @@ static char xgene_pmu_dev_name(struct device dev, u32 type, int id) · 1462 unmodified lines
1463	case PMU_TYPE_IOB:	1463	case PMU_TYPE_IOB:
1464	return devm_kasprintf(dev, GFP_KERNEL, "iob%d", id);	1464	return devm_kasprintf(dev, GFP_KERNEL, "iob%d", id);
1465	case PMU_TYPE_IOB_SLOW:	1465	case PMU_TYPE_IOB_SLOW:
1466	return devm_kasprintf(dev, GFP_KERNEL, "iob-slow%d", id);	1466	return devm_kasprintf(dev, GFP_KERNEL, "iob_slow%d", id);
1467	case PMU_TYPE_MCB:	1467	case PMU_TYPE_MCB:
1468	return devm_kasprintf(dev, GFP_KERNEL, "mcb%d", id);	1468	return devm_kasprintf(dev, GFP_KERNEL, "mcb%d", id);
1469	case PMU_TYPE_MC:	1469	case PMU_TYPE_MC:

drivers/s390/net/qeth_core.h+12−1

 /*some helper functions*/
 #define QETH_CARD_IFNAME(card) (((card)->dev)? (card)->dev->name : "")
+static inline void qeth_scrub_qdio_buffer(struct qdio_buffer *buf,
+					  unsigned int elements)
+{
+	unsigned int i;
+	for (i = 0; i < elements; i++)
+		memset(&buf->element[i], 0, sizeof(struct qdio_buffer_element));
+	buf->element[14].sflags = 0;
+	buf->element[15].sflags = 0;
+}
 /**
  * qeth_get_elements_for_range() -	find number of SBALEs to cover range.
  * @start:				Start of the address range.
 						 __u16, __u16,
 						 enum qeth_prot_versions);
 int qeth_set_features(struct net_device *, netdev_features_t);
-void qeth_recover_features(struct net_device *dev);
+void qeth_enable_hw_features(struct net_device *dev);
 netdev_features_t qeth_fix_features(struct net_device *, netdev_features_t);
 netdev_features_t qeth_features_check(struct sk_buff *skb,
 				      struct net_device *dev,

drivers/s390/net/qeth_core_main.c+28−19

@@ -73,9 +73,6 @@ static void qeth_notify_skbs(struct qeth_qdio_out_q *queue, · 72 unmodified lines
73	struct qeth_qdio_out_buffer *buf,	73	struct qeth_qdio_out_buffer *buf,
74	enum iucv_tx_notify notification);	74	enum iucv_tx_notify notification);
75	static void qeth_release_skbs(struct qeth_qdio_out_buffer *buf);	75	static void qeth_release_skbs(struct qeth_qdio_out_buffer *buf);
76	static void qeth_clear_output_buffer(struct qeth_qdio_out_q *queue,
77	struct qeth_qdio_out_buffer *buf,
78	enum qeth_qdio_buffer_states newbufstate);
79	static int qeth_init_qdio_out_buf(struct qeth_qdio_out_q *, int);	76	static int qeth_init_qdio_out_buf(struct qeth_qdio_out_q *, int);
80		77
81	struct workqueue_struct *qeth_wq;	78	struct workqueue_struct *qeth_wq;
@@ -489,6 +486,7 @@ static void qeth_qdio_handle_aob(struct qeth_card *card, · 407 unmodified lines
489	struct qaob *aob;	486	struct qaob *aob;
490	struct qeth_qdio_out_buffer *buffer;	487	struct qeth_qdio_out_buffer *buffer;
491	enum iucv_tx_notify notification;	488	enum iucv_tx_notify notification;
		489	unsigned int i;
492		490
493	aob = (struct qaob *) phys_to_virt(phys_aob_addr);	491	aob = (struct qaob *) phys_to_virt(phys_aob_addr);
494	QETH_CARD_TEXT(card, 5, "haob");	492	QETH_CARD_TEXT(card, 5, "haob");
@@ -513,10 +511,18 @@ static void qeth_qdio_handle_aob(struct qeth_card *card, · 18 unmodified lines
513	qeth_notify_skbs(buffer->q, buffer, notification);	511	qeth_notify_skbs(buffer->q, buffer, notification);
514		512
515	buffer->aob = NULL;	513	buffer->aob = NULL;
516	qeth_clear_output_buffer(buffer->q, buffer,	514	/* Free dangling allocations. The attached skbs are handled by
517	QETH_QDIO_BUF_HANDLED_DELAYED);	515	* qeth_cleanup_handled_pending().
		516	*/
		517	for (i = 0;
		518	i < aob->sb_count && i < QETH_MAX_BUFFER_ELEMENTS(card);
		519	i++) {
		520	if (aob->sba[i] && buffer->is_header[i])
		521	kmem_cache_free(qeth_core_header_cache,
		522	(void *) aob->sba[i]);
		523	}
		524	atomic_set(&buffer->state, QETH_QDIO_BUF_HANDLED_DELAYED);
518		525
519	/* from here on: do not touch buffer anymore */
520	qdio_release_aob(aob);	526	qdio_release_aob(aob);
521	}	527	}
522		528
@@ -3759,6 +3765,10 @@ static void qeth_qdio_output_handler(struct ccw_device *ccwdev, · 3236 unmodified lines
3759	QETH_CARD_TEXT(queue->card, 5, "aob");	3765	QETH_CARD_TEXT(queue->card, 5, "aob");
3760	QETH_CARD_TEXT_(queue->card, 5, "%lx",	3766	QETH_CARD_TEXT_(queue->card, 5, "%lx",
3761	virt_to_phys(buffer->aob));	3767	virt_to_phys(buffer->aob));
		3768
		3769	/* prepare the queue slot for re-use: */
		3770	qeth_scrub_qdio_buffer(buffer->buffer,
		3771	QETH_MAX_BUFFER_ELEMENTS(card));
3762	if (qeth_init_qdio_out_buf(queue, bidx)) {	3772	if (qeth_init_qdio_out_buf(queue, bidx)) {
3763	QETH_CARD_TEXT(card, 2, "outofbuf");	3773	QETH_CARD_TEXT(card, 2, "outofbuf");
3764	qeth_schedule_recovery(card);	3774	qeth_schedule_recovery(card);
@@ -4834,7 +4844,7 @@ int qeth_vm_request_mac(struct qeth_card *card) · 1069 unmodified lines
4834	goto out;	4844	goto out;
4835	}	4845	}
4836		4846
4837	ccw_device_get_id(CARD_RDEV(card), &id);	4847	ccw_device_get_id(CARD_DDEV(card), &id);
4838	request->resp_buf_len = sizeof(*response);	4848	request->resp_buf_len = sizeof(*response);
4839	request->resp_version = DIAG26C_VERSION2;	4849	request->resp_version = DIAG26C_VERSION2;
4840	request->op_code = DIAG26C_GET_MAC;	4850	request->op_code = DIAG26C_GET_MAC;
@@ -6459,28 +6469,27 @@ static int qeth_set_ipa_rx_csum(struct qeth_card *card, bool on) · 1618 unmodified lines
6459	#define QETH_HW_FEATURES (NETIF_F_RXCSUM \| NETIF_F_IP_CSUM \| NETIF_F_TSO \| \	6469	#define QETH_HW_FEATURES (NETIF_F_RXCSUM \| NETIF_F_IP_CSUM \| NETIF_F_TSO \| \
6460	NETIF_F_IPV6_CSUM)	6470	NETIF_F_IPV6_CSUM)
6461	/**	6471	/**
6462	* qeth_recover_features() - Restore device features after recovery	6472	* qeth_enable_hw_features() - (Re-)Enable HW functions for device features
6463	* @dev: the recovering net_device	6473	* @dev: a net_device
6464	*
6465	* Caller must hold rtnl lock.
6466	*/	6474	*/
6467	void qeth_recover_features(struct net_device *dev)	6475	void qeth_enable_hw_features(struct net_device *dev)
6468	{	6476	{
6469	netdev_features_t features = dev->features;
6470	struct qeth_card *card = dev->ml_priv;	6477	struct qeth_card *card = dev->ml_priv;
		6478	netdev_features_t features;
6471		6479
		6480	rtnl_lock();
		6481	features = dev->features;
6472	/* force-off any feature that needs an IPA sequence.	6482	/* force-off any feature that needs an IPA sequence.
6473	* netdev_update_features() will restart them.	6483	* netdev_update_features() will restart them.
6474	*/	6484	*/
6475	dev->features &= ~QETH_HW_FEATURES;	6485	dev->features &= ~QETH_HW_FEATURES;
6476	netdev_update_features(dev);	6486	netdev_update_features(dev);
6477		6487	if (features != dev->features)
6478	if (features == dev->features)	6488	dev_warn(&card->gdev->dev,
6479	return;	6489	"Device recovery failed to restore all offload features\n");
6480	dev_warn(&card->gdev->dev,	6490	rtnl_unlock();
6481	"Device recovery failed to restore all offload features\n");
6482	}	6491	}
6483	EXPORT_SYMBOL_GPL(qeth_recover_features);	6492	EXPORT_SYMBOL_GPL(qeth_enable_hw_features);
6484		6493
6485	int qeth_set_features(struct net_device *dev, netdev_features_t features)	6494	int qeth_set_features(struct net_device *dev, netdev_features_t features)
6486	{	6495	{

drivers/s390/net/qeth_l2_main.c+15−9

@@ -140,7 +140,7 @@ static int qeth_l2_send_setmac(struct qeth_card card, __u8 mac) · 139 unmodified lines
140		140
141	static int qeth_l2_write_mac(struct qeth_card card, u8 mac)	141	static int qeth_l2_write_mac(struct qeth_card card, u8 mac)
142	{	142	{
143	enum qeth_ipa_cmds cmd = is_multicast_ether_addr_64bits(mac) ?	143	enum qeth_ipa_cmds cmd = is_multicast_ether_addr(mac) ?
144	IPA_CMD_SETGMAC : IPA_CMD_SETVMAC;	144	IPA_CMD_SETGMAC : IPA_CMD_SETVMAC;
145	int rc;	145	int rc;
146		146
@@ -157,7 +157,7 @@ static int qeth_l2_write_mac(struct qeth_card card, u8 mac) · 10 unmodified lines
157		157
158	static int qeth_l2_remove_mac(struct qeth_card card, u8 mac)	158	static int qeth_l2_remove_mac(struct qeth_card card, u8 mac)
159	{	159	{
160	enum qeth_ipa_cmds cmd = is_multicast_ether_addr_64bits(mac) ?	160	enum qeth_ipa_cmds cmd = is_multicast_ether_addr(mac) ?
161	IPA_CMD_DELGMAC : IPA_CMD_DELVMAC;	161	IPA_CMD_DELGMAC : IPA_CMD_DELVMAC;
162	int rc;	162	int rc;
163		163
@@ -501,27 +501,34 @@ static int qeth_l2_set_mac_address(struct net_device dev, void p) · 337 unmodified lines
501	return -ERESTARTSYS;	501	return -ERESTARTSYS;
502	}	502	}
503		503
		504	/* avoid racing against concurrent state change: */
		505	if (!mutex_trylock(&card->conf_mutex))
		506	return -EAGAIN;
		507
504	if (!qeth_card_hw_is_reachable(card)) {	508	if (!qeth_card_hw_is_reachable(card)) {
505	ether_addr_copy(dev->dev_addr, addr->sa_data);	509	ether_addr_copy(dev->dev_addr, addr->sa_data);
506	return 0;	510	goto out_unlock;
507	}	511	}
508		512
509	/* don't register the same address twice */	513	/* don't register the same address twice */
510	if (ether_addr_equal_64bits(dev->dev_addr, addr->sa_data) &&	514	if (ether_addr_equal_64bits(dev->dev_addr, addr->sa_data) &&
511	(card->info.mac_bits & QETH_LAYER2_MAC_REGISTERED))	515	(card->info.mac_bits & QETH_LAYER2_MAC_REGISTERED))
512	return 0;	516	goto out_unlock;
513		517
514	/* add the new address, switch over, drop the old */	518	/* add the new address, switch over, drop the old */
515	rc = qeth_l2_send_setmac(card, addr->sa_data);	519	rc = qeth_l2_send_setmac(card, addr->sa_data);
516	if (rc)	520	if (rc)
517	return rc;	521	goto out_unlock;
518	ether_addr_copy(old_addr, dev->dev_addr);	522	ether_addr_copy(old_addr, dev->dev_addr);
519	ether_addr_copy(dev->dev_addr, addr->sa_data);	523	ether_addr_copy(dev->dev_addr, addr->sa_data);
520		524
521	if (card->info.mac_bits & QETH_LAYER2_MAC_REGISTERED)	525	if (card->info.mac_bits & QETH_LAYER2_MAC_REGISTERED)
522	qeth_l2_remove_mac(card, old_addr);	526	qeth_l2_remove_mac(card, old_addr);
523	card->info.mac_bits \|= QETH_LAYER2_MAC_REGISTERED;	527	card->info.mac_bits \|= QETH_LAYER2_MAC_REGISTERED;
524	return 0;	528
		529	out_unlock:
		530	mutex_unlock(&card->conf_mutex);
		531	return rc;
525	}	532	}
526		533
527	static void qeth_promisc_to_bridge(struct qeth_card *card)	534	static void qeth_promisc_to_bridge(struct qeth_card *card)
@@ -1112,6 +1119,8 @@ static int __qeth_l2_set_online(struct ccwgroup_device *gdev, int recovery_mode) · 584 unmodified lines
1112	netif_carrier_off(card->dev);	1119	netif_carrier_off(card->dev);
1113		1120
1114	qeth_set_allowed_threads(card, 0xffffffff, 0);	1121	qeth_set_allowed_threads(card, 0xffffffff, 0);
		1122
		1123	qeth_enable_hw_features(card->dev);
1115	if (recover_flag == CARD_STATE_RECOVER) {	1124	if (recover_flag == CARD_STATE_RECOVER) {
1116	if (recovery_mode &&	1125	if (recovery_mode &&
1117	card->info.type != QETH_CARD_TYPE_OSN) {	1126	card->info.type != QETH_CARD_TYPE_OSN) {
@@ -1123,9 +1132,6 @@ static int __qeth_l2_set_online(struct ccwgroup_device *gdev, int recovery_mode) · 5 unmodified lines
1123	}	1132	}
1124	/* this also sets saved unicast addresses */	1133	/* this also sets saved unicast addresses */
1125	qeth_l2_set_rx_mode(card->dev);	1134	qeth_l2_set_rx_mode(card->dev);
1126	rtnl_lock();
1127	qeth_recover_features(card->dev);
1128	rtnl_unlock();
1129	}	1135	}
1130	/* let user_space know that device is online */	1136	/* let user_space know that device is online */
1131	kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);	1137	kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);

drivers/s390/net/qeth_l3_main.c+2−1

 		netif_carrier_on(card->dev);
 	else
 		netif_carrier_off(card->dev);
+	qeth_enable_hw_features(card->dev);
 	if (recover_flag == CARD_STATE_RECOVER) {
 		rtnl_lock();
 		if (recovery_mode)
 		else
 			dev_open(card->dev);
 		qeth_l3_set_rx_mode(card->dev);
-		qeth_recover_features(card->dev);
 		rtnl_unlock();
 	}
 	qeth_trace_features(card);

drivers/scsi/ipr.c+0−2

 		ioa_cfg->hrrq[i].allow_interrupts = 0;
 		spin_unlock(&ioa_cfg->hrrq[i]._lock);
 	}
-	wmb();
 	/* Set interrupt mask to stop all new interrupts */
 	if (ioa_cfg->sis64)
 		ioa_cfg->hrrq[i].allow_interrupts = 1;
 		spin_unlock(&ioa_cfg->hrrq[i]._lock);
 	}
-	wmb();
 	if (ioa_cfg->sis64) {
 		/* Set the adapter to the correct endian mode. */
 		writel(IPR_ENDIAN_SWAP_KEY, ioa_cfg->regs.endian_swap_reg);

drivers/scsi/qla2xxx/qla_target.c+3−4

 void qlt_schedule_sess_for_deletion(struct fc_port *sess)
 {
 	struct qla_tgt *tgt = sess->tgt;
-	struct qla_hw_data *ha = sess->vha->hw;
 	unsigned long flags;
 	if (sess->disc_state == DSC_DELETE_PEND)
 			return;
 	}
-	spin_lock_irqsave(&ha->tgt.sess_lock, flags);
 	if (sess->deleted == QLA_SESS_DELETED)
 		sess->logout_on_delete = 0;
+	spin_lock_irqsave(&sess->vha->work_lock, flags);
 	if (sess->deleted == QLA_SESS_DELETION_IN_PROGRESS) {
-		spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
+		spin_unlock_irqrestore(&sess->vha->work_lock, flags);
 		return;
 	}
 	sess->deleted = QLA_SESS_DELETION_IN_PROGRESS;
-	spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
+	spin_unlock_irqrestore(&sess->vha->work_lock, flags);
 	sess->disc_state = DSC_DELETE_PEND;

drivers/scsi/scsi_debug.c+1−1

 	int k = sdebug_add_host;
 	stop_all_queued();
-	free_all_queued();
 	for (; k; k--)
 		sdebug_remove_adapter();
+	free_all_queued();
 	driver_unregister(&sdebug_driverfs_driver);
 	bus_unregister(&pseudo_lld_bus);
 	root_device_unregister(pseudo_primary);

drivers/soc/imx/gpcv2.c+9−4

@@ -39,10 +39,15 @@ · 38 unmodified lines
39		39
40	#define GPC_M4_PU_PDN_FLG 0x1bc	40	#define GPC_M4_PU_PDN_FLG 0x1bc
41		41
42		42	/*
43	#define PGC_MIPI 4	43	* The PGC offset values in Reference Manual
44	#define PGC_PCIE 5	44	* (Rev. 1, 01/2018 and the older ones) GPC chapter's
45	#define PGC_USB_HSIC 8	45	* GPC_PGC memory map are incorrect, below offset
		46	* values are from design RTL.
		47	*/
		48	#define PGC_MIPI 16
		49	#define PGC_PCIE 17
		50	#define PGC_USB_HSIC 20
46	#define GPC_PGC_CTRL(n) (0x800 + (n) * 0x40)	51	#define GPC_PGC_CTRL(n) (0x800 + (n) * 0x40)
47	#define GPC_PGC_SR(n) (GPC_PGC_CTRL(n) + 0xc)	52	#define GPC_PGC_SR(n) (GPC_PGC_CTRL(n) + 0xc)
48		53

drivers/soc/qcom/Kconfig+2−1

@@ -5,7 +5,8 @@ menu "Qualcomm SoC drivers" · 4 unmodified lines
5		5
6	config QCOM_COMMAND_DB	6	config QCOM_COMMAND_DB
7	bool "Qualcomm Command DB"	7	bool "Qualcomm Command DB"
8	depends on (ARCH_QCOM && OF) \|\| COMPILE_TEST	8	depends on ARCH_QCOM \|\| COMPILE_TEST
		9	depends on OF_RESERVED_MEM
9	help	10	help
10	Command DB queries shared memory by key string for shared system	11	Command DB queries shared memory by key string for shared system
11	resources. Platform drivers that require to set state of a shared	12	resources. Platform drivers that require to set state of a shared

drivers/soc/renesas/rcar-sysc.c+29−6

 static bool has_cpg_mstp;
-static void __init rcar_sysc_pd_setup(struct rcar_sysc_pd *pd)
+static int __init rcar_sysc_pd_setup(struct rcar_sysc_pd *pd)
 {
 	struct generic_pm_domain *genpd = &pd->genpd;
 	const char *name = pd->genpd.name;
 	struct dev_power_governor *gov = &simple_qos_governor;
+	int error;
 	if (pd->flags & PD_CPU) {
 		/*
 	rcar_sysc_power_up(&pd->ch);
 finalize:
-	pm_genpd_init(genpd, gov, false);
+	error = pm_genpd_init(genpd, gov, false);
+	if (error)
+		pr_err("Failed to init PM domain %s: %d\n", name, error);
+	return error;
 }
 static const struct of_device_id rcar_sysc_matches[] __initconst = {
 	pr_debug("%pOF: syscier = 0x%08x\n", np, syscier);
 	iowrite32(syscier, base + SYSCIER);
+	/*
+	 * First, create all PM domains
+	 */
 	for (i = 0; i < info->num_areas; i++) {
 		const struct rcar_sysc_area *area = &info->areas[i];
 		struct rcar_sysc_pd *pd;
 		pd->ch.isr_bit = area->isr_bit;
 		pd->flags = area->flags;
-		rcar_sysc_pd_setup(pd);
+		error = rcar_sysc_pd_setup(pd);
-		if (area->parent >= 0)
+		if (error)
-			pm_genpd_add_subdomain(domains->domains[area->parent],
+			goto out_put;
-					       &pd->genpd);
 		domains->domains[area->isr_bit] = &pd->genpd;
 	}
+	/*
+	 * Second, link all PM domains to their parents
+	 */
+	for (i = 0; i < info->num_areas; i++) {
+		const struct rcar_sysc_area *area = &info->areas[i];
+		if (!area->name || area->parent < 0)
+			continue;
+		error = pm_genpd_add_subdomain(domains->domains[area->parent],
+					       domains->domains[area->isr_bit]);
+		if (error)
+			pr_warn("Failed to add PM subdomain %s to parent %u\n",
+				area->name, area->parent);
+	}
 	error = of_genpd_add_provider_onecell(np, &domains->onecell_data);
 out_put:

drivers/staging/android/ion/ion_heap.c+1−1

@@ -30,7 +30,7 @@ void ion_heap_map_kernel(struct ion_heap heap, · 29 unmodified lines
30	struct page **tmp = pages;	30	struct page **tmp = pages;
31		31
32	if (!pages)	32	if (!pages)
33	return NULL;	33	return ERR_PTR(-ENOMEM);
34		34
35	if (buffer->flags & ION_FLAG_CACHED)	35	if (buffer->flags & ION_FLAG_CACHED)
36	pgprot = PAGE_KERNEL;	36	pgprot = PAGE_KERNEL;

drivers/staging/comedi/drivers/quatech_daqp_cs.c+1−1

@@ -642,7 +642,7 @@ static int daqp_ao_insn_write(struct comedi_device *dev, · 641 unmodified lines
642	/* Make sure D/A update mode is direct update */	642	/* Make sure D/A update mode is direct update */
643	outb(0, dev->iobase + DAQP_AUX_REG);	643	outb(0, dev->iobase + DAQP_AUX_REG);
644		644
645	for (i = 0; i > insn->n; i++) {	645	for (i = 0; i < insn->n; i++) {
646	unsigned int val = data[i];	646	unsigned int val = data[i];
647	int ret;	647	int ret;
648		648

drivers/staging/typec/Kconfig+1−0

@@ -11,6 +11,7 @@ config TYPEC_TCPCI · 10 unmodified lines
11		11
12	config TYPEC_RT1711H	12	config TYPEC_RT1711H
13	tristate "Richtek RT1711H Type-C chip driver"	13	tristate "Richtek RT1711H Type-C chip driver"
		14	depends on I2C
14	select TYPEC_TCPCI	15	select TYPEC_TCPCI
15	help	16	help
16	Richtek RT1711H Type-C chip driver that works with	17	Richtek RT1711H Type-C chip driver that works with

drivers/target/target_core_user.c+36−8

 }
 static void gather_data_area(struct tcmu_dev *udev, struct tcmu_cmd *cmd,
-			     bool bidi)
+			     bool bidi, uint32_t read_len)
 {
 	struct se_cmd *se_cmd = cmd->se_cmd;
 	int i, dbi;
 	for_each_sg(data_sg, sg, data_nents, i) {
 		int sg_remaining = sg->length;
 		to = kmap_atomic(sg_page(sg)) + sg->offset;
-		while (sg_remaining > 0) {
+		while (sg_remaining > 0 && read_len > 0) {
 			if (block_remaining == 0) {
 				if (from)
 					kunmap_atomic(from);
 			}
 			copy_bytes = min_t(size_t, sg_remaining,
 					block_remaining);
+			if (read_len < copy_bytes)
+				copy_bytes = read_len;
 			offset = DATA_BLOCK_SIZE - block_remaining;
 			tcmu_flush_dcache_range(from, copy_bytes);
 			memcpy(to + sg->length - sg_remaining, from + offset,
 			sg_remaining -= copy_bytes;
 			block_remaining -= copy_bytes;
+			read_len -= copy_bytes;
 		}
 		kunmap_atomic(to - sg->offset);
+		if (read_len == 0)
+			break;
 	}
 	if (from)
 		kunmap_atomic(from);
 {
 	struct se_cmd *se_cmd = cmd->se_cmd;
 	struct tcmu_dev *udev = cmd->tcmu_dev;
+	bool read_len_valid = false;
+	uint32_t read_len = se_cmd->data_length;
 	/*
 	 * cmd has been completed already from timeout, just reclaim
 		pr_warn("TCMU: Userspace set UNKNOWN_OP flag on se_cmd %p\n",
 			cmd->se_cmd);
 		entry->rsp.scsi_status = SAM_STAT_CHECK_CONDITION;
-	} else if (entry->rsp.scsi_status == SAM_STAT_CHECK_CONDITION) {
+		goto done;
+	}
+	if (se_cmd->data_direction == DMA_FROM_DEVICE &&
+	    (entry->hdr.uflags & TCMU_UFLAG_READ_LEN) && entry->rsp.read_len) {
+		read_len_valid = true;
+		if (entry->rsp.read_len < read_len)
+			read_len = entry->rsp.read_len;
+	}
+	if (entry->rsp.scsi_status == SAM_STAT_CHECK_CONDITION) {
 		transport_copy_sense_to_cmd(se_cmd, entry->rsp.sense_buffer);
-	} else if (se_cmd->se_cmd_flags & SCF_BIDI) {
+		if (!read_len_valid )
+			goto done;
+		else
+			se_cmd->se_cmd_flags |= SCF_TREAT_READ_AS_NORMAL;
+	}
+	if (se_cmd->se_cmd_flags & SCF_BIDI) {
 		/* Get Data-In buffer before clean up */
-		gather_data_area(udev, cmd, true);
+		gather_data_area(udev, cmd, true, read_len);
 	} else if (se_cmd->data_direction == DMA_FROM_DEVICE) {
-		gather_data_area(udev, cmd, false);
+		gather_data_area(udev, cmd, false, read_len);
 	} else if (se_cmd->data_direction == DMA_TO_DEVICE) {
 		/* TODO: */
 	} else if (se_cmd->data_direction != DMA_NONE) {
 			se_cmd->data_direction);
 	}
-	target_complete_cmd(cmd->se_cmd, entry->rsp.scsi_status);
+done:
+	if (read_len_valid) {
+		pr_debug("read_len = %d\n", read_len);
+		target_complete_cmd_with_length(cmd->se_cmd,
+					entry->rsp.scsi_status, read_len);
+	} else
+		target_complete_cmd(cmd->se_cmd, entry->rsp.scsi_status);
 out:
 	cmd->se_cmd = NULL;
 	/* Initialise the mailbox of the ring buffer */
 	mb = udev->mb_addr;
 	mb->version = TCMU_MAILBOX_VERSION;
-	mb->flags = TCMU_MAILBOX_FLAG_CAP_OOOC;
+	mb->flags = TCMU_MAILBOX_FLAG_CAP_OOOC | TCMU_MAILBOX_FLAG_CAP_READ_LEN;
 	mb->cmdr_off = CMDR_OFF;
 	mb->cmdr_size = udev->cmdr_size;

drivers/tty/n_tty.c+32−23

 	struct mutex output_lock;
 };
+#define MASK(x) ((x) & (N_TTY_BUF_SIZE - 1))
 static inline size_t read_cnt(struct n_tty_data *ldata)
 {
 	return ldata->read_head - ldata->read_tail;
 static inline unsigned char echo_buf(struct n_tty_data *ldata, size_t i)
 {
+	smp_rmb(); /* Matches smp_wmb() in add_echo_byte(). */
 	return ldata->echo_buf[i & (N_TTY_BUF_SIZE - 1)];
 }
 static void reset_buffer_flags(struct n_tty_data *ldata)
 {
 	ldata->read_head = ldata->canon_head = ldata->read_tail = 0;
-	ldata->echo_head = ldata->echo_tail = ldata->echo_commit = 0;
 	ldata->commit_head = 0;
-	ldata->echo_mark = 0;
 	ldata->line_start = 0;
 	ldata->erasing = 0;
 	old_space = space = tty_write_room(tty);
 	tail = ldata->echo_tail;
-	while (ldata->echo_commit != tail) {
+	while (MASK(ldata->echo_commit) != MASK(tail)) {
 		c = echo_buf(ldata, tail);
 		if (c == ECHO_OP_START) {
 			unsigned char op;
 			int no_space_left = 0;
+			/*
+			 * Since add_echo_byte() is called without holding
+			 * output_lock, we might see only portion of multi-byte
+			 * operation.
+			 */
+			if (MASK(ldata->echo_commit) == MASK(tail + 1))
+				goto not_yet_stored;
 			/*
 			 * If the buffer byte is the start of a multi-byte
 			 * operation, get the next byte, which is either the
 				unsigned int num_chars, num_bs;
 			case ECHO_OP_ERASE_TAB:
+				if (MASK(ldata->echo_commit) == MASK(tail + 2))
+					goto not_yet_stored;
 				num_chars = echo_buf(ldata, tail + 2);
 				/*
 	/* If the echo buffer is nearly full (so that the possibility exists
 	 * of echo overrun before the next commit), then discard enough
 	 * data at the tail to prevent a subsequent overrun */
-	while (ldata->echo_commit - tail >= ECHO_DISCARD_WATERMARK) {
+	while (ldata->echo_commit > tail &&
+	       ldata->echo_commit - tail >= ECHO_DISCARD_WATERMARK) {
 		if (echo_buf(ldata, tail) == ECHO_OP_START) {
 			if (echo_buf(ldata, tail + 1) == ECHO_OP_ERASE_TAB)
 				tail += 3;
 			tail++;
 	}
+ not_yet_stored:
 	ldata->echo_tail = tail;
 	return old_space - space;
 }
 	size_t nr, old, echoed;
 	size_t head;
+	mutex_lock(&ldata->output_lock);
 	head = ldata->echo_head;
 	ldata->echo_mark = head;
 	old = ldata->echo_commit - ldata->echo_tail;
 	 * is over the threshold (and try again each time another
 	 * block is accumulated) */
 	nr = head - ldata->echo_tail;
-	if (nr < ECHO_COMMIT_WATERMARK || (nr % ECHO_BLOCK > old % ECHO_BLOCK))
+	if (nr < ECHO_COMMIT_WATERMARK ||
+	    (nr % ECHO_BLOCK > old % ECHO_BLOCK)) {
+		mutex_unlock(&ldata->output_lock);
 		return;
+	}
-	mutex_lock(&ldata->output_lock);
 	ldata->echo_commit = head;
 	echoed = __process_echoes(tty);
 	mutex_unlock(&ldata->output_lock);
 static inline void add_echo_byte(unsigned char c, struct n_tty_data *ldata)
 {
-	*echo_buf_addr(ldata, ldata->echo_head++) = c;
+	*echo_buf_addr(ldata, ldata->echo_head) = c;
+	smp_wmb(); /* Matches smp_rmb() in echo_buf(). */
+	ldata->echo_head++;
 }
 /**
 	}
 	seen_alnums = 0;
-	while (ldata->read_head != ldata->canon_head) {
+	while (MASK(ldata->read_head) != MASK(ldata->canon_head)) {
 		head = ldata->read_head;
 		/* erase a single possibly multibyte character */
 		do {
 			head--;
 			c = read_buf(ldata, head);
-		} while (is_continuation(c, tty) && head != ldata->canon_head);
+		} while (is_continuation(c, tty) &&
+			 MASK(head) != MASK(ldata->canon_head));
 		/* do not partially erase */
 		if (is_continuation(c, tty))
 				 * This info is used to go back the correct
 				 * number of columns.
 				 */
-				while (tail != ldata->canon_head) {
+				while (MASK(tail) != MASK(ldata->canon_head)) {
 					tail--;
 					c = read_buf(ldata, tail);
 					if (c == '\t') {
 			finish_erasing(ldata);
 			echo_char(c, tty);
 			echo_char_raw('\n', ldata);
-			while (tail != ldata->read_head) {
+			while (MASK(tail) != MASK(ldata->read_head)) {
 				echo_char(read_buf(ldata, tail), tty);
 				tail++;
 			}
 	struct n_tty_data *ldata;
 	/* Currently a malloc failure here can panic */
-	ldata = vmalloc(sizeof(*ldata));
+	ldata = vzalloc(sizeof(*ldata));
 	if (!ldata)
-		goto err;
+		return -ENOMEM;
 	ldata->overrun_time = jiffies;
 	mutex_init(&ldata->atomic_read_lock);
 	mutex_init(&ldata->output_lock);
 	tty->disc_data = ldata;
-	reset_buffer_flags(tty->disc_data);
-	ldata->column = 0;
-	ldata->canon_column = 0;
-	ldata->num_overrun = 0;
-	ldata->no_room = 0;
-	ldata->lnext = 0;
 	tty->closing = 0;
 	/* indicate buffer work may resume */
 	clear_bit(TTY_LDISC_HALTED, &tty->flags);
 	n_tty_set_termios(tty, NULL);
 	tty_unthrottle(tty);
 	return 0;
-err:
-	return -ENOMEM;
 }
 static inline int input_available_p(struct tty_struct *tty, int poll)
 	tail = ldata->read_tail;
 	nr = head - tail;
 	/* Skip EOF-chars.. */
-	while (head != tail) {
+	while (MASK(head) != MASK(tail)) {
 		if (test_bit(tail & (N_TTY_BUF_SIZE - 1), ldata->read_flags) &&
 		    read_buf(ldata, tail) == __DISABLED_CHAR)
 			nr--;

drivers/tty/serdev/core.c+1−0

@@ -617,6 +617,7 @@ EXPORT_SYMBOL_GPL(__serdev_device_driver_register); · 616 unmodified lines
617	static void __exit serdev_exit(void)	617	static void __exit serdev_exit(void)
618	{	618	{
619	bus_unregister(&serdev_bus_type);	619	bus_unregister(&serdev_bus_type);
		620	ida_destroy(&ctrl_ida);
620	}	621	}
621	module_exit(serdev_exit);	622	module_exit(serdev_exit);
622		623

drivers/tty/serial/8250/8250_pci.c+0−2

 	/* multi-io cards handled by parport_serial */
 	{ PCI_DEVICE(0x4348, 0x7053), }, /* WCH CH353 2S1P */
 	{ PCI_DEVICE(0x4348, 0x5053), }, /* WCH CH353 1S1P */
-	{ PCI_DEVICE(0x4348, 0x7173), }, /* WCH CH355 4S */
 	{ PCI_DEVICE(0x1c00, 0x3250), }, /* WCH CH382 2S1P */
-	{ PCI_DEVICE(0x1c00, 0x3470), }, /* WCH CH384 4S */
 	/* Moxa Smartio MUE boards handled by 8250_moxa */
 	{ PCI_VDEVICE(MOXA, 0x1024), },

drivers/tty/vt/vt.c+2−2

@@ -784,7 +784,7 @@ int vc_allocate(unsigned int currcons) /* return 0 on success */ · 783 unmodified lines
784	if (!*vc->vc_uni_pagedir_loc)	784	if (!*vc->vc_uni_pagedir_loc)
785	con_set_default_unimap(vc);	785	con_set_default_unimap(vc);
786		786
787	vc->vc_screenbuf = kmalloc(vc->vc_screenbuf_size, GFP_KERNEL);	787	vc->vc_screenbuf = kzalloc(vc->vc_screenbuf_size, GFP_KERNEL);
788	if (!vc->vc_screenbuf)	788	if (!vc->vc_screenbuf)
789	goto err_free;	789	goto err_free;
790		790
@@ -871,7 +871,7 @@ static int vc_do_resize(struct tty_struct tty, struct vc_data vc, · 80 unmodified lines
871		871
872	if (new_screen_size > (4 << 20))	872	if (new_screen_size > (4 << 20))
873	return -EINVAL;	873	return -EINVAL;
874	newscreen = kmalloc(new_screen_size, GFP_USER);	874	newscreen = kzalloc(new_screen_size, GFP_USER);
875	if (!newscreen)	875	if (!newscreen)
876	return -ENOMEM;	876	return -ENOMEM;
877		877

drivers/usb/chipidea/host.c+4−1

 	hcd->power_budget = ci->platdata->power_budget;
 	hcd->tpl_support = ci->platdata->tpl_support;
-	if (ci->phy || ci->usb_phy)
+	if (ci->phy || ci->usb_phy) {
 		hcd->skip_phy_initialization = 1;
+		if (ci->usb_phy)
+			hcd->usb_phy = ci->usb_phy;
+	}
 	ehci = hcd_to_ehci(hcd);
 	ehci->caps = ci->hw_bank.cap;

drivers/usb/class/cdc-acm.c+3−0

 	{ USB_DEVICE(0x11ca, 0x0201), /* VeriFone Mx870 Gadget Serial */
 	.driver_info = SINGLE_RX_URB,
 	},
+	{ USB_DEVICE(0x1965, 0x0018), /* Uniden UBC125XLT */
+	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
+	},
 	{ USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
 	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
 	},

drivers/usb/dwc2/core.h+3−0

  * @frame_list_sz:      Frame list size
  * @desc_gen_cache:     Kmem cache for generic descriptors
  * @desc_hsisoc_cache:  Kmem cache for hs isochronous descriptors
+ * @unaligned_cache:    Kmem cache for DMA mode to handle non-aligned buf
  *
  * These are for peripheral mode:
  *
 	u32 frame_list_sz;
 	struct kmem_cache *desc_gen_cache;
 	struct kmem_cache *desc_hsisoc_cache;
+	struct kmem_cache *unaligned_cache;
+#define DWC2_KMEM_UNALIGNED_BUF_SIZE 1024
 #endif /* CONFIG_USB_DWC2_HOST || CONFIG_USB_DWC2_DUAL_ROLE */

drivers/usb/dwc2/gadget.c+12−8

@@ -812,6 +812,7 @@ static int dwc2_gadget_fill_isoc_desc(struct dwc2_hsotg_ep *hs_ep, · 811 unmodified lines
812	u32 index;	812	u32 index;
813	u32 maxsize = 0;	813	u32 maxsize = 0;
814	u32 mask = 0;	814	u32 mask = 0;
		815	u8 pid = 0;
815		816
816	maxsize = dwc2_gadget_get_desc_params(hs_ep, &mask);	817	maxsize = dwc2_gadget_get_desc_params(hs_ep, &mask);
817		818
@@ -840,7 +841,11 @@ static int dwc2_gadget_fill_isoc_desc(struct dwc2_hsotg_ep *hs_ep, · 22 unmodified lines
840	((len << DEV_DMA_NBYTES_SHIFT) & mask));	841	((len << DEV_DMA_NBYTES_SHIFT) & mask));
841		842
842	if (hs_ep->dir_in) {	843	if (hs_ep->dir_in) {
843	desc->status \|= ((hs_ep->mc << DEV_DMA_ISOC_PID_SHIFT) &	844	if (len)
		845	pid = DIV_ROUND_UP(len, hs_ep->ep.maxpacket);
		846	else
		847	pid = 1;
		848	desc->status \|= ((pid << DEV_DMA_ISOC_PID_SHIFT) &
844	DEV_DMA_ISOC_PID_MASK) \|	849	DEV_DMA_ISOC_PID_MASK) \|
845	((len % hs_ep->ep.maxpacket) ?	850	((len % hs_ep->ep.maxpacket) ?
846	DEV_DMA_SHORT : 0) \|	851	DEV_DMA_SHORT : 0) \|
@@ -884,6 +889,7 @@ static void dwc2_gadget_start_isoc_ddma(struct dwc2_hsotg_ep *hs_ep) · 37 unmodified lines
884	struct dwc2_dma_desc *desc;	889	struct dwc2_dma_desc *desc;
885		890
886	if (list_empty(&hs_ep->queue)) {	891	if (list_empty(&hs_ep->queue)) {
		892	hs_ep->target_frame = TARGET_FRAME_INITIAL;
887	dev_dbg(hsotg->dev, "%s: No requests in queue\n", __func__);	893	dev_dbg(hsotg->dev, "%s: No requests in queue\n", __func__);
888	return;	894	return;
889	}	895	}
@@ -2755,8 +2761,6 @@ static void dwc2_gadget_handle_out_token_ep_disabled(struct dwc2_hsotg_ep *ep) · 1865 unmodified lines
2755	*/	2761	*/
2756	tmp = dwc2_hsotg_read_frameno(hsotg);	2762	tmp = dwc2_hsotg_read_frameno(hsotg);
2757		2763
2758	dwc2_hsotg_complete_request(hsotg, ep, get_ep_head(ep), 0);
2759
2760	if (using_desc_dma(hsotg)) {	2764	if (using_desc_dma(hsotg)) {
2761	if (ep->target_frame == TARGET_FRAME_INITIAL) {	2765	if (ep->target_frame == TARGET_FRAME_INITIAL) {
2762	/* Start first ISO Out */	2766	/* Start first ISO Out */
@@ -2817,9 +2821,6 @@ static void dwc2_gadget_handle_nak(struct dwc2_hsotg_ep *hs_ep) · 54 unmodified lines
2817		2821
2818	tmp = dwc2_hsotg_read_frameno(hsotg);	2822	tmp = dwc2_hsotg_read_frameno(hsotg);
2819	if (using_desc_dma(hsotg)) {	2823	if (using_desc_dma(hsotg)) {
2820	dwc2_hsotg_complete_request(hsotg, hs_ep,
2821	get_ep_head(hs_ep), 0);
2822
2823	hs_ep->target_frame = tmp;	2824	hs_ep->target_frame = tmp;
2824	dwc2_gadget_incr_frame_num(hs_ep);	2825	dwc2_gadget_incr_frame_num(hs_ep);
2825	dwc2_gadget_start_isoc_ddma(hs_ep);	2826	dwc2_gadget_start_isoc_ddma(hs_ep);
@@ -4739,9 +4740,11 @@ int dwc2_gadget_init(struct dwc2_hsotg *hsotg) · 1913 unmodified lines
4739	}	4740	}
4740		4741
4741	ret = usb_add_gadget_udc(dev, &hsotg->gadget);	4742	ret = usb_add_gadget_udc(dev, &hsotg->gadget);
4742	if (ret)	4743	if (ret) {
		4744	dwc2_hsotg_ep_free_request(&hsotg->eps_out[0]->ep,
		4745	hsotg->ctrl_req);
4743	return ret;	4746	return ret;
4744		4747	}
4745	dwc2_hsotg_dump(hsotg);	4748	dwc2_hsotg_dump(hsotg);
4746		4749
4747	return 0;	4750	return 0;
@@ -4755,6 +4758,7 @@ int dwc2_gadget_init(struct dwc2_hsotg *hsotg) · 7 unmodified lines
4755	int dwc2_hsotg_remove(struct dwc2_hsotg *hsotg)	4758	int dwc2_hsotg_remove(struct dwc2_hsotg *hsotg)
4756	{	4759	{
4757	usb_del_gadget_udc(&hsotg->gadget);	4760	usb_del_gadget_udc(&hsotg->gadget);
		4761	dwc2_hsotg_ep_free_request(&hsotg->eps_out[0]->ep, hsotg->ctrl_req);
4758		4762
4759	return 0;	4763	return 0;
4760	}	4764	}

drivers/usb/dwc2/hcd.c+87−6

@@ -1567,11 +1567,20 @@ static void dwc2_hc_start_transfer(struct dwc2_hsotg *hsotg, · 1566 unmodified lines
1567	}	1567	}
1568		1568
1569	if (hsotg->params.host_dma) {	1569	if (hsotg->params.host_dma) {
1570	dwc2_writel((u32)chan->xfer_dma,	1570	dma_addr_t dma_addr;
1571	hsotg->regs + HCDMA(chan->hc_num));	1571
		1572	if (chan->align_buf) {
		1573	if (dbg_hc(chan))
		1574	dev_vdbg(hsotg->dev, "align_buf\n");
		1575	dma_addr = chan->align_buf;
		1576	} else {
		1577	dma_addr = chan->xfer_dma;
		1578	}
		1579	dwc2_writel((u32)dma_addr, hsotg->regs + HCDMA(chan->hc_num));
		1580
1572	if (dbg_hc(chan))	1581	if (dbg_hc(chan))
1573	dev_vdbg(hsotg->dev, "Wrote %08lx to HCDMA(%d)\n",	1582	dev_vdbg(hsotg->dev, "Wrote %08lx to HCDMA(%d)\n",
1574	(unsigned long)chan->xfer_dma, chan->hc_num);	1583	(unsigned long)dma_addr, chan->hc_num);
1575	}	1584	}
1576		1585
1577	/* Start the split */	1586	/* Start the split */
@@ -2625,6 +2634,35 @@ static void dwc2_hc_init_xfer(struct dwc2_hsotg *hsotg, · 1047 unmodified lines
2625	}	2634	}
2626	}	2635	}
2627		2636
		2637	static int dwc2_alloc_split_dma_aligned_buf(struct dwc2_hsotg *hsotg,
		2638	struct dwc2_qh *qh,
		2639	struct dwc2_host_chan *chan)
		2640	{
		2641	if (!hsotg->unaligned_cache \|\|
		2642	chan->max_packet > DWC2_KMEM_UNALIGNED_BUF_SIZE)
		2643	return -ENOMEM;
		2644
		2645	if (!qh->dw_align_buf) {
		2646	qh->dw_align_buf = kmem_cache_alloc(hsotg->unaligned_cache,
		2647	GFP_ATOMIC \| GFP_DMA);
		2648	if (!qh->dw_align_buf)
		2649	return -ENOMEM;
		2650	}
		2651
		2652	qh->dw_align_buf_dma = dma_map_single(hsotg->dev, qh->dw_align_buf,
		2653	DWC2_KMEM_UNALIGNED_BUF_SIZE,
		2654	DMA_FROM_DEVICE);
		2655
		2656	if (dma_mapping_error(hsotg->dev, qh->dw_align_buf_dma)) {
		2657	dev_err(hsotg->dev, "can't map align_buf\n");
		2658	chan->align_buf = 0;
		2659	return -EINVAL;
		2660	}
		2661
		2662	chan->align_buf = qh->dw_align_buf_dma;
		2663	return 0;
		2664	}
		2665
2628	#define DWC2_USB_DMA_ALIGN 4	2666	#define DWC2_USB_DMA_ALIGN 4
2629		2667
2630	struct dma_aligned_buffer {	2668	struct dma_aligned_buffer {
@@ -2802,6 +2840,32 @@ static int dwc2_assign_and_init_hc(struct dwc2_hsotg hsotg, struct dwc2_qh qh) · 171 unmodified lines
2802	/* Set the transfer attributes */	2840	/* Set the transfer attributes */
2803	dwc2_hc_init_xfer(hsotg, chan, qtd);	2841	dwc2_hc_init_xfer(hsotg, chan, qtd);
2804		2842
		2843	/* For non-dword aligned buffers */
		2844	if (hsotg->params.host_dma && qh->do_split &&
		2845	chan->ep_is_in && (chan->xfer_dma & 0x3)) {
		2846	dev_vdbg(hsotg->dev, "Non-aligned buffer\n");
		2847	if (dwc2_alloc_split_dma_aligned_buf(hsotg, qh, chan)) {
		2848	dev_err(hsotg->dev,
		2849	"Failed to allocate memory to handle non-aligned buffer\n");
		2850	/* Add channel back to free list */
		2851	chan->align_buf = 0;
		2852	chan->multi_count = 0;
		2853	list_add_tail(&chan->hc_list_entry,
		2854	&hsotg->free_hc_list);
		2855	qtd->in_process = 0;
		2856	qh->channel = NULL;
		2857	return -ENOMEM;
		2858	}
		2859	} else {
		2860	/*
		2861	* We assume that DMA is always aligned in non-split
		2862	* case or split out case. Warn if not.
		2863	*/
		2864	WARN_ON_ONCE(hsotg->params.host_dma &&
		2865	(chan->xfer_dma & 0x3));
		2866	chan->align_buf = 0;
		2867	}
		2868
2805	if (chan->ep_type == USB_ENDPOINT_XFER_INT \|\|	2869	if (chan->ep_type == USB_ENDPOINT_XFER_INT \|\|
2806	chan->ep_type == USB_ENDPOINT_XFER_ISOC)	2870	chan->ep_type == USB_ENDPOINT_XFER_ISOC)
2807	/*	2871	/*
@@ -5246,6 +5310,19 @@ int dwc2_hcd_init(struct dwc2_hsotg *hsotg) · 2438 unmodified lines
5246	}	5310	}
5247	}	5311	}
5248		5312
		5313	if (hsotg->params.host_dma) {
		5314	/*
		5315	* Create kmem caches to handle non-aligned buffer
		5316	* in Buffer DMA mode.
		5317	*/
		5318	hsotg->unaligned_cache = kmem_cache_create("dwc2-unaligned-dma",
		5319	DWC2_KMEM_UNALIGNED_BUF_SIZE, 4,
		5320	SLAB_CACHE_DMA, NULL);
		5321	if (!hsotg->unaligned_cache)
		5322	dev_err(hsotg->dev,
		5323	"unable to create dwc2 unaligned cache\n");
		5324	}
		5325
5249	hsotg->otg_port = 1;	5326	hsotg->otg_port = 1;
5250	hsotg->frame_list = NULL;	5327	hsotg->frame_list = NULL;
5251	hsotg->frame_list_dma = 0;	5328	hsotg->frame_list_dma = 0;
@@ -5280,8 +5357,9 @@ int dwc2_hcd_init(struct dwc2_hsotg *hsotg) · 28 unmodified lines
5280	return 0;	5357	return 0;
5281		5358
5282	error4:	5359	error4:
5283	kmem_cache_destroy(hsotg->desc_gen_cache);	5360	kmem_cache_destroy(hsotg->unaligned_cache);
5284	kmem_cache_destroy(hsotg->desc_hsisoc_cache);	5361	kmem_cache_destroy(hsotg->desc_hsisoc_cache);
		5362	kmem_cache_destroy(hsotg->desc_gen_cache);
5285	error3:	5363	error3:
5286	dwc2_hcd_release(hsotg);	5364	dwc2_hcd_release(hsotg);
5287	error2:	5365	error2:
@@ -5322,8 +5400,9 @@ void dwc2_hcd_remove(struct dwc2_hsotg *hsotg) · 34 unmodified lines
5322	usb_remove_hcd(hcd);	5400	usb_remove_hcd(hcd);
5323	hsotg->priv = NULL;	5401	hsotg->priv = NULL;
5324		5402
5325	kmem_cache_destroy(hsotg->desc_gen_cache);	5403	kmem_cache_destroy(hsotg->unaligned_cache);
5326	kmem_cache_destroy(hsotg->desc_hsisoc_cache);	5404	kmem_cache_destroy(hsotg->desc_hsisoc_cache);
		5405	kmem_cache_destroy(hsotg->desc_gen_cache);
5327		5406
5328	dwc2_hcd_release(hsotg);	5407	dwc2_hcd_release(hsotg);
5329	usb_put_hcd(hcd);	5408	usb_put_hcd(hcd);
@@ -5435,7 +5514,7 @@ int dwc2_host_enter_hibernation(struct dwc2_hsotg *hsotg) · 105 unmodified lines
5435	dwc2_writel(hprt0, hsotg->regs + HPRT0);	5514	dwc2_writel(hprt0, hsotg->regs + HPRT0);
5436		5515
5437	/* Wait for the HPRT0.PrtSusp register field to be set */	5516	/* Wait for the HPRT0.PrtSusp register field to be set */
5438	if (dwc2_hsotg_wait_bit_set(hsotg, HPRT0, HPRT0_SUSP, 300))	5517	if (dwc2_hsotg_wait_bit_set(hsotg, HPRT0, HPRT0_SUSP, 3000))
5439	dev_warn(hsotg->dev, "Suspend wasn't generated\n");	5518	dev_warn(hsotg->dev, "Suspend wasn't generated\n");
5440		5519
5441	/*	5520	/*
@@ -5616,6 +5695,8 @@ int dwc2_host_exit_hibernation(struct dwc2_hsotg *hsotg, int rem_wakeup, · 174 unmodified lines
5616	return ret;	5695	return ret;
5617	}	5696	}
5618		5697
		5698	dwc2_hcd_rem_wakeup(hsotg);
		5699
5619	hsotg->hibernated = 0;	5700	hsotg->hibernated = 0;
5620	hsotg->bus_suspended = 0;	5701	hsotg->bus_suspended = 0;
5621	hsotg->lx_state = DWC2_L0;	5702	hsotg->lx_state = DWC2_L0;

drivers/usb/dwc2/hcd.h+8−0

  *                      (micro)frame
  * @xfer_buf:           Pointer to current transfer buffer position
  * @xfer_dma:           DMA address of xfer_buf
+ * @align_buf:          In Buffer DMA mode this will be used if xfer_buf is not
+ *                      DWORD aligned
  * @xfer_len:           Total number of bytes to transfer
  * @xfer_count:         Number of bytes transferred so far
  * @start_pkt_count:    Packet count at start of transfer
 	u8 *xfer_buf;
 	dma_addr_t xfer_dma;
+	dma_addr_t align_buf;
 	u32 xfer_len;
 	u32 xfer_count;
 	u16 start_pkt_count;
  *                           speed.  Note that this is in "schedule slice" which
  *                           is tightly packed.
  * @ntd:                Actual number of transfer descriptors in a list
+ * @dw_align_buf:       Used instead of original buffer if its physical address
+ *                      is not dword-aligned
+ * @dw_align_buf_dma:   DMA address for dw_align_buf
  * @qtd_list:           List of QTDs for this QH
  * @channel:            Host channel currently processing transfers for this QH
  * @qh_list_entry:      Entry for QH in either the periodic or non-periodic
 	struct dwc2_hs_transfer_time hs_transfers[DWC2_HS_SCHEDULE_UFRAMES];
 	u32 ls_start_schedule_slice;
 	u16 ntd;
+	u8 *dw_align_buf;
+	dma_addr_t dw_align_buf_dma;
 	struct list_head qtd_list;
 	struct dwc2_host_chan *channel;
 	struct list_head qh_list_entry;

drivers/usb/dwc2/hcd_intr.c+9−2

 	frame_desc = &qtd->urb->iso_descs[qtd->isoc_frame_index];
 	len = dwc2_get_actual_xfer_length(hsotg, chan, chnum, qtd,
 					  DWC2_HC_XFER_COMPLETE, NULL);
-	if (!len) {
+	if (!len && !qtd->isoc_split_offset) {
 		qtd->complete_split = 0;
-		qtd->isoc_split_offset = 0;
 		return 0;
 	}
 	frame_desc->actual_length += len;
+	if (chan->align_buf) {
+		dev_vdbg(hsotg->dev, "non-aligned buffer\n");
+		dma_unmap_single(hsotg->dev, chan->qh->dw_align_buf_dma,
+				 DWC2_KMEM_UNALIGNED_BUF_SIZE, DMA_FROM_DEVICE);
+		memcpy(qtd->urb->buf + (chan->xfer_dma - qtd->urb->dma),
+		       chan->qh->dw_align_buf, len);
+	}
 	qtd->isoc_split_offset += len;
 	hctsiz = dwc2_readl(hsotg->regs + HCTSIZ(chnum));

drivers/usb/dwc2/hcd_queue.c+4−1

 	/* Get the map and adjust if this is a multi_tt hub */
 	map = qh->dwc_tt->periodic_bitmaps;
 	if (qh->dwc_tt->usb_tt->multi)
-		map += DWC2_ELEMENTS_PER_LS_BITMAP * qh->ttport;
+		map += DWC2_ELEMENTS_PER_LS_BITMAP * (qh->ttport - 1);
 	return map;
 }
 	if (qh->desc_list)
 		dwc2_hcd_qh_free_ddma(hsotg, qh);
+	else if (hsotg->unaligned_cache && qh->dw_align_buf)
+		kmem_cache_free(hsotg->unaligned_cache, qh->dw_align_buf);
 	kfree(qh);
 }

drivers/usb/dwc3/core.c+13−10

@@ -1272,7 +1272,6 @@ static int dwc3_probe(struct platform_device *pdev) · 1271 unmodified lines
1272	if (!dwc->clks)	1272	if (!dwc->clks)
1273	return -ENOMEM;	1273	return -ENOMEM;
1274		1274
1275	dwc->num_clks = ARRAY_SIZE(dwc3_core_clks);
1276	dwc->dev = dev;	1275	dwc->dev = dev;
1277		1276
1278	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);	1277	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -1307,15 +1306,19 @@ static int dwc3_probe(struct platform_device *pdev) · 28 unmodified lines
1307	if (IS_ERR(dwc->reset))	1306	if (IS_ERR(dwc->reset))
1308	return PTR_ERR(dwc->reset);	1307	return PTR_ERR(dwc->reset);
1309		1308
1310	ret = clk_bulk_get(dev, dwc->num_clks, dwc->clks);	1309	if (dev->of_node) {
1311	if (ret == -EPROBE_DEFER)	1310	dwc->num_clks = ARRAY_SIZE(dwc3_core_clks);
1312	return ret;	1311
1313	/*	1312	ret = clk_bulk_get(dev, dwc->num_clks, dwc->clks);
1314	* Clocks are optional, but new DT platforms should support all clocks	1313	if (ret == -EPROBE_DEFER)
1315	* as required by the DT-binding.	1314	return ret;
1316	*/	1315	/*
1317	if (ret)	1316	* Clocks are optional, but new DT platforms should support all
1318	dwc->num_clks = 0;	1317	* clocks as required by the DT-binding.
		1318	*/
		1319	if (ret)
		1320	dwc->num_clks = 0;
		1321	}
1319		1322
1320	ret = reset_control_deassert(dwc->reset);	1323	ret = reset_control_deassert(dwc->reset);
1321	if (ret)	1324	if (ret)

drivers/usb/dwc3/dwc3-of-simple.c+2−1

@@ -165,8 +165,9 @@ static int dwc3_of_simple_remove(struct platform_device *pdev) · 164 unmodified lines
165		165
166	reset_control_put(simple->resets);	166	reset_control_put(simple->resets);
167		167
168	pm_runtime_put_sync(dev);
169	pm_runtime_disable(dev);	168	pm_runtime_disable(dev);
		169	pm_runtime_put_noidle(dev);
		170	pm_runtime_set_suspended(dev);
170		171
171	return 0;	172	return 0;
172	}	173	}

drivers/usb/dwc3/dwc3-pci.c+2−0

 #define PCI_DEVICE_ID_INTEL_GLK			0x31aa
 #define PCI_DEVICE_ID_INTEL_CNPLP		0x9dee
 #define PCI_DEVICE_ID_INTEL_CNPH		0xa36e
+#define PCI_DEVICE_ID_INTEL_ICLLP		0x34ee
 #define PCI_INTEL_BXT_DSM_GUID		"732b85d5-b7a7-4a1b-9ba0-4bbd00ffd511"
 #define PCI_INTEL_BXT_FUNC_PMU_PWR	4
 	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_GLK), },
 	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_CNPLP), },
 	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_CNPH), },
+	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICLLP), },
 	{ PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_NL_USB), },
 	{  }	/* Terminating Entry */
 };

drivers/usb/dwc3/dwc3-qcom.c+5−8

 	qcom->dwc3 = of_find_device_by_node(dwc3_np);
 	if (!qcom->dwc3) {
 		dev_err(&pdev->dev, "failed to get dwc3 platform device\n");
+		ret = -ENODEV;
 		goto depopulate;
 	}
 	return 0;
 }
-#ifdef CONFIG_PM_SLEEP
+static int __maybe_unused dwc3_qcom_pm_suspend(struct device *dev)
-static int dwc3_qcom_pm_suspend(struct device *dev)
 {
 	struct dwc3_qcom *qcom = dev_get_drvdata(dev);
 	int ret = 0;
 	return ret;
 }
-static int dwc3_qcom_pm_resume(struct device *dev)
+static int __maybe_unused dwc3_qcom_pm_resume(struct device *dev)
 {
 	struct dwc3_qcom *qcom = dev_get_drvdata(dev);
 	int ret;
 	return ret;
 }
-#endif
-#ifdef CONFIG_PM
+static int __maybe_unused dwc3_qcom_runtime_suspend(struct device *dev)
-static int dwc3_qcom_runtime_suspend(struct device *dev)
 {
 	struct dwc3_qcom *qcom = dev_get_drvdata(dev);
 	return dwc3_qcom_suspend(qcom);
 }
-static int dwc3_qcom_runtime_resume(struct device *dev)
+static int __maybe_unused dwc3_qcom_runtime_resume(struct device *dev)
 {
 	struct dwc3_qcom *qcom = dev_get_drvdata(dev);
 	return dwc3_qcom_resume(qcom);
 }
-#endif
 static const struct dev_pm_ops dwc3_qcom_dev_pm_ops = {
 	SET_SYSTEM_SLEEP_PM_OPS(dwc3_qcom_pm_suspend, dwc3_qcom_pm_resume)

drivers/usb/gadget/composite.c+3−0

 		 */
 		if (w_value && !f->get_alt)
 			break;
+		spin_lock(&cdev->lock);
 		value = f->set_alt(f, w_index, w_value);
 		if (value == USB_GADGET_DELAYED_STATUS) {
 			DBG(cdev,
 			DBG(cdev, "delayed_status count %d\n",
 					cdev->delayed_status);
 		}
+		spin_unlock(&cdev->lock);
 		break;
 	case USB_REQ_GET_INTERFACE:
 		if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE))

drivers/usb/gadget/function/f_fs.c+18−8

@@ -215,6 +215,7 @@ struct ffs_io_data { · 214 unmodified lines
215		215
216	struct mm_struct *mm;	216	struct mm_struct *mm;
217	struct work_struct work;	217	struct work_struct work;
		218	struct work_struct cancellation_work;
218		219
219	struct usb_ep *ep;	220	struct usb_ep *ep;
220	struct usb_request *req;	221	struct usb_request *req;
@@ -1072,22 +1073,31 @@ ffs_epfile_open(struct inode inode, struct file file) · 851 unmodified lines
1072	return 0;	1073	return 0;
1073	}	1074	}
1074		1075
		1076	static void ffs_aio_cancel_worker(struct work_struct *work)
		1077	{
		1078	struct ffs_io_data *io_data = container_of(work, struct ffs_io_data,
		1079	cancellation_work);
		1080
		1081	ENTER();
		1082
		1083	usb_ep_dequeue(io_data->ep, io_data->req);
		1084	}
		1085
1075	static int ffs_aio_cancel(struct kiocb *kiocb)	1086	static int ffs_aio_cancel(struct kiocb *kiocb)
1076	{	1087	{
1077	struct ffs_io_data *io_data = kiocb->private;	1088	struct ffs_io_data *io_data = kiocb->private;
1078	struct ffs_epfile *epfile = kiocb->ki_filp->private_data;	1089	struct ffs_data *ffs = io_data->ffs;
1079	int value;	1090	int value;
1080		1091
1081	ENTER();	1092	ENTER();
1082		1093
1083	spin_lock_irq(&epfile->ffs->eps_lock);	1094	if (likely(io_data && io_data->ep && io_data->req)) {
1084		1095	INIT_WORK(&io_data->cancellation_work, ffs_aio_cancel_worker);
1085	if (likely(io_data && io_data->ep && io_data->req))	1096	queue_work(ffs->io_completion_wq, &io_data->cancellation_work);
1086	value = usb_ep_dequeue(io_data->ep, io_data->req);	1097	value = -EINPROGRESS;
1087	else	1098	} else {
1088	value = -EINVAL;	1099	value = -EINVAL;
1089		1100	}
1090	spin_unlock_irq(&epfile->ffs->eps_lock);
1091		1101
1092	return value;	1102	return value;
1093	}	1103	}

drivers/usb/host/xhci-mem.c+2−2

 	dev = xhci->devs[slot_id];
-	trace_xhci_free_virt_device(dev);
 	xhci->dcbaa->dev_context_ptrs[slot_id] = 0;
 	if (!dev)
 		return;
+	trace_xhci_free_virt_device(dev);
 	if (dev->tt_info)
 		old_active_eps = dev->tt_info->active_eps;

drivers/usb/host/xhci-tegra.c+3−3

@@ -481,7 +481,7 @@ static void tegra_xusb_mbox_handle(struct tegra_xusb *tegra, · 480 unmodified lines
481	unsigned long mask;	481	unsigned long mask;
482	unsigned int port;	482	unsigned int port;
483	bool idle, enable;	483	bool idle, enable;
484	int err;	484	int err = 0;
485		485
486	memset(&rsp, 0, sizeof(rsp));	486	memset(&rsp, 0, sizeof(rsp));
487		487
@@ -1223,10 +1223,10 @@ disable_rpm: · 735 unmodified lines
1223	pm_runtime_disable(&pdev->dev);	1223	pm_runtime_disable(&pdev->dev);
1224	usb_put_hcd(tegra->hcd);	1224	usb_put_hcd(tegra->hcd);
1225	disable_xusbc:	1225	disable_xusbc:
1226	if (!&pdev->dev.pm_domain)	1226	if (!pdev->dev.pm_domain)
1227	tegra_powergate_power_off(TEGRA_POWERGATE_XUSBC);	1227	tegra_powergate_power_off(TEGRA_POWERGATE_XUSBC);
1228	disable_xusba:	1228	disable_xusba:
1229	if (!&pdev->dev.pm_domain)	1229	if (!pdev->dev.pm_domain)
1230	tegra_powergate_power_off(TEGRA_POWERGATE_XUSBA);	1230	tegra_powergate_power_off(TEGRA_POWERGATE_XUSBA);
1231	put_padctl:	1231	put_padctl:
1232	tegra_xusb_padctl_put(tegra->padctl);	1232	tegra_xusb_padctl_put(tegra->padctl);

drivers/usb/host/xhci-trace.h+31−5

@@ -171,6 +171,37 @@ DEFINE_EVENT(xhci_log_trb, xhci_dbc_gadget_ep_queue, · 170 unmodified lines
171	TP_ARGS(ring, trb)	171	TP_ARGS(ring, trb)
172	);	172	);
173		173
		174	DECLARE_EVENT_CLASS(xhci_log_free_virt_dev,
		175	TP_PROTO(struct xhci_virt_device *vdev),
		176	TP_ARGS(vdev),
		177	TP_STRUCT__entry(
		178	__field(void *, vdev)
		179	__field(unsigned long long, out_ctx)
		180	__field(unsigned long long, in_ctx)
		181	__field(u8, fake_port)
		182	__field(u8, real_port)
		183	__field(u16, current_mel)
		184
		185	),
		186	TP_fast_assign(
		187	__entry->vdev = vdev;
		188	__entry->in_ctx = (unsigned long long) vdev->in_ctx->dma;
		189	__entry->out_ctx = (unsigned long long) vdev->out_ctx->dma;
		190	__entry->fake_port = (u8) vdev->fake_port;
		191	__entry->real_port = (u8) vdev->real_port;
		192	__entry->current_mel = (u16) vdev->current_mel;
		193	),
		194	TP_printk("vdev %p ctx %llx \| %llx fake_port %d real_port %d current_mel %d",
		195	__entry->vdev, __entry->in_ctx, __entry->out_ctx,
		196	__entry->fake_port, __entry->real_port, __entry->current_mel
		197	)
		198	);
		199
		200	DEFINE_EVENT(xhci_log_free_virt_dev, xhci_free_virt_device,
		201	TP_PROTO(struct xhci_virt_device *vdev),
		202	TP_ARGS(vdev)
		203	);
		204
174	DECLARE_EVENT_CLASS(xhci_log_virt_dev,	205	DECLARE_EVENT_CLASS(xhci_log_virt_dev,
175	TP_PROTO(struct xhci_virt_device *vdev),	206	TP_PROTO(struct xhci_virt_device *vdev),
176	TP_ARGS(vdev),	207	TP_ARGS(vdev),
@@ -208,11 +239,6 @@ DEFINE_EVENT(xhci_log_virt_dev, xhci_alloc_virt_device, · 31 unmodified lines
208	TP_ARGS(vdev)	239	TP_ARGS(vdev)
209	);	240	);
210		241
211	DEFINE_EVENT(xhci_log_virt_dev, xhci_free_virt_device,
212	TP_PROTO(struct xhci_virt_device *vdev),
213	TP_ARGS(vdev)
214	);
215
216	DEFINE_EVENT(xhci_log_virt_dev, xhci_setup_device,	242	DEFINE_EVENT(xhci_log_virt_dev, xhci_setup_device,
217	TP_PROTO(struct xhci_virt_device *vdev),	243	TP_PROTO(struct xhci_virt_device *vdev),
218	TP_ARGS(vdev)	244	TP_ARGS(vdev)

drivers/usb/host/xhci.c+43−4

@@ -908,6 +908,41 @@ static void xhci_disable_port_wake_on_bits(struct xhci_hcd *xhci) · 907 unmodified lines
908	spin_unlock_irqrestore(&xhci->lock, flags);	908	spin_unlock_irqrestore(&xhci->lock, flags);
909	}	909	}
910		910
		911	static bool xhci_pending_portevent(struct xhci_hcd *xhci)
		912	{
		913	struct xhci_port **ports;
		914	int port_index;
		915	u32 status;
		916	u32 portsc;
		917
		918	status = readl(&xhci->op_regs->status);
		919	if (status & STS_EINT)
		920	return true;
		921	/*
		922	* Checking STS_EINT is not enough as there is a lag between a change
		923	* bit being set and the Port Status Change Event that it generated
		924	* being written to the Event Ring. See note in xhci 1.1 section 4.19.2.
		925	*/
		926
		927	port_index = xhci->usb2_rhub.num_ports;
		928	ports = xhci->usb2_rhub.ports;
		929	while (port_index--) {
		930	portsc = readl(ports[port_index]->addr);
		931	if (portsc & PORT_CHANGE_MASK \|\|
		932	(portsc & PORT_PLS_MASK) == XDEV_RESUME)
		933	return true;
		934	}
		935	port_index = xhci->usb3_rhub.num_ports;
		936	ports = xhci->usb3_rhub.ports;
		937	while (port_index--) {
		938	portsc = readl(ports[port_index]->addr);
		939	if (portsc & PORT_CHANGE_MASK \|\|
		940	(portsc & PORT_PLS_MASK) == XDEV_RESUME)
		941	return true;
		942	}
		943	return false;
		944	}
		945
911	/*	946	/*
912	* Stop HC (not bus-specific)	947	* Stop HC (not bus-specific)
913	*	948	*
@@ -1009,7 +1044,7 @@ EXPORT_SYMBOL_GPL(xhci_suspend); · 95 unmodified lines
1009	*/	1044	*/
1010	int xhci_resume(struct xhci_hcd *xhci, bool hibernated)	1045	int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
1011	{	1046	{
1012	u32 command, temp = 0, status;	1047	u32 command, temp = 0;
1013	struct usb_hcd *hcd = xhci_to_hcd(xhci);	1048	struct usb_hcd *hcd = xhci_to_hcd(xhci);
1014	struct usb_hcd *secondary_hcd;	1049	struct usb_hcd *secondary_hcd;
1015	int retval = 0;	1050	int retval = 0;
@@ -1043,8 +1078,13 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated) · 27 unmodified lines
1043	command = readl(&xhci->op_regs->command);	1078	command = readl(&xhci->op_regs->command);
1044	command \|= CMD_CRS;	1079	command \|= CMD_CRS;
1045	writel(command, &xhci->op_regs->command);	1080	writel(command, &xhci->op_regs->command);
		1081	/*
		1082	* Some controllers take up to 55+ ms to complete the controller
		1083	* restore so setting the timeout to 100ms. Xhci specification
		1084	* doesn't mention any timeout value.
		1085	*/
1046	if (xhci_handshake(&xhci->op_regs->status,	1086	if (xhci_handshake(&xhci->op_regs->status,
1047	STS_RESTORE, 0, 10 * 1000)) {	1087	STS_RESTORE, 0, 100 * 1000)) {
1048	xhci_warn(xhci, "WARN: xHC restore state timeout\n");	1088	xhci_warn(xhci, "WARN: xHC restore state timeout\n");
1049	spin_unlock_irq(&xhci->lock);	1089	spin_unlock_irq(&xhci->lock);
1050	return -ETIMEDOUT;	1090	return -ETIMEDOUT;
@@ -1134,8 +1174,7 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated) · 83 unmodified lines
1134	done:	1174	done:
1135	if (retval == 0) {	1175	if (retval == 0) {
1136	/* Resume root hubs only when have pending events. */	1176	/* Resume root hubs only when have pending events. */
1137	status = readl(&xhci->op_regs->status);	1177	if (xhci_pending_portevent(xhci)) {
1138	if (status & STS_EINT) {
1139	usb_hcd_resume_root_hub(xhci->shared_hcd);	1178	usb_hcd_resume_root_hub(xhci->shared_hcd);
1140	usb_hcd_resume_root_hub(hcd);	1179	usb_hcd_resume_root_hub(hcd);
1141	}	1180	}

drivers/usb/host/xhci.h+4−0

 #define PORT_PLC	(1 << 22)
 /* port configure error change - port failed to configure its link partner */
 #define PORT_CEC	(1 << 23)
+#define PORT_CHANGE_MASK	(PORT_CSC | PORT_PEC | PORT_WRC | PORT_OCC | \
+				 PORT_RC | PORT_PLC | PORT_CEC)
 /* Cold Attach Status - xHC can set this bit to report device attached during
  * Sx state. Warm port reset should be perfomed to clear this bit and move port
  * to connected state.

drivers/usb/serial/cp210x.c+14−0

 	{ USB_DEVICE(0x10C4, 0x8156) }, /* B&G H3000 link cable */
 	{ USB_DEVICE(0x10C4, 0x815E) }, /* Helicomm IP-Link 1220-DVM */
 	{ USB_DEVICE(0x10C4, 0x815F) }, /* Timewave HamLinkUSB */
+	{ USB_DEVICE(0x10C4, 0x817C) }, /* CESINEL MEDCAL N Power Quality Monitor */
+	{ USB_DEVICE(0x10C4, 0x817D) }, /* CESINEL MEDCAL NT Power Quality Monitor */
+	{ USB_DEVICE(0x10C4, 0x817E) }, /* CESINEL MEDCAL S Power Quality Monitor */
 	{ USB_DEVICE(0x10C4, 0x818B) }, /* AVIT Research USB to TTL */
 	{ USB_DEVICE(0x10C4, 0x819F) }, /* MJS USB Toslink Switcher */
 	{ USB_DEVICE(0x10C4, 0x81A6) }, /* ThinkOptics WavIt */
 	{ USB_DEVICE(0x10C4, 0x826B) }, /* Cygnal Integrated Products, Inc., Fasttrax GPS demonstration module */
 	{ USB_DEVICE(0x10C4, 0x8281) }, /* Nanotec Plug & Drive */
 	{ USB_DEVICE(0x10C4, 0x8293) }, /* Telegesis ETRX2USB */
+	{ USB_DEVICE(0x10C4, 0x82EF) }, /* CESINEL FALCO 6105 AC Power Supply */
+	{ USB_DEVICE(0x10C4, 0x82F1) }, /* CESINEL MEDCAL EFD Earth Fault Detector */
+	{ USB_DEVICE(0x10C4, 0x82F2) }, /* CESINEL MEDCAL ST Network Analyzer */
 	{ USB_DEVICE(0x10C4, 0x82F4) }, /* Starizona MicroTouch */
 	{ USB_DEVICE(0x10C4, 0x82F9) }, /* Procyon AVS */
 	{ USB_DEVICE(0x10C4, 0x8341) }, /* Siemens MC35PU GPRS Modem */
 	{ USB_DEVICE(0x10C4, 0x8470) }, /* Juniper Networks BX Series System Console */
 	{ USB_DEVICE(0x10C4, 0x8477) }, /* Balluff RFID */
 	{ USB_DEVICE(0x10C4, 0x84B6) }, /* Starizona Hyperion */
+	{ USB_DEVICE(0x10C4, 0x851E) }, /* CESINEL MEDCAL PT Network Analyzer */
 	{ USB_DEVICE(0x10C4, 0x85A7) }, /* LifeScan OneTouch Verio IQ */
+	{ USB_DEVICE(0x10C4, 0x85B8) }, /* CESINEL ReCon T Energy Logger */
 	{ USB_DEVICE(0x10C4, 0x85EA) }, /* AC-Services IBUS-IF */
 	{ USB_DEVICE(0x10C4, 0x85EB) }, /* AC-Services CIS-IBUS */
 	{ USB_DEVICE(0x10C4, 0x85F8) }, /* Virtenio Preon32 */
 	{ USB_DEVICE(0x10C4, 0x8857) },	/* CEL EM357 ZigBee USB Stick */
 	{ USB_DEVICE(0x10C4, 0x88A4) }, /* MMB Networks ZigBee USB Device */
 	{ USB_DEVICE(0x10C4, 0x88A5) }, /* Planet Innovation Ingeni ZigBee USB Device */
+	{ USB_DEVICE(0x10C4, 0x88FB) }, /* CESINEL MEDCAL STII Network Analyzer */
+	{ USB_DEVICE(0x10C4, 0x8938) }, /* CESINEL MEDCAL S II Network Analyzer */
 	{ USB_DEVICE(0x10C4, 0x8946) }, /* Ketra N1 Wireless Interface */
 	{ USB_DEVICE(0x10C4, 0x8962) }, /* Brim Brothers charging dock */
 	{ USB_DEVICE(0x10C4, 0x8977) },	/* CEL MeshWorks DevKit Device */
 	{ USB_DEVICE(0x10C4, 0x8998) }, /* KCF Technologies PRN */
+	{ USB_DEVICE(0x10C4, 0x89A4) }, /* CESINEL FTBC Flexible Thyristor Bridge Controller */
 	{ USB_DEVICE(0x10C4, 0x8A2A) }, /* HubZ dual ZigBee and Z-Wave dongle */
 	{ USB_DEVICE(0x10C4, 0x8A5E) }, /* CEL EM3588 ZigBee USB Stick Long Range */
 	{ USB_DEVICE(0x10C4, 0x8B34) }, /* Qivicon ZigBee USB Radio Stick */
 	{ USB_DEVICE(0x10C4, 0xEA60) }, /* Silicon Labs factory default */
 	{ USB_DEVICE(0x10C4, 0xEA61) }, /* Silicon Labs factory default */
+	{ USB_DEVICE(0x10C4, 0xEA63) }, /* Silicon Labs Windows Update (CP2101-4/CP2102N) */
 	{ USB_DEVICE(0x10C4, 0xEA70) }, /* Silicon Labs factory default */
 	{ USB_DEVICE(0x10C4, 0xEA71) }, /* Infinity GPS-MIC-1 Radio Monophone */
+	{ USB_DEVICE(0x10C4, 0xEA7A) }, /* Silicon Labs Windows Update (CP2105) */
+	{ USB_DEVICE(0x10C4, 0xEA7B) }, /* Silicon Labs Windows Update (CP2108) */
 	{ USB_DEVICE(0x10C4, 0xF001) }, /* Elan Digital Systems USBscope50 */
 	{ USB_DEVICE(0x10C4, 0xF002) }, /* Elan Digital Systems USBwave12 */
 	{ USB_DEVICE(0x10C4, 0xF003) }, /* Elan Digital Systems USBpulse100 */

drivers/usb/typec/tcpm.c+6−4

 	u64 ts_nsec = local_clock();
 	unsigned long rem_nsec;
+	mutex_lock(&port->logbuffer_lock);
 	if (!port->logbuffer[port->logbuffer_head]) {
 		port->logbuffer[port->logbuffer_head] =
 				kzalloc(LOG_BUFFER_ENTRY_SIZE, GFP_KERNEL);
-		if (!port->logbuffer[port->logbuffer_head])
+		if (!port->logbuffer[port->logbuffer_head]) {
+			mutex_unlock(&port->logbuffer_lock);
 			return;
+		}
 	}
 	vsnprintf(tmpbuffer, sizeof(tmpbuffer), fmt, args);
-	mutex_lock(&port->logbuffer_lock);
 	if (tcpm_log_full(port)) {
 		port->logbuffer_head = max(port->logbuffer_head - 1, 0);
 		strcpy(tmpbuffer, "overflow");
 		    tcpm_port_is_sink(port) &&
 		    time_is_after_jiffies(port->delayed_runtime)) {
 			tcpm_set_state(port, SNK_DISCOVERY,
-				       port->delayed_runtime - jiffies);
+				       jiffies_to_msecs(port->delayed_runtime -
+							jiffies));
 			break;
 		}
 		tcpm_set_state(port, unattached_state(port), 0);

drivers/usb/typec/ucsi/ucsi.c+13−0

@@ -350,6 +350,19 @@ static void ucsi_connector_change(struct work_struct *work) · 349 unmodified lines
350	}	350	}
351		351
352	if (con->status.change & UCSI_CONSTAT_CONNECT_CHANGE) {	352	if (con->status.change & UCSI_CONSTAT_CONNECT_CHANGE) {
		353	typec_set_pwr_role(con->port, con->status.pwr_dir);
		354
		355	switch (con->status.partner_type) {
		356	case UCSI_CONSTAT_PARTNER_TYPE_UFP:
		357	typec_set_data_role(con->port, TYPEC_HOST);
		358	break;
		359	case UCSI_CONSTAT_PARTNER_TYPE_DFP:
		360	typec_set_data_role(con->port, TYPEC_DEVICE);
		361	break;
		362	default:
		363	break;
		364	}
		365
353	if (con->status.connected)	366	if (con->status.connected)
354	ucsi_register_partner(con);	367	ucsi_register_partner(con);
355	else	368	else

drivers/usb/typec/ucsi/ucsi_acpi.c+5−0

 		return -ENODEV;
 	}
+	/* This will make sure we can use ioremap_nocache() */
+	status = acpi_release_memory(ACPI_HANDLE(&pdev->dev), res, 1);
+	if (ACPI_FAILURE(status))
+		return -ENOMEM;
 	/*
 	 * NOTE: The memory region for the data structures is used also in an
 	 * operation region, which means ACPI has already reserved it. Therefore

fs/aio.c+1−147

@@ -5,7 +5,6 @@ · 4 unmodified lines
5	* Implements an efficient asynchronous io interface.	5	* Implements an efficient asynchronous io interface.
6	*	6	*
7	* Copyright 2000, 2001, 2002 Red Hat, Inc. All Rights Reserved.	7	* Copyright 2000, 2001, 2002 Red Hat, Inc. All Rights Reserved.
8	* Copyright 2018 Christoph Hellwig.
9	*	8	*
10	* See ../COPYING for licensing terms.	9	* See ../COPYING for licensing terms.
11	*/	10	*/
@@ -165,22 +164,10 @@ struct fsync_iocb { · 153 unmodified lines
165	bool datasync;	164	bool datasync;
166	};	165	};
167		166
168	struct poll_iocb {
169	struct file *file;
170	__poll_t events;
171	struct wait_queue_head *head;
172
173	union {
174	struct wait_queue_entry wait;
175	struct work_struct work;
176	};
177	};
178
179	struct aio_kiocb {	167	struct aio_kiocb {
180	union {	168	union {
181	struct kiocb rw;	169	struct kiocb rw;
182	struct fsync_iocb fsync;	170	struct fsync_iocb fsync;
183	struct poll_iocb poll;
184	};	171	};
185		172
186	struct kioctx *ki_ctx;	173	struct kioctx *ki_ctx;
@@ -1590,6 +1577,7 @@ static int aio_fsync(struct fsync_iocb req, struct iocb iocb, bool datasync) · 1403 unmodified lines
1590	if (unlikely(iocb->aio_buf \|\| iocb->aio_offset \|\| iocb->aio_nbytes \|\|	1577	if (unlikely(iocb->aio_buf \|\| iocb->aio_offset \|\| iocb->aio_nbytes \|\|
1591	iocb->aio_rw_flags))	1578	iocb->aio_rw_flags))
1592	return -EINVAL;	1579	return -EINVAL;
		1580
1593	req->file = fget(iocb->aio_fildes);	1581	req->file = fget(iocb->aio_fildes);
1594	if (unlikely(!req->file))	1582	if (unlikely(!req->file))
1595	return -EBADF;	1583	return -EBADF;
@@ -1604,137 +1592,6 @@ static int aio_fsync(struct fsync_iocb req, struct iocb iocb, bool datasync) · 8 unmodified lines
1604	return 0;	1592	return 0;
1605	}	1593	}
1606		1594
1607	/* need to use list_del_init so we can check if item was present */
1608	static inline bool __aio_poll_remove(struct poll_iocb *req)
1609	{
1610	if (list_empty(&req->wait.entry))
1611	return false;
1612	list_del_init(&req->wait.entry);
1613	return true;
1614	}
1615
1616	static inline void __aio_poll_complete(struct aio_kiocb *iocb, __poll_t mask)
1617	{
1618	fput(iocb->poll.file);
1619	aio_complete(iocb, mangle_poll(mask), 0);
1620	}
1621
1622	static void aio_poll_work(struct work_struct *work)
1623	{
1624	struct aio_kiocb *iocb = container_of(work, struct aio_kiocb, poll.work);
1625
1626	if (!list_empty_careful(&iocb->ki_list))
1627	aio_remove_iocb(iocb);
1628	__aio_poll_complete(iocb, iocb->poll.events);
1629	}
1630
1631	static int aio_poll_cancel(struct kiocb *iocb)
1632	{
1633	struct aio_kiocb *aiocb = container_of(iocb, struct aio_kiocb, rw);
1634	struct poll_iocb *req = &aiocb->poll;
1635	struct wait_queue_head *head = req->head;
1636	bool found = false;
1637
1638	spin_lock(&head->lock);
1639	found = __aio_poll_remove(req);
1640	spin_unlock(&head->lock);
1641
1642	if (found) {
1643	req->events = 0;
1644	INIT_WORK(&req->work, aio_poll_work);
1645	schedule_work(&req->work);
1646	}
1647	return 0;
1648	}
1649
1650	static int aio_poll_wake(struct wait_queue_entry *wait, unsigned mode, int sync,
1651	void *key)
1652	{
1653	struct poll_iocb *req = container_of(wait, struct poll_iocb, wait);
1654	struct aio_kiocb *iocb = container_of(req, struct aio_kiocb, poll);
1655	struct file *file = req->file;
1656	__poll_t mask = key_to_poll(key);
1657
1658	assert_spin_locked(&req->head->lock);
1659
1660	/* for instances that support it check for an event match first: */
1661	if (mask && !(mask & req->events))
1662	return 0;
1663
1664	mask = file->f_op->poll_mask(file, req->events) & req->events;
1665	if (!mask)
1666	return 0;
1667
1668	__aio_poll_remove(req);
1669
1670	/*
1671	* Try completing without a context switch if we can acquire ctx_lock
1672	* without spinning. Otherwise we need to defer to a workqueue to
1673	* avoid a deadlock due to the lock order.
1674	*/
1675	if (spin_trylock(&iocb->ki_ctx->ctx_lock)) {
1676	list_del_init(&iocb->ki_list);
1677	spin_unlock(&iocb->ki_ctx->ctx_lock);
1678
1679	__aio_poll_complete(iocb, mask);
1680	} else {
1681	req->events = mask;
1682	INIT_WORK(&req->work, aio_poll_work);
1683	schedule_work(&req->work);
1684	}
1685
1686	return 1;
1687	}
1688
1689	static ssize_t aio_poll(struct aio_kiocb aiocb, struct iocb iocb)
1690	{
1691	struct kioctx *ctx = aiocb->ki_ctx;
1692	struct poll_iocb *req = &aiocb->poll;
1693	__poll_t mask;
1694
1695	/* reject any unknown events outside the normal event mask. */
1696	if ((u16)iocb->aio_buf != iocb->aio_buf)
1697	return -EINVAL;
1698	/* reject fields that are not defined for poll */
1699	if (iocb->aio_offset \|\| iocb->aio_nbytes \|\| iocb->aio_rw_flags)
1700	return -EINVAL;
1701
1702	req->events = demangle_poll(iocb->aio_buf) \| EPOLLERR \| EPOLLHUP;
1703	req->file = fget(iocb->aio_fildes);
1704	if (unlikely(!req->file))
1705	return -EBADF;
1706	if (!file_has_poll_mask(req->file))
1707	goto out_fail;
1708
1709	req->head = req->file->f_op->get_poll_head(req->file, req->events);
1710	if (!req->head)
1711	goto out_fail;
1712	if (IS_ERR(req->head)) {
1713	mask = EPOLLERR;
1714	goto done;
1715	}
1716
1717	init_waitqueue_func_entry(&req->wait, aio_poll_wake);
1718	aiocb->ki_cancel = aio_poll_cancel;
1719
1720	spin_lock_irq(&ctx->ctx_lock);
1721	spin_lock(&req->head->lock);
1722	mask = req->file->f_op->poll_mask(req->file, req->events) & req->events;
1723	if (!mask) {
1724	__add_wait_queue(req->head, &req->wait);
1725	list_add_tail(&aiocb->ki_list, &ctx->active_reqs);
1726	}
1727	spin_unlock(&req->head->lock);
1728	spin_unlock_irq(&ctx->ctx_lock);
1729	done:
1730	if (mask)
1731	__aio_poll_complete(aiocb, mask);
1732	return 0;
1733	out_fail:
1734	fput(req->file);
1735	return -EINVAL; /* same as no support for IOCB_CMD_POLL */
1736	}
1737
1738	static int io_submit_one(struct kioctx ctx, struct iocb __user user_iocb,	1595	static int io_submit_one(struct kioctx ctx, struct iocb __user user_iocb,
1739	bool compat)	1596	bool compat)
1740	{	1597	{
@@ -1808,9 +1665,6 @@ static int io_submit_one(struct kioctx ctx, struct iocb __user user_iocb, · 67 unmodified lines
1808	case IOCB_CMD_FDSYNC:	1665	case IOCB_CMD_FDSYNC:
1809	ret = aio_fsync(&req->fsync, &iocb, true);	1666	ret = aio_fsync(&req->fsync, &iocb, true);
1810	break;	1667	break;
1811	case IOCB_CMD_POLL:
1812	ret = aio_poll(req, &iocb);
1813	break;
1814	default:	1668	default:
1815	pr_debug("invalid aio operation %d\n", iocb.aio_lio_opcode);	1669	pr_debug("invalid aio operation %d\n", iocb.aio_lio_opcode);
1816	ret = -EINVAL;	1670	ret = -EINVAL;

fs/btrfs/extent_io.c+4−1

 			offset_in_extent = em_start - em->start;
 		em_end = extent_map_end(em);
 		em_len = em_end - em_start;
-		disko = em->block_start + offset_in_extent;
 		flags = 0;
+		if (em->block_start < EXTENT_MAP_LAST_BYTE)
+			disko = em->block_start + offset_in_extent;
+		else
+			disko = 0;
 		/*
 		 * bump off for our next call to get_extent

fs/btrfs/inode.c+5−2

 	unlock_extent_cached(io_tree, page_start, page_end, &cached_state);
-out_unlock:
 	if (!ret2) {
 		btrfs_delalloc_release_extents(BTRFS_I(inode), PAGE_SIZE, true);
 		sb_end_pagefault(inode->i_sb);
 		extent_changeset_free(data_reserved);
 		return VM_FAULT_LOCKED;
 	}
+out_unlock:
 	unlock_page(page);
 out:
 	btrfs_delalloc_release_extents(BTRFS_I(inode), PAGE_SIZE, (ret != 0));
 	u64 new_idx = 0;
 	u64 root_objectid;
 	int ret;
+	int ret2;
 	bool root_log_pinned = false;
 	bool dest_log_pinned = false;
 			dest_log_pinned = false;
 		}
 	}
-	ret = btrfs_end_transaction(trans);
+	ret2 = btrfs_end_transaction(trans);
+	ret = ret ? ret : ret2;
 out_notrans:
 	if (new_ino == BTRFS_FIRST_FREE_OBJECTID)
 		up_read(&fs_info->subvol_sem);

fs/btrfs/ioctl.c+5−5

 		ret = btrfs_extent_same_range(src, loff, BTRFS_MAX_DEDUPE_LEN,
 					      dst, dst_loff, &cmp);
 		if (ret)
-			goto out_unlock;
+			goto out_free;
 		loff += BTRFS_MAX_DEDUPE_LEN;
 		dst_loff += BTRFS_MAX_DEDUPE_LEN;
 		ret = btrfs_extent_same_range(src, loff, tail_len, dst,
 					      dst_loff, &cmp);
+out_free:
+	kvfree(cmp.src_pages);
+	kvfree(cmp.dst_pages);
 out_unlock:
 	if (same_inode)
 		inode_unlock(src);
 	else
 		btrfs_double_inode_unlock(src, dst);
-out_free:
-	kvfree(cmp.src_pages);
-	kvfree(cmp.dst_pages);
 	return ret;
 }

fs/btrfs/qgroup.c+13−4

 		free_extent_buffer(scratch_leaf);
 	}
-	if (done && !ret)
+	if (done && !ret) {
 		ret = 1;
+		fs_info->qgroup_rescan_progress.objectid = (u64)-1;
+	}
 	return ret;
 }
 	if (!init_flags) {
 		/* we're resuming qgroup rescan at mount time */
-		if (!(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN))
+		if (!(fs_info->qgroup_flags &
+		      BTRFS_QGROUP_STATUS_FLAG_RESCAN)) {
 			btrfs_warn(fs_info,
 			"qgroup rescan init failed, qgroup is not enabled");
-		else if (!(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_ON))
+			ret = -EINVAL;
+		} else if (!(fs_info->qgroup_flags &
+			     BTRFS_QGROUP_STATUS_FLAG_ON)) {
 			btrfs_warn(fs_info,
 			"qgroup rescan init failed, qgroup rescan is not queued");
-		return -EINVAL;
+			ret = -EINVAL;
+		}
+		if (ret)
+			return ret;
 	}
 	mutex_lock(&fs_info->qgroup_rescan_lock);

fs/ceph/inode.c+1−0

@@ -1135,6 +1135,7 @@ static struct dentry splice_dentry(struct dentry dn, struct inode *in) · 1134 unmodified lines
1135	if (IS_ERR(realdn)) {	1135	if (IS_ERR(realdn)) {
1136	pr_err("splice_dentry error %ld %p inode %p ino %llx.%llx\n",	1136	pr_err("splice_dentry error %ld %p inode %p ino %llx.%llx\n",
1137	PTR_ERR(realdn), dn, in, ceph_vinop(in));	1137	PTR_ERR(realdn), dn, in, ceph_vinop(in));
		1138	dput(dn);
1138	dn = realdn; /* note realdn contains the error */	1139	dn = realdn; /* note realdn contains the error */
1139	goto out;	1140	goto out;
1140	} else if (realdn) {	1141	} else if (realdn) {

fs/eventfd.c+6−13

 	return 0;
 }
-static struct wait_queue_head *
+static __poll_t eventfd_poll(struct file *file, poll_table *wait)
-eventfd_get_poll_head(struct file *file, __poll_t events)
-{
-	struct eventfd_ctx *ctx = file->private_data;
-	return &ctx->wqh;
-}
-static __poll_t eventfd_poll_mask(struct file *file, __poll_t eventmask)
 {
 	struct eventfd_ctx *ctx = file->private_data;
 	__poll_t events = 0;
 	u64 count;
+	poll_wait(file, &ctx->wqh, wait);
 	/*
 	 * All writes to ctx->count occur within ctx->wqh.lock.  This read
 	 * can be done outside ctx->wqh.lock because we know that poll_wait
 	count = READ_ONCE(ctx->count);
 	if (count > 0)
-		events |= (EPOLLIN & eventmask);
+		events |= EPOLLIN;
 	if (count == ULLONG_MAX)
 		events |= EPOLLERR;
 	if (ULLONG_MAX - 1 > count)
-		events |= (EPOLLOUT & eventmask);
+		events |= EPOLLOUT;
 	return events;
 }
 	.show_fdinfo	= eventfd_show_fdinfo,
 #endif
 	.release	= eventfd_release,
-	.get_poll_head	= eventfd_get_poll_head,
+	.poll		= eventfd_poll,
-	.poll_mask	= eventfd_poll_mask,
 	.read		= eventfd_read,
 	.write		= eventfd_write,
 	.llseek		= noop_llseek,

fs/eventpoll.c+5−10

 	return 0;
 }
-static struct wait_queue_head *ep_eventpoll_get_poll_head(struct file *file,
+static __poll_t ep_eventpoll_poll(struct file *file, poll_table *wait)
-		__poll_t eventmask)
-{
-	struct eventpoll *ep = file->private_data;
-	return &ep->poll_wait;
-}
-static __poll_t ep_eventpoll_poll_mask(struct file *file, __poll_t eventmask)
 {
 	struct eventpoll *ep = file->private_data;
 	int depth = 0;
+	/* Insert inside our poll wait queue */
+	poll_wait(file, &ep->poll_wait, wait);
 	/*
 	 * Proceed to find out if wanted events are really available inside
 	 * the ready list.
 	.show_fdinfo	= ep_show_fdinfo,
 #endif
 	.release	= ep_eventpoll_release,
-	.get_poll_head	= ep_eventpoll_get_poll_head,
+	.poll		= ep_eventpoll_poll,
-	.poll_mask	= ep_eventpoll_poll_mask,
 	.llseek		= noop_llseek,
 };

fs/pipe.c+9−13

@@ -509,22 +509,19 @@ static long pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) · 508 unmodified lines
509	}	509	}
510	}	510	}
511		511
512	static struct wait_queue_head *
513	pipe_get_poll_head(struct file *filp, __poll_t events)
514	{
515	struct pipe_inode_info *pipe = filp->private_data;
516
517	return &pipe->wait;
518	}
519
520	/* No kernel lock held - fine */	512	/* No kernel lock held - fine */
521	static __poll_t pipe_poll_mask(struct file *filp, __poll_t events)	513	static __poll_t
		514	pipe_poll(struct file filp, poll_table wait)
522	{	515	{
		516	__poll_t mask;
523	struct pipe_inode_info *pipe = filp->private_data;	517	struct pipe_inode_info *pipe = filp->private_data;
524	int nrbufs = pipe->nrbufs;	518	int nrbufs;
525	__poll_t mask = 0;	519
		520	poll_wait(filp, &pipe->wait, wait);
526		521
527	/* Reading only -- no need for acquiring the semaphore. */	522	/* Reading only -- no need for acquiring the semaphore. */
		523	nrbufs = pipe->nrbufs;
		524	mask = 0;
528	if (filp->f_mode & FMODE_READ) {	525	if (filp->f_mode & FMODE_READ) {
529	mask = (nrbufs > 0) ? EPOLLIN \| EPOLLRDNORM : 0;	526	mask = (nrbufs > 0) ? EPOLLIN \| EPOLLRDNORM : 0;
530	if (!pipe->writers && filp->f_version != pipe->w_counter)	527	if (!pipe->writers && filp->f_version != pipe->w_counter)
@@ -1023,8 +1020,7 @@ const struct file_operations pipefifo_fops = { · 492 unmodified lines
1023	.llseek = no_llseek,	1020	.llseek = no_llseek,
1024	.read_iter = pipe_read,	1021	.read_iter = pipe_read,
1025	.write_iter = pipe_write,	1022	.write_iter = pipe_write,
1026	.get_poll_head = pipe_get_poll_head,	1023	.poll = pipe_poll,
1027	.poll_mask = pipe_poll_mask,
1028	.unlocked_ioctl = pipe_ioctl,	1024	.unlocked_ioctl = pipe_ioctl,
1029	.release = pipe_release,	1025	.release = pipe_release,
1030	.fasync = pipe_fasync,	1026	.fasync = pipe_fasync,

fs/proc/generic.c+10−1

 	return seq_open(file, de->seq_ops);
 }
+static int proc_seq_release(struct inode *inode, struct file *file)
+{
+	struct proc_dir_entry *de = PDE(inode);
+	if (de->state_size)
+		return seq_release_private(inode, file);
+	return seq_release(inode, file);
+}
 static const struct file_operations proc_seq_fops = {
 	.open		= proc_seq_open,
 	.read		= seq_read,
 	.llseek		= seq_lseek,
-	.release	= seq_release,
+	.release	= proc_seq_release,
 };
 struct proc_dir_entry *proc_create_seq_private(const char *name, umode_t mode,

fs/select.c+0−23

@@ -34,29 +34,6 @@ · 33 unmodified lines
34		34
35	#include <linux/uaccess.h>	35	#include <linux/uaccess.h>
36		36
37	__poll_t vfs_poll(struct file file, struct poll_table_struct pt)
38	{
39	if (file->f_op->poll) {
40	return file->f_op->poll(file, pt);
41	} else if (file_has_poll_mask(file)) {
42	unsigned int events = poll_requested_events(pt);
43	struct wait_queue_head *head;
44
45	if (pt && pt->_qproc) {
46	head = file->f_op->get_poll_head(file, events);
47	if (!head)
48	return DEFAULT_POLLMASK;
49	if (IS_ERR(head))
50	return EPOLLERR;
51	pt->_qproc(file, head, pt);
52	}
53
54	return file->f_op->poll_mask(file, events);
55	} else {
56	return DEFAULT_POLLMASK;
57	}
58	}
59	EXPORT_SYMBOL_GPL(vfs_poll);
60		37
61	/*	38	/*
62	* Estimate expected accuracy in ns from a timeval.	39	* Estimate expected accuracy in ns from a timeval.

fs/timerfd.c+11−11

 	kfree_rcu(ctx, rcu);
 	return 0;
 }
-static struct wait_queue_head *timerfd_get_poll_head(struct file *file,
+static __poll_t timerfd_poll(struct file *file, poll_table *wait)
-		__poll_t eventmask)
 {
 	struct timerfd_ctx *ctx = file->private_data;
+	__poll_t events = 0;
+	unsigned long flags;
-	return &ctx->wqh;
+	poll_wait(file, &ctx->wqh, wait);
-}
-static __poll_t timerfd_poll_mask(struct file *file, __poll_t eventmask)
+	spin_lock_irqsave(&ctx->wqh.lock, flags);
-{
+	if (ctx->ticks)
-	struct timerfd_ctx *ctx = file->private_data;
+		events |= EPOLLIN;
+	spin_unlock_irqrestore(&ctx->wqh.lock, flags);
-	return ctx->ticks ? EPOLLIN : 0;
+	return events;
 }
 static ssize_t timerfd_read(struct file *file, char __user *buf, size_t count,
 static const struct file_operations timerfd_fops = {
 	.release	= timerfd_release,
-	.get_poll_head	= timerfd_get_poll_head,
+	.poll		= timerfd_poll,
-	.poll_mask	= timerfd_poll_mask,
 	.read		= timerfd_read,
 	.llseek		= noop_llseek,
 	.show_fdinfo	= timerfd_show,

fs/xfs/libxfs/xfs_ag_resv.c+27−4

 	error = xfs_mod_fdblocks(pag->pag_mount, oldresv, true);
 	resv->ar_reserved = 0;
 	resv->ar_asked = 0;
+	resv->ar_orig_reserved = 0;
 	if (error)
 		trace_xfs_ag_resv_free_error(pag->pag_mount, pag->pag_agno,
 	struct xfs_mount		*mp = pag->pag_mount;
 	struct xfs_ag_resv		*resv;
 	int				error;
-	xfs_extlen_t			reserved;
+	xfs_extlen_t			hidden_space;
 	if (used > ask)
 		ask = used;
-	reserved = ask - used;
-	error = xfs_mod_fdblocks(mp, -(int64_t)reserved, true);
+	switch (type) {
+	case XFS_AG_RESV_RMAPBT:
+		/*
+		 * Space taken by the rmapbt is not subtracted from fdblocks
+		 * because the rmapbt lives in the free space.  Here we must
+		 * subtract the entire reservation from fdblocks so that we
+		 * always have blocks available for rmapbt expansion.
+		 */
+		hidden_space = ask;
+		break;
+	case XFS_AG_RESV_METADATA:
+		/*
+		 * Space taken by all other metadata btrees are accounted
+		 * on-disk as used space.  We therefore only hide the space
+		 * that is reserved but not used by the trees.
+		 */
+		hidden_space = ask - used;
+		break;
+	default:
+		ASSERT(0);
+		return -EINVAL;
+	}
+	error = xfs_mod_fdblocks(mp, -(int64_t)hidden_space, true);
 	if (error) {
 		trace_xfs_ag_resv_init_error(pag->pag_mount, pag->pag_agno,
 				error, _RET_IP_);
 	resv = xfs_perag_resv(pag, type);
 	resv->ar_asked = ask;
-	resv->ar_reserved = resv->ar_orig_reserved = reserved;
+	resv->ar_orig_reserved = hidden_space;
+	resv->ar_reserved = ask - used;
 	trace_xfs_ag_resv_init(pag, type, ask);
 	return 0;

fs/xfs/libxfs/xfs_bmap.c+26−0

@@ -5780,6 +5780,32 @@ del_cursor: · 5779 unmodified lines
5780	return error;	5780	return error;
5781	}	5781	}
5782		5782
		5783	/* Make sure we won't be right-shifting an extent past the maximum bound. */
		5784	int
		5785	xfs_bmap_can_insert_extents(
		5786	struct xfs_inode *ip,
		5787	xfs_fileoff_t off,
		5788	xfs_fileoff_t shift)
		5789	{
		5790	struct xfs_bmbt_irec got;
		5791	int is_empty;
		5792	int error = 0;
		5793
		5794	ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
		5795
		5796	if (XFS_FORCED_SHUTDOWN(ip->i_mount))
		5797	return -EIO;
		5798
		5799	xfs_ilock(ip, XFS_ILOCK_EXCL);
		5800	error = xfs_bmap_last_extent(NULL, ip, XFS_DATA_FORK, &got, &is_empty);
		5801	if (!error && !is_empty && got.br_startoff >= off &&
		5802	((got.br_startoff + shift) & BMBT_STARTOFF_MASK) < got.br_startoff)
		5803	error = -EINVAL;
		5804	xfs_iunlock(ip, XFS_ILOCK_EXCL);
		5805
		5806	return error;
		5807	}
		5808
5783	int	5809	int
5784	xfs_bmap_insert_extents(	5810	xfs_bmap_insert_extents(
5785	struct xfs_trans *tp,	5811	struct xfs_trans *tp,

fs/xfs/libxfs/xfs_bmap.h+2−0

 		xfs_fileoff_t *next_fsb, xfs_fileoff_t offset_shift_fsb,
 		bool *done, xfs_fsblock_t *firstblock,
 		struct xfs_defer_ops *dfops);
+int	xfs_bmap_can_insert_extents(struct xfs_inode *ip, xfs_fileoff_t off,
+		xfs_fileoff_t shift);
 int	xfs_bmap_insert_extents(struct xfs_trans *tp, struct xfs_inode *ip,
 		xfs_fileoff_t *next_fsb, xfs_fileoff_t offset_shift_fsb,
 		bool *done, xfs_fileoff_t stop_fsb, xfs_fsblock_t *firstblock,

fs/xfs/libxfs/xfs_format.h+5−0

 		XFS_DFORK_DSIZE(dip, mp) : \
 		XFS_DFORK_ASIZE(dip, mp))
+#define XFS_DFORK_MAXEXT(dip, mp, w) \
+	(XFS_DFORK_SIZE(dip, mp, w) / sizeof(struct xfs_bmbt_rec))
 /*
  * Return pointers to the data or attribute forks.
  */
 #define BMBT_STARTBLOCK_BITLEN	52
 #define BMBT_BLOCKCOUNT_BITLEN	21
+#define BMBT_STARTOFF_MASK	((1ULL << BMBT_STARTOFF_BITLEN) - 1)
 typedef struct xfs_bmbt_rec {
 	__be64			l0, l1;
 } xfs_bmbt_rec_t;

fs/xfs/libxfs/xfs_inode_buf.c+47−29

 	}
 }
+static xfs_failaddr_t
+xfs_dinode_verify_fork(
+	struct xfs_dinode	*dip,
+	struct xfs_mount	*mp,
+	int			whichfork)
+{
+	uint32_t		di_nextents = XFS_DFORK_NEXTENTS(dip, whichfork);
+	switch (XFS_DFORK_FORMAT(dip, whichfork)) {
+	case XFS_DINODE_FMT_LOCAL:
+		/*
+		 * no local regular files yet
+		 */
+		if (whichfork == XFS_DATA_FORK) {
+			if (S_ISREG(be16_to_cpu(dip->di_mode)))
+				return __this_address;
+			if (be64_to_cpu(dip->di_size) >
+					XFS_DFORK_SIZE(dip, mp, whichfork))
+				return __this_address;
+		}
+		if (di_nextents)
+			return __this_address;
+		break;
+	case XFS_DINODE_FMT_EXTENTS:
+		if (di_nextents > XFS_DFORK_MAXEXT(dip, mp, whichfork))
+			return __this_address;
+		break;
+	case XFS_DINODE_FMT_BTREE:
+		if (whichfork == XFS_ATTR_FORK) {
+			if (di_nextents > MAXAEXTNUM)
+				return __this_address;
+		} else if (di_nextents > MAXEXTNUM) {
+			return __this_address;
+		}
+		break;
+	default:
+		return __this_address;
+	}
+	return NULL;
+}
 xfs_failaddr_t
 xfs_dinode_verify(
 	struct xfs_mount	*mp,
 	case S_IFREG:
 	case S_IFLNK:
 	case S_IFDIR:
-		switch (dip->di_format) {
+		fa = xfs_dinode_verify_fork(dip, mp, XFS_DATA_FORK);
-		case XFS_DINODE_FMT_LOCAL:
+		if (fa)
-			/*
+			return fa;
-			 * no local regular files yet
-			 */
-			if (S_ISREG(mode))
-				return __this_address;
-			if (di_size > XFS_DFORK_DSIZE(dip, mp))
-				return __this_address;
-			if (dip->di_nextents)
-				return __this_address;
-			/* fall through */
-		case XFS_DINODE_FMT_EXTENTS:
-		case XFS_DINODE_FMT_BTREE:
-			break;
-		default:
-			return __this_address;
-		}
 		break;
 	case 0:
 		/* Uninitialized inode ok. */
 	}
 	if (XFS_DFORK_Q(dip)) {
-		switch (dip->di_aformat) {
+		fa = xfs_dinode_verify_fork(dip, mp, XFS_ATTR_FORK);
-		case XFS_DINODE_FMT_LOCAL:
+		if (fa)
-			if (dip->di_anextents)
+			return fa;
-				return __this_address;
-		/* fall through */
-		case XFS_DINODE_FMT_EXTENTS:
-		case XFS_DINODE_FMT_BTREE:
-			break;
-		default:
-			return __this_address;
-		}
 	} else {
 		/*
 		 * If there is no fork offset, this may be a freshly-made inode

fs/xfs/libxfs/xfs_rtbitmap.c+2−2

@@ -1029,8 +1029,8 @@ xfs_rtalloc_query_range( · 1028 unmodified lines
1029	if (low_rec->ar_startext >= mp->m_sb.sb_rextents \|\|	1029	if (low_rec->ar_startext >= mp->m_sb.sb_rextents \|\|
1030	low_rec->ar_startext == high_rec->ar_startext)	1030	low_rec->ar_startext == high_rec->ar_startext)
1031	return 0;	1031	return 0;
1032	if (high_rec->ar_startext >= mp->m_sb.sb_rextents)	1032	if (high_rec->ar_startext > mp->m_sb.sb_rextents)
1033	high_rec->ar_startext = mp->m_sb.sb_rextents - 1;	1033	high_rec->ar_startext = mp->m_sb.sb_rextents;
1034		1034
1035	/* Iterate the bitmap, looking for discrepancies. */	1035	/* Iterate the bitmap, looking for discrepancies. */
1036	rtstart = low_rec->ar_startext;	1036	rtstart = low_rec->ar_startext;

fs/xfs/xfs_bmap_util.c+52−54

 }
 /*
- * dead simple method of punching delalyed allocation blocks from a range in
+ * Dead simple method of punching delalyed allocation blocks from a range in
- * the inode. Walks a block at a time so will be slow, but is only executed in
+ * the inode.  This will always punch out both the start and end blocks, even
- * rare error cases so the overhead is not critical. This will always punch out
+ * if the ranges only partially overlap them, so it is up to the caller to
- * both the start and end blocks, even if the ranges only partially overlap
+ * ensure that partial blocks are not passed in.
- * them, so it is up to the caller to ensure that partial blocks are not
- * passed in.
  */
 int
 xfs_bmap_punch_delalloc_range(
 	xfs_fileoff_t		start_fsb,
 	xfs_fileoff_t		length)
 {
-	xfs_fileoff_t		remaining = length;
+	struct xfs_ifork	*ifp = &ip->i_df;
+	xfs_fileoff_t		end_fsb = start_fsb + length;
+	struct xfs_bmbt_irec	got, del;
+	struct xfs_iext_cursor	icur;
 	int			error = 0;
 	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
-	do {
+	if (!(ifp->if_flags & XFS_IFEXTENTS)) {
-		int		done;
+		error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK);
-		xfs_bmbt_irec_t	imap;
+		if (error)
-		int		nimaps = 1;
+			return error;
-		xfs_fsblock_t	firstblock;
+	}
-		struct xfs_defer_ops dfops;
-		/*
+	if (!xfs_iext_lookup_extent_before(ip, ifp, &end_fsb, &icur, &got))
-		 * Map the range first and check that it is a delalloc extent
+		return 0;
-		 * before trying to unmap the range. Otherwise we will be
-		 * trying to remove a real extent (which requires a
-		 * transaction) or a hole, which is probably a bad idea...
-		 */
-		error = xfs_bmapi_read(ip, start_fsb, 1, &imap, &nimaps,
-				       XFS_BMAPI_ENTIRE);
-		if (error) {
+	while (got.br_startoff + got.br_blockcount > start_fsb) {
-			/* something screwed, just bail */
+		del = got;
-			if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) {
+		xfs_trim_extent(&del, start_fsb, length);
-				xfs_alert(ip->i_mount,
-			"Failed delalloc mapping lookup ino %lld fsb %lld.",
-						ip->i_ino, start_fsb);
-			}
-			break;
-		}
-		if (!nimaps) {
-			/* nothing there */
-			goto next_block;
-		}
-		if (imap.br_startblock != DELAYSTARTBLOCK) {
-			/* been converted, ignore */
-			goto next_block;
-		}
-		WARN_ON(imap.br_blockcount == 0);
 		/*
-		 * Note: while we initialise the firstblock/dfops pair, they
+		 * A delete can push the cursor forward. Step back to the
-		 * should never be used because blocks should never be
+		 * previous extent on non-delalloc or extents outside the
-		 * allocated or freed for a delalloc extent and hence we need
+		 * target range.
-		 * don't cancel or finish them after the xfs_bunmapi() call.
 		 */
-		xfs_defer_init(&dfops, &firstblock);
+		if (!del.br_blockcount ||
-		error = xfs_bunmapi(NULL, ip, start_fsb, 1, 0, 1, &firstblock,
+		    !isnullstartblock(del.br_startblock)) {
-					&dfops, &done);
+			if (!xfs_iext_prev_extent(ifp, &icur, &got))
-		if (error)
+				break;
-			break;
+			continue;
+		}
-		ASSERT(!xfs_defer_has_unfinished_work(&dfops));
+		error = xfs_bmap_del_extent_delay(ip, XFS_DATA_FORK, &icur,
-next_block:
+						  &got, &del);
-		start_fsb++;
+		if (error || !xfs_iext_get_extent(ifp, &icur, &got))
-		remaining--;
+			break;
-	} while(remaining > 0);
+	}
 	return error;
 }
 		return 0;
 	if (offset + len > XFS_ISIZE(ip))
 		len = XFS_ISIZE(ip) - offset;
-	return iomap_zero_range(VFS_I(ip), offset, len, NULL, &xfs_iomap_ops);
+	error = iomap_zero_range(VFS_I(ip), offset, len, NULL, &xfs_iomap_ops);
+	if (error)
+		return error;
+	/*
+	 * If we zeroed right up to EOF and EOF straddles a page boundary we
+	 * must make sure that the post-EOF area is also zeroed because the
+	 * page could be mmap'd and iomap_zero_range doesn't do that for us.
+	 * Writeback of the eof page will do this, albeit clumsily.
+	 */
+	if (offset + len >= XFS_ISIZE(ip) && ((offset + len) & PAGE_MASK)) {
+		error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
+				(offset + len) & ~PAGE_MASK, LLONG_MAX);
+	}
+	return error;
 }
 /*
 	trace_xfs_insert_file_space(ip);
+	error = xfs_bmap_can_insert_extents(ip, stop_fsb, shift_fsb);
+	if (error)
+		return error;
 	error = xfs_prepare_shift(ip, offset);
 	if (error)
 		return error;

fs/xfs/xfs_fsmap.c+2−2

@@ -513,8 +513,8 @@ xfs_getfsmap_rtdev_rtbitmap_query( · 512 unmodified lines
513	struct xfs_trans *tp,	513	struct xfs_trans *tp,
514	struct xfs_getfsmap_info *info)	514	struct xfs_getfsmap_info *info)
515	{	515	{
516	struct xfs_rtalloc_rec alow;	516	struct xfs_rtalloc_rec alow = { 0 };
517	struct xfs_rtalloc_rec ahigh;	517	struct xfs_rtalloc_rec ahigh = { 0 };
518	int error;	518	int error;
519		519
520	xfs_ilock(tp->t_mountp->m_rbmip, XFS_ILOCK_SHARED);	520	xfs_ilock(tp->t_mountp->m_rbmip, XFS_ILOCK_SHARED);

fs/xfs/xfs_fsops.c+1−1

@@ -387,7 +387,7 @@ xfs_reserve_blocks( · 386 unmodified lines
387	do {	387	do {
388	free = percpu_counter_sum(&mp->m_fdblocks) -	388	free = percpu_counter_sum(&mp->m_fdblocks) -
389	mp->m_alloc_set_aside;	389	mp->m_alloc_set_aside;
390	if (!free)	390	if (free <= 0)
391	break;	391	break;
392		392
393	delta = request - mp->m_resblks;	393	delta = request - mp->m_resblks;

fs/xfs/xfs_inode.c+21−36

 	struct xfs_inode	*cip;
 	int			nr_found;
 	int			clcount = 0;
-	int			bufwasdelwri;
 	int			i;
 	pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
 	 * inode buffer and shut down the filesystem.
 	 */
 	rcu_read_unlock();
-	/*
-	 * Clean up the buffer.  If it was delwri, just release it --
-	 * brelse can handle it with no problems.  If not, shut down the
-	 * filesystem before releasing the buffer.
-	 */
-	bufwasdelwri = (bp->b_flags & _XBF_DELWRI_Q);
-	if (bufwasdelwri)
-		xfs_buf_relse(bp);
 	xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
-	if (!bufwasdelwri) {
-		/*
-		 * Just like incore_relse: if we have b_iodone functions,
-		 * mark the buffer as an error and call them.  Otherwise
-		 * mark it as stale and brelse.
-		 */
-		if (bp->b_iodone) {
-			bp->b_flags &= ~XBF_DONE;
-			xfs_buf_stale(bp);
-			xfs_buf_ioerror(bp, -EIO);
-			xfs_buf_ioend(bp);
-		} else {
-			xfs_buf_stale(bp);
-			xfs_buf_relse(bp);
-		}
-	}
 	/*
-	 * Unlocks the flush lock
+	 * We'll always have an inode attached to the buffer for completion
+	 * process by the time we are called from xfs_iflush(). Hence we have
+	 * always need to do IO completion processing to abort the inodes
+	 * attached to the buffer.  handle them just like the shutdown case in
+	 * xfs_buf_submit().
 	 */
+	ASSERT(bp->b_iodone);
+	bp->b_flags &= ~XBF_DONE;
+	xfs_buf_stale(bp);
+	xfs_buf_ioerror(bp, -EIO);
+	xfs_buf_ioend(bp);
+	/* abort the corrupt inode, as it was not attached to the buffer */
 	xfs_iflush_abort(cip, false);
 	kmem_free(cilist);
 	xfs_perag_put(pag);
 		xfs_log_force(mp, 0);
 	/*
-	 * inode clustering:
+	 * inode clustering: try to gather other inodes into this write
-	 * see if other inodes can be gathered into this write
+	 *
+	 * Note: Any error during clustering will result in the filesystem
+	 * being shut down and completion callbacks run on the cluster buffer.
+	 * As we have already flushed and attached this inode to the buffer,
+	 * it has already been aborted and released by xfs_iflush_cluster() and
+	 * so we have no further error handling to do here.
 	 */
 	error = xfs_iflush_cluster(ip, bp);
 	if (error)
-		goto cluster_corrupt_out;
+		return error;
 	*bpp = bp;
 	return 0;
 	if (bp)
 		xfs_buf_relse(bp);
 	xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
-cluster_corrupt_out:
-	error = -EFSCORRUPTED;
 abort_out:
-	/*
+	/* abort the corrupt inode, as it was not attached to the buffer */
-	 * Unlocks the flush lock
-	 */
 	xfs_iflush_abort(ip, false);
 	return error;
 }

fs/xfs/xfs_iomap.c+14−1

 	unsigned		*lockmode)
 {
 	unsigned		mode = XFS_ILOCK_SHARED;
+	bool			is_write = flags & (IOMAP_WRITE | IOMAP_ZERO);
 	/*
 	 * COW writes may allocate delalloc space or convert unwritten COW
 	 * extents, so we need to make sure to take the lock exclusively here.
 	 */
-	if (xfs_is_reflink_inode(ip) && (flags & (IOMAP_WRITE | IOMAP_ZERO))) {
+	if (xfs_is_reflink_inode(ip) && is_write) {
 		/*
 		 * FIXME: It could still overwrite on unshared extents and not
 		 * need allocation.
 		mode = XFS_ILOCK_EXCL;
 	}
+relock:
 	if (flags & IOMAP_NOWAIT) {
 		if (!xfs_ilock_nowait(ip, mode))
 			return -EAGAIN;
 		xfs_ilock(ip, mode);
 	}
+	/*
+	 * The reflink iflag could have changed since the earlier unlocked
+	 * check, so if we got ILOCK_SHARED for a write and but we're now a
+	 * reflink inode we have to switch to ILOCK_EXCL and relock.
+	 */
+	if (mode == XFS_ILOCK_SHARED && is_write && xfs_is_reflink_inode(ip)) {
+		xfs_iunlock(ip, mode);
+		mode = XFS_ILOCK_EXCL;
+		goto relock;
+	}
 	*lockmode = mode;
 	return 0;
 }

fs/xfs/xfs_trans.c+6−1

 	if (!(flags & XFS_TRANS_NO_WRITECOUNT))
 		sb_start_intwrite(mp->m_super);
-	WARN_ON(mp->m_super->s_writers.frozen == SB_FREEZE_COMPLETE);
+	/*
+	 * Zero-reservation ("empty") transactions can't modify anything, so
+	 * they're allowed to run while we're frozen.
+	 */
+	WARN_ON(resp->tr_logres > 0 &&
+		mp->m_super->s_writers.frozen == SB_FREEZE_COMPLETE);
 	atomic_inc(&mp->m_active_trans);
 	tp = kmem_zone_zalloc(xfs_trans_zone,

include/crypto/if_alg.h+2−1

 			int offset, size_t size, int flags);
 void af_alg_free_resources(struct af_alg_async_req *areq);
 void af_alg_async_cb(struct crypto_async_request *_req, int err);
-__poll_t af_alg_poll_mask(struct socket *sock, __poll_t events);
+__poll_t af_alg_poll(struct file *file, struct socket *sock,
+			 poll_table *wait);
 struct af_alg_async_req *af_alg_alloc_areq(struct sock *sk,
 					   unsigned int areqlen);
 int af_alg_get_rsgl(struct sock *sk, struct msghdr *msg, int flags,

include/linux/acpi.h+3−0

@@ -443,6 +443,9 @@ int acpi_check_resource_conflict(const struct resource *res); · 442 unmodified lines
443	int acpi_check_region(resource_size_t start, resource_size_t n,	443	int acpi_check_region(resource_size_t start, resource_size_t n,
444	const char *name);	444	const char *name);
445		445
		446	acpi_status acpi_release_memory(acpi_handle handle, struct resource *res,
		447	u32 level);
		448
446	int acpi_resources_are_enforced(void);	449	int acpi_resources_are_enforced(void);
447		450
448	#ifdef CONFIG_HIBERNATION	451	#ifdef CONFIG_HIBERNATION

include/linux/blkdev.h+2−2

@@ -1119,8 +1119,8 @@ static inline unsigned int blk_max_size_offset(struct request_queue *q, · 1118 unmodified lines
1119	if (!q->limits.chunk_sectors)	1119	if (!q->limits.chunk_sectors)
1120	return q->limits.max_sectors;	1120	return q->limits.max_sectors;
1121		1121
1122	return q->limits.chunk_sectors -	1122	return min(q->limits.max_sectors, (unsigned int)(q->limits.chunk_sectors -
1123	(offset & (q->limits.chunk_sectors - 1));	1123	(offset & (q->limits.chunk_sectors - 1))));
1124	}	1124	}
1125		1125
1126	static inline unsigned int blk_rq_get_max_sectors(struct request *rq,	1126	static inline unsigned int blk_rq_get_max_sectors(struct request *rq,

include/linux/bpf-cgroup.h+26−0

@@ -188,12 +188,38 @@ int __cgroup_bpf_check_dev_permission(short dev_type, u32 major, u32 minor, · 187 unmodified lines
188	\	188	\
189	__ret; \	189	__ret; \
190	})	190	})
		191	int cgroup_bpf_prog_attach(const union bpf_attr *attr,
		192	enum bpf_prog_type ptype, struct bpf_prog *prog);
		193	int cgroup_bpf_prog_detach(const union bpf_attr *attr,
		194	enum bpf_prog_type ptype);
		195	int cgroup_bpf_prog_query(const union bpf_attr *attr,
		196	union bpf_attr __user *uattr);
191	#else	197	#else
192		198
		199	struct bpf_prog;
193	struct cgroup_bpf {};	200	struct cgroup_bpf {};
194	static inline void cgroup_bpf_put(struct cgroup *cgrp) {}	201	static inline void cgroup_bpf_put(struct cgroup *cgrp) {}
195	static inline int cgroup_bpf_inherit(struct cgroup *cgrp) { return 0; }	202	static inline int cgroup_bpf_inherit(struct cgroup *cgrp) { return 0; }
196		203
		204	static inline int cgroup_bpf_prog_attach(const union bpf_attr *attr,
		205	enum bpf_prog_type ptype,
		206	struct bpf_prog *prog)
		207	{
		208	return -EINVAL;
		209	}
		210
		211	static inline int cgroup_bpf_prog_detach(const union bpf_attr *attr,
		212	enum bpf_prog_type ptype)
		213	{
		214	return -EINVAL;
		215	}
		216
		217	static inline int cgroup_bpf_prog_query(const union bpf_attr *attr,
		218	union bpf_attr __user *uattr)
		219	{
		220	return -EINVAL;
		221	}
		222
197	#define cgroup_bpf_enabled (0)	223	#define cgroup_bpf_enabled (0)
198	#define BPF_CGROUP_PRE_CONNECT_ENABLED(sk) (0)	224	#define BPF_CGROUP_PRE_CONNECT_ENABLED(sk) (0)
199	#define BPF_CGROUP_RUN_PROG_INET_INGRESS(sk,skb) ({ 0; })	225	#define BPF_CGROUP_RUN_PROG_INET_INGRESS(sk,skb) ({ 0; })

include/linux/bpf.h+8−0

 struct sock  *__sock_map_lookup_elem(struct bpf_map *map, u32 key);
 struct sock  *__sock_hash_lookup_elem(struct bpf_map *map, void *key);
 int sock_map_prog(struct bpf_map *map, struct bpf_prog *prog, u32 type);
+int sockmap_get_from_fd(const union bpf_attr *attr, int type,
+			struct bpf_prog *prog);
 #else
 static inline struct sock  *__sock_map_lookup_elem(struct bpf_map *map, u32 key)
 {
 {
 	return -EOPNOTSUPP;
 }
+static inline int sockmap_get_from_fd(const union bpf_attr *attr, int type,
+				      struct bpf_prog *prog)
+{
+	return -EINVAL;
+}
 #endif
 #if defined(CONFIG_XDP_SOCKETS)

include/linux/bpf_lirc.h+3−2

 #include <uapi/linux/bpf.h>
 #ifdef CONFIG_BPF_LIRC_MODE2
-int lirc_prog_attach(const union bpf_attr *attr);
+int lirc_prog_attach(const union bpf_attr *attr, struct bpf_prog *prog);
 int lirc_prog_detach(const union bpf_attr *attr);
 int lirc_prog_query(const union bpf_attr *attr, union bpf_attr __user *uattr);
 #else
-static inline int lirc_prog_attach(const union bpf_attr *attr)
+static inline int lirc_prog_attach(const union bpf_attr *attr,
+				   struct bpf_prog *prog)
 {
 	return -EINVAL;
 }

include/linux/compat.h+7−1

  */
 #ifndef COMPAT_SYSCALL_DEFINEx
 #define COMPAT_SYSCALL_DEFINEx(x, name, ...)					\
+	__diag_push();								\
+	__diag_ignore(GCC, 8, "-Wattribute-alias",				\
+		      "Type aliasing is used to sanitize syscall arguments");\
 	asmlinkage long compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__));	\
 	asmlinkage long compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__))	\
 		__attribute__((alias(__stringify(__se_compat_sys##name))));	\
 	asmlinkage long __se_compat_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__));	\
 	asmlinkage long __se_compat_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__))	\
 	{									\
-		return __do_compat_sys##name(__MAP(x,__SC_DELOUSE,__VA_ARGS__));\
+		long ret = __do_compat_sys##name(__MAP(x,__SC_DELOUSE,__VA_ARGS__));\
+		__MAP(x,__SC_TEST,__VA_ARGS__);					\
+		return ret;							\
 	}									\
+	__diag_pop();								\
 	static inline long __do_compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__))
 #endif /* COMPAT_SYSCALL_DEFINEx */

include/linux/compiler-gcc.h+25−0

@@ -347,3 +347,28 @@ · 346 unmodified lines
347	#if GCC_VERSION >= 50100	347	#if GCC_VERSION >= 50100
348	#define COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW 1	348	#define COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW 1
349	#endif	349	#endif
		350
		351	/*
		352	* Turn individual warnings and errors on and off locally, depending
		353	* on version.
		354	*/
		355	#define __diag_GCC(version, severity, s) \
		356	__diag_GCC_ ## version(__diag_GCC_ ## severity s)
		357
		358	/* Severity used in pragma directives */
		359	#define __diag_GCC_ignore ignored
		360	#define __diag_GCC_warn warning
		361	#define __diag_GCC_error error
		362
		363	/* Compilers before gcc-4.6 do not understand "#pragma GCC diagnostic push" */
		364	#if GCC_VERSION >= 40600
		365	#define __diag_str1(s) #s
		366	#define __diag_str(s) __diag_str1(s)
		367	#define __diag(s) _Pragma(__diag_str(GCC diagnostic s))
		368	#endif
		369
		370	#if GCC_VERSION >= 80000
		371	#define __diag_GCC_8(s) __diag(s)
		372	#else
		373	#define __diag_GCC_8(s)
		374	#endif

include/linux/compiler_types.h+18−0

@@ -271,4 +271,22 @@ struct ftrace_likely_data { · 270 unmodified lines
271	# define __native_word(t) (sizeof(t) == sizeof(char) \|\| sizeof(t) == sizeof(short) \|\| sizeof(t) == sizeof(int) \|\| sizeof(t) == sizeof(long))	271	# define __native_word(t) (sizeof(t) == sizeof(char) \|\| sizeof(t) == sizeof(short) \|\| sizeof(t) == sizeof(int) \|\| sizeof(t) == sizeof(long))
272	#endif	272	#endif
273		273
		274	#ifndef __diag
		275	#define __diag(string)
		276	#endif
		277
		278	#ifndef __diag_GCC
		279	#define __diag_GCC(version, severity, string)
		280	#endif
		281
		282	#define __diag_push() __diag(push)
		283	#define __diag_pop() __diag(pop)
		284
		285	#define __diag_ignore(compiler, version, option, comment) \
		286	__diag_ ## compiler(version, ignore, option)
		287	#define __diag_warn(compiler, version, option, comment) \
		288	__diag_ ## compiler(version, warn, option)
		289	#define __diag_error(compiler, version, option, comment) \
		290	__diag_ ## compiler(version, error, option)
		291
274	#endif /* __LINUX_COMPILER_TYPES_H */	292	#endif /* __LINUX_COMPILER_TYPES_H */

include/linux/dax.h+1−1

@@ -135,7 +135,7 @@ void dax_flush(struct dax_device dax_dev, void addr, size_t size); · 134 unmodified lines
135		135
136	ssize_t dax_iomap_rw(struct kiocb iocb, struct iov_iter iter,	136	ssize_t dax_iomap_rw(struct kiocb iocb, struct iov_iter iter,
137	const struct iomap_ops *ops);	137	const struct iomap_ops *ops);
138	int dax_iomap_fault(struct vm_fault *vmf, enum page_entry_size pe_size,	138	vm_fault_t dax_iomap_fault(struct vm_fault *vmf, enum page_entry_size pe_size,
139	pfn_t pfnp, int errp, const struct iomap_ops *ops);	139	pfn_t pfnp, int errp, const struct iomap_ops *ops);
140	vm_fault_t dax_finish_sync_fault(struct vm_fault *vmf,	140	vm_fault_t dax_finish_sync_fault(struct vm_fault *vmf,
141	enum page_entry_size pe_size, pfn_t pfn);	141	enum page_entry_size pe_size, pfn_t pfn);

include/linux/filter.h+8−48

 };
 struct bpf_binary_header {
-	u16 pages;
+	u32 pages;
-	u16 locked:1;
 	/* Some arches need word alignment for their instructions */
 	u8 image[] __aligned(4);
 };
 	u16			pages;		/* Number of allocated pages */
 	u16			jited:1,	/* Is our filter JIT'ed? */
 				jit_requested:1,/* archs need to JIT the prog */
-				locked:1,	/* Program image locked? */
+				undo_set_mem:1,	/* Passed set_memory_ro() checkpoint */
 				gpl_compatible:1, /* Is filter GPL compatible? */
 				cb_access:1,	/* Is control block accessed? */
 				dst_needed:1,	/* Do we need dst entry? */
 static inline void bpf_prog_lock_ro(struct bpf_prog *fp)
 {
-#ifdef CONFIG_ARCH_HAS_SET_MEMORY
+	fp->undo_set_mem = 1;
-	fp->locked = 1;
+	set_memory_ro((unsigned long)fp, fp->pages);
-	if (set_memory_ro((unsigned long)fp, fp->pages))
-		fp->locked = 0;
-#endif
 }
 static inline void bpf_prog_unlock_ro(struct bpf_prog *fp)
 {
-#ifdef CONFIG_ARCH_HAS_SET_MEMORY
+	if (fp->undo_set_mem)
-	if (fp->locked) {
+		set_memory_rw((unsigned long)fp, fp->pages);
-		WARN_ON_ONCE(set_memory_rw((unsigned long)fp, fp->pages));
-		/* In case set_memory_rw() fails, we want to be the first
-		 * to crash here instead of some random place later on.
-		 */
-		fp->locked = 0;
-	}
-#endif
 }
 static inline void bpf_jit_binary_lock_ro(struct bpf_binary_header *hdr)
 {
-#ifdef CONFIG_ARCH_HAS_SET_MEMORY
+	set_memory_ro((unsigned long)hdr, hdr->pages);
-	hdr->locked = 1;
-	if (set_memory_ro((unsigned long)hdr, hdr->pages))
-		hdr->locked = 0;
-#endif
 }
 static inline void bpf_jit_binary_unlock_ro(struct bpf_binary_header *hdr)
 {
-#ifdef CONFIG_ARCH_HAS_SET_MEMORY
+	set_memory_rw((unsigned long)hdr, hdr->pages);
-	if (hdr->locked) {
-		WARN_ON_ONCE(set_memory_rw((unsigned long)hdr, hdr->pages));
-		/* In case set_memory_rw() fails, we want to be the first
-		 * to crash here instead of some random place later on.
-		 */
-		hdr->locked = 0;
-	}
-#endif
 }
 static inline struct bpf_binary_header *
 	return (void *)addr;
 }
-#ifdef CONFIG_ARCH_HAS_SET_MEMORY
-static inline int bpf_prog_check_pages_ro_single(const struct bpf_prog *fp)
-{
-	if (!fp->locked)
-		return -ENOLCK;
-	if (fp->jited) {
-		const struct bpf_binary_header *hdr = bpf_jit_binary_hdr(fp);
-		if (!hdr->locked)
-			return -ENOLCK;
-	}
-	return 0;
-}
-#endif
 int sk_filter_trim_cap(struct sock *sk, struct sk_buff *skb, unsigned int cap);
 static inline int sk_filter(struct sock *sk, struct sk_buff *skb)
 {

include/linux/fs.h+0−2

 	int (*iterate) (struct file *, struct dir_context *);
 	int (*iterate_shared) (struct file *, struct dir_context *);
 	__poll_t (*poll) (struct file *, struct poll_table_struct *);
-	struct wait_queue_head * (*get_poll_head)(struct file *, __poll_t);
-	__poll_t (*poll_mask) (struct file *, __poll_t);
 	long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
 	long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
 	int (*mmap) (struct file *, struct vm_area_struct *);

include/linux/iio/buffer-dma.h+1−1

@@ -141,7 +141,7 @@ int iio_dma_buffer_read(struct iio_buffer *buffer, size_t n, · 140 unmodified lines
141	char __user *user_buffer);	141	char __user *user_buffer);
142	size_t iio_dma_buffer_data_available(struct iio_buffer *buffer);	142	size_t iio_dma_buffer_data_available(struct iio_buffer *buffer);
143	int iio_dma_buffer_set_bytes_per_datum(struct iio_buffer *buffer, size_t bpd);	143	int iio_dma_buffer_set_bytes_per_datum(struct iio_buffer *buffer, size_t bpd);
144	int iio_dma_buffer_set_length(struct iio_buffer *buffer, int length);	144	int iio_dma_buffer_set_length(struct iio_buffer *buffer, unsigned int length);
145	int iio_dma_buffer_request_update(struct iio_buffer *buffer);	145	int iio_dma_buffer_request_update(struct iio_buffer *buffer);
146		146
147	int iio_dma_buffer_init(struct iio_dma_buffer_queue *queue,	147	int iio_dma_buffer_init(struct iio_dma_buffer_queue *queue,

include/linux/input/mt.h+1−1

@@ -100,7 +100,7 @@ static inline bool input_is_mt_axis(int axis) · 99 unmodified lines
100	return axis == ABS_MT_SLOT \|\| input_is_mt_value(axis);	100	return axis == ABS_MT_SLOT \|\| input_is_mt_value(axis);
101	}	101	}
102		102
103	void input_mt_report_slot_state(struct input_dev *dev,	103	bool input_mt_report_slot_state(struct input_dev *dev,
104	unsigned int tool_type, bool active);	104	unsigned int tool_type, bool active);
105		105
106	void input_mt_report_finger_count(struct input_dev *dev, int count);	106	void input_mt_report_finger_count(struct input_dev *dev, int count);

include/linux/mlx5/eswitch.h+2−0

@@ -8,6 +8,8 @@ · 7 unmodified lines
8		8
9	#include <linux/mlx5/driver.h>	9	#include <linux/mlx5/driver.h>
10		10
		11	#define MLX5_ESWITCH_MANAGER(mdev) MLX5_CAP_GEN(mdev, eswitch_manager)
		12
11	enum {	13	enum {
12	SRIOV_NONE,	14	SRIOV_NONE,
13	SRIOV_LEGACY,	15	SRIOV_LEGACY,

include/linux/mlx5/mlx5_ifc.h+1−1

@@ -922,7 +922,7 @@ struct mlx5_ifc_cmd_hca_cap_bits { · 921 unmodified lines
922	u8 vnic_env_queue_counters[0x1];	922	u8 vnic_env_queue_counters[0x1];
923	u8 ets[0x1];	923	u8 ets[0x1];
924	u8 nic_flow_table[0x1];	924	u8 nic_flow_table[0x1];
925	u8 eswitch_flow_table[0x1];	925	u8 eswitch_manager[0x1];
926	u8 device_memory[0x1];	926	u8 device_memory[0x1];
927	u8 mcam_reg[0x1];	927	u8 mcam_reg[0x1];
928	u8 pcam_reg[0x1];	928	u8 pcam_reg[0x1];

include/linux/net.h+0−1

@@ -147,7 +147,6 @@ struct proto_ops { · 146 unmodified lines
147	int (getname) (struct socket sock,	147	int (getname) (struct socket sock,
148	struct sockaddr *addr,	148	struct sockaddr *addr,
149	int peer);	149	int peer);
150	__poll_t (poll_mask) (struct socket sock, __poll_t events);
151	__poll_t (poll) (struct file file, struct socket *sock,	150	__poll_t (poll) (struct file file, struct socket *sock,
152	struct poll_table_struct *wait);	151	struct poll_table_struct *wait);
153	int (ioctl) (struct socket sock, unsigned int cmd,	152	int (ioctl) (struct socket sock, unsigned int cmd,

include/linux/netdevice.h+20−0

@@ -2796,11 +2796,31 @@ static inline void skb_gro_flush_final(struct sk_buff skb, struct sk_buff pp, · 2795 unmodified lines
2796	if (PTR_ERR(pp) != -EINPROGRESS)	2796	if (PTR_ERR(pp) != -EINPROGRESS)
2797	NAPI_GRO_CB(skb)->flush \|= flush;	2797	NAPI_GRO_CB(skb)->flush \|= flush;
2798	}	2798	}
		2799	static inline void skb_gro_flush_final_remcsum(struct sk_buff *skb,
		2800	struct sk_buff *pp,
		2801	int flush,
		2802	struct gro_remcsum *grc)
		2803	{
		2804	if (PTR_ERR(pp) != -EINPROGRESS) {
		2805	NAPI_GRO_CB(skb)->flush \|= flush;
		2806	skb_gro_remcsum_cleanup(skb, grc);
		2807	skb->remcsum_offload = 0;
		2808	}
		2809	}
2799	#else	2810	#else
2800	static inline void skb_gro_flush_final(struct sk_buff skb, struct sk_buff pp, int flush)	2811	static inline void skb_gro_flush_final(struct sk_buff skb, struct sk_buff pp, int flush)
2801	{	2812	{
2802	NAPI_GRO_CB(skb)->flush \|= flush;	2813	NAPI_GRO_CB(skb)->flush \|= flush;
2803	}	2814	}
		2815	static inline void skb_gro_flush_final_remcsum(struct sk_buff *skb,
		2816	struct sk_buff *pp,
		2817	int flush,
		2818	struct gro_remcsum *grc)
		2819	{
		2820	NAPI_GRO_CB(skb)->flush \|= flush;
		2821	skb_gro_remcsum_cleanup(skb, grc);
		2822	skb->remcsum_offload = 0;
		2823	}
2804	#endif	2824	#endif
2805		2825
2806	static inline int dev_hard_header(struct sk_buff skb, struct net_device dev,	2826	static inline int dev_hard_header(struct sk_buff skb, struct net_device dev,

include/linux/pm_domain.h+3−3

@@ -234,7 +234,7 @@ struct generic_pm_domain of_genpd_remove_last(struct device_node np); · 233 unmodified lines
234	int of_genpd_parse_idle_states(struct device_node *dn,	234	int of_genpd_parse_idle_states(struct device_node *dn,
235	struct genpd_power_state *states, int n);	235	struct genpd_power_state *states, int n);
236	unsigned int of_genpd_opp_to_performance_state(struct device *dev,	236	unsigned int of_genpd_opp_to_performance_state(struct device *dev,
237	struct device_node *opp_node);	237	struct device_node *np);
238		238
239	int genpd_dev_pm_attach(struct device *dev);	239	int genpd_dev_pm_attach(struct device *dev);
240	struct device genpd_dev_pm_attach_by_id(struct device dev,	240	struct device genpd_dev_pm_attach_by_id(struct device dev,
@@ -274,9 +274,9 @@ static inline int of_genpd_parse_idle_states(struct device_node *dn, · 33 unmodified lines
274		274
275	static inline unsigned int	275	static inline unsigned int
276	of_genpd_opp_to_performance_state(struct device *dev,	276	of_genpd_opp_to_performance_state(struct device *dev,
277	struct device_node *opp_node)	277	struct device_node *np)
278	{	278	{
279	return -ENODEV;	279	return 0;
280	}	280	}
281		281
282	static inline int genpd_dev_pm_attach(struct device *dev)	282	static inline int genpd_dev_pm_attach(struct device *dev)

include/linux/poll.h+6−6

 	pt->_key   = ~(__poll_t)0; /* all events enabled */
 }
-static inline bool file_has_poll_mask(struct file *file)
+static inline bool file_can_poll(struct file *file)
 {
-	return file->f_op->get_poll_head && file->f_op->poll_mask;
+	return file->f_op->poll;
 }
-static inline bool file_can_poll(struct file *file)
+static inline __poll_t vfs_poll(struct file *file, struct poll_table_struct *pt)
 {
-	return file->f_op->poll || file_has_poll_mask(file);
+	if (unlikely(!file->f_op->poll))
+		return DEFAULT_POLLMASK;
+	return file->f_op->poll(file, pt);
 }
-__poll_t vfs_poll(struct file *file, struct poll_table_struct *pt);
 struct poll_table_entry {
 	struct file *filp;
 	__poll_t key;

include/linux/rmi.h+2−0

@@ -354,6 +354,8 @@ struct rmi_driver_data { · 353 unmodified lines
354	struct mutex irq_mutex;	354	struct mutex irq_mutex;
355	struct input_dev *input;	355	struct input_dev *input;
356		356
		357	struct irq_domain *irqdomain;
		358
357	u8 pdt_props;	359	u8 pdt_props;
358		360
359	u8 num_rx_electrodes;	361	u8 num_rx_electrodes;

include/linux/scatterlist.h+0−18

 #include <asm/io.h>
 struct scatterlist {
-#ifdef CONFIG_DEBUG_SG
-	unsigned long	sg_magic;
-#endif
 	unsigned long	page_link;
 	unsigned int	offset;
 	unsigned int	length;
  *
  */
-#define SG_MAGIC	0x87654321
 #define SG_CHAIN	0x01UL
 #define SG_END		0x02UL
 	 */
 	BUG_ON((unsigned long) page & (SG_CHAIN | SG_END));
 #ifdef CONFIG_DEBUG_SG
-	BUG_ON(sg->sg_magic != SG_MAGIC);
 	BUG_ON(sg_is_chain(sg));
 #endif
 	sg->page_link = page_link | (unsigned long) page;
 static inline struct page *sg_page(struct scatterlist *sg)
 {
 #ifdef CONFIG_DEBUG_SG
-	BUG_ON(sg->sg_magic != SG_MAGIC);
 	BUG_ON(sg_is_chain(sg));
 #endif
 	return (struct page *)((sg)->page_link & ~(SG_CHAIN | SG_END));
  **/
 static inline void sg_mark_end(struct scatterlist *sg)
 {
-#ifdef CONFIG_DEBUG_SG
-	BUG_ON(sg->sg_magic != SG_MAGIC);
-#endif
 	/*
 	 * Set termination bit, clear potential chain bit
 	 */
  **/
 static inline void sg_unmark_end(struct scatterlist *sg)
 {
-#ifdef CONFIG_DEBUG_SG
-	BUG_ON(sg->sg_magic != SG_MAGIC);
-#endif
 	sg->page_link &= ~SG_END;
 }
 static inline void sg_init_marker(struct scatterlist *sgl,
 				  unsigned int nents)
 {
-#ifdef CONFIG_DEBUG_SG
-	unsigned int i;
-	for (i = 0; i < nents; i++)
-		sgl[i].sg_magic = SG_MAGIC;
-#endif
 	sg_mark_end(&sgl[nents - 1]);
 }

include/linux/skbuff.h+2−1

 				    int *peeked, int *off, int *err);
 struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags, int noblock,
 				  int *err);
-__poll_t datagram_poll_mask(struct socket *sock, __poll_t events);
+__poll_t datagram_poll(struct file *file, struct socket *sock,
+			   struct poll_table_struct *wait);
 int skb_copy_datagram_iter(const struct sk_buff *from, int offset,
 			   struct iov_iter *to, int size);
 static inline int skb_copy_datagram_msg(const struct sk_buff *from, int offset,

include/linux/slub_def.h+4−0

 #ifdef CONFIG_SYSFS
 #define SLAB_SUPPORTS_SYSFS
+void sysfs_slab_unlink(struct kmem_cache *);
 void sysfs_slab_release(struct kmem_cache *);
 #else
+static inline void sysfs_slab_unlink(struct kmem_cache *s)
+{
+}
 static inline void sysfs_slab_release(struct kmem_cache *s)
 {
 }

include/linux/syscalls.h+4−0

  */
 #ifndef __SYSCALL_DEFINEx
 #define __SYSCALL_DEFINEx(x, name, ...)					\
+	__diag_push();							\
+	__diag_ignore(GCC, 8, "-Wattribute-alias",			\
+		      "Type aliasing is used to sanitize syscall arguments");\
 	asmlinkage long sys##name(__MAP(x,__SC_DECL,__VA_ARGS__))	\
 		__attribute__((alias(__stringify(__se_sys##name))));	\
 	ALLOW_ERROR_INJECTION(sys##name, ERRNO);			\
 		__PROTECT(x, ret,__MAP(x,__SC_ARGS,__VA_ARGS__));	\
 		return ret;						\
 	}								\
+	__diag_pop();							\
 	static inline long __do_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__))
 #endif /* __SYSCALL_DEFINEx */

include/net/bluetooth/bluetooth.h+1−1

@@ -271,7 +271,7 @@ int bt_sock_recvmsg(struct socket sock, struct msghdr msg, size_t len, · 270 unmodified lines
271	int flags);	271	int flags);
272	int bt_sock_stream_recvmsg(struct socket sock, struct msghdr msg,	272	int bt_sock_stream_recvmsg(struct socket sock, struct msghdr msg,
273	size_t len, int flags);	273	size_t len, int flags);
274	__poll_t bt_sock_poll_mask(struct socket *sock, __poll_t events);	274	__poll_t bt_sock_poll(struct file file, struct socket sock, poll_table *wait);
275	int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg);	275	int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg);
276	int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo);	276	int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo);
277	int bt_sock_wait_ready(struct sock *sk, unsigned long flags);	277	int bt_sock_wait_ready(struct sock *sk, unsigned long flags);

include/net/iucv/af_iucv.h+2−0

@@ -153,6 +153,8 @@ struct iucv_sock_list { · 152 unmodified lines
153	atomic_t autobind_name;	153	atomic_t autobind_name;
154	};	154	};
155		155
		156	__poll_t iucv_sock_poll(struct file file, struct socket sock,
		157	poll_table *wait);
156	void iucv_sock_link(struct iucv_sock_list l, struct sock s);	158	void iucv_sock_link(struct iucv_sock_list l, struct sock s);
157	void iucv_sock_unlink(struct iucv_sock_list l, struct sock s);	159	void iucv_sock_unlink(struct iucv_sock_list l, struct sock s);
158	void iucv_accept_enqueue(struct sock parent, struct sock sk);	160	void iucv_accept_enqueue(struct sock parent, struct sock sk);

include/net/net_namespace.h+1−0

@@ -128,6 +128,7 @@ struct net { · 127 unmodified lines
128	#endif	128	#endif
129	#if IS_ENABLED(CONFIG_NF_DEFRAG_IPV6)	129	#if IS_ENABLED(CONFIG_NF_DEFRAG_IPV6)
130	struct netns_nf_frag nf_frag;	130	struct netns_nf_frag nf_frag;
		131	struct ctl_table_header *nf_frag_frags_hdr;
131	#endif	132	#endif
132	struct sock *nfnl;	133	struct sock *nfnl;
133	struct sock *nfnl_stash;	134	struct sock *nfnl_stash;

include/net/netns/ipv6.h+0−1

@@ -109,7 +109,6 @@ struct netns_ipv6 { · 108 unmodified lines
109		109
110	#if IS_ENABLED(CONFIG_NF_DEFRAG_IPV6)	110	#if IS_ENABLED(CONFIG_NF_DEFRAG_IPV6)
111	struct netns_nf_frag {	111	struct netns_nf_frag {
112	struct netns_sysctl_ipv6 sysctl;
113	struct netns_frags frags;	112	struct netns_frags frags;
114	};	113	};
115	#endif	114	#endif

include/net/pkt_cls.h+5−0

 {
 }
+static inline bool tcf_block_shared(struct tcf_block *block)
+{
+	return false;
+}
 static inline struct Qdisc *tcf_block_q(struct tcf_block *block)
 {
 	return NULL;

include/net/sctp/sctp.h+2−1

 int sctp_inet_listen(struct socket *sock, int backlog);
 void sctp_write_space(struct sock *sk);
 void sctp_data_ready(struct sock *sk);
-__poll_t sctp_poll_mask(struct socket *sock, __poll_t events);
+__poll_t sctp_poll(struct file *file, struct socket *sock,
+		poll_table *wait);
 void sctp_sock_rfree(struct sk_buff *skb);
 void sctp_copy_sock(struct sock *newsk, struct sock *sk,
 		    struct sctp_association *asoc);

include/net/tcp.h+2−1

 void tcp_close(struct sock *sk, long timeout);
 void tcp_init_sock(struct sock *sk);
 void tcp_init_transfer(struct sock *sk, int bpf_op);
-__poll_t tcp_poll_mask(struct socket *sock, __poll_t events);
+__poll_t tcp_poll(struct file *file, struct socket *sock,
+		      struct poll_table_struct *wait);
 int tcp_getsockopt(struct sock *sk, int level, int optname,
 		   char __user *optval, int __user *optlen);
 int tcp_setsockopt(struct sock *sk, int level, int optname,

include/net/tls.h+4−2

 	struct strparser strp;
 	void (*saved_data_ready)(struct sock *sk);
-	__poll_t (*sk_poll_mask)(struct socket *sock, __poll_t events);
+	unsigned int (*sk_poll)(struct file *file, struct socket *sock,
+				struct poll_table_struct *wait);
 	struct sk_buff *recv_pkt;
 	u8 control;
 	bool decrypted;
 void tls_sw_free_resources_rx(struct sock *sk);
 int tls_sw_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
 		   int nonblock, int flags, int *addr_len);
-__poll_t tls_sw_poll_mask(struct socket *sock, __poll_t events);
+unsigned int tls_sw_poll(struct file *file, struct socket *sock,
+			 struct poll_table_struct *wait);
 ssize_t tls_sw_splice_read(struct socket *sock, loff_t *ppos,
 			   struct pipe_inode_info *pipe,
 			   size_t len, unsigned int flags);

include/net/udp.h+1−1

@@ -285,7 +285,7 @@ int udp_init_sock(struct sock *sk); · 284 unmodified lines
285	int udp_pre_connect(struct sock sk, struct sockaddr uaddr, int addr_len);	285	int udp_pre_connect(struct sock sk, struct sockaddr uaddr, int addr_len);
286	int __udp_disconnect(struct sock *sk, int flags);	286	int __udp_disconnect(struct sock *sk, int flags);
287	int udp_disconnect(struct sock *sk, int flags);	287	int udp_disconnect(struct sock *sk, int flags);
288	__poll_t udp_poll_mask(struct socket *sock, __poll_t events);	288	__poll_t udp_poll(struct file file, struct socket sock, poll_table *wait);
289	struct sk_buff skb_udp_tunnel_segment(struct sk_buff skb,	289	struct sk_buff skb_udp_tunnel_segment(struct sk_buff skb,
290	netdev_features_t features,	290	netdev_features_t features,
291	bool is_ipv6);	291	bool is_ipv6);

include/uapi/linux/aio_abi.h+4−2

 	IOCB_CMD_PWRITE = 1,
 	IOCB_CMD_FSYNC = 2,
 	IOCB_CMD_FDSYNC = 3,
-	/* 4 was the experimental IOCB_CMD_PREADX */
+	/* These two are experimental.
-	IOCB_CMD_POLL = 5,
+	 * IOCB_CMD_PREADX = 4,
+	 * IOCB_CMD_POLL = 5,
+	 */
 	IOCB_CMD_NOOP = 6,
 	IOCB_CMD_PREADV = 7,
 	IOCB_CMD_PWRITEV = 8,

include/uapi/linux/bpf.h+23−5

@@ -1857,7 +1857,8 @@ union bpf_attr { · 1856 unmodified lines
1857	* is resolved), the nexthop address is returned in ipv4_dst	1857	* is resolved), the nexthop address is returned in ipv4_dst
1858	* or ipv6_dst based on family, smac is set to mac address of	1858	* or ipv6_dst based on family, smac is set to mac address of
1859	* egress device, dmac is set to nexthop mac address, rt_metric	1859	* egress device, dmac is set to nexthop mac address, rt_metric
1860	* is set to metric from route (IPv4/IPv6 only).	1860	* is set to metric from route (IPv4/IPv6 only), and ifindex
		1861	* is set to the device index of the nexthop from the FIB lookup.
1861	*	1862	*
1862	* plen argument is the size of the passed in struct.	1863	* plen argument is the size of the passed in struct.
1863	* flags argument can be a combination of one or more of the	1864	* flags argument can be a combination of one or more of the
@@ -1873,9 +1874,10 @@ union bpf_attr { · 9 unmodified lines
1873	* ctx is either struct xdp_md for XDP programs or	1874	* ctx is either struct xdp_md for XDP programs or
1874	* struct sk_buff tc cls_act programs.	1875	* struct sk_buff tc cls_act programs.
1875	* Return	1876	* Return
1876	* Egress device index on success, 0 if packet needs to continue	1877	* * < 0 if any input argument is invalid
1877	* up the stack for further processing or a negative error in case	1878	* * 0 on success (packet is forwarded, nexthop neighbor exists)
1878	* of failure.	1879	* * > 0 one of BPF_FIB_LKUP_RET_ codes explaining why the
		1880	* * packet is not forwarded or needs assist from full stack
1879	*	1881	*
1880	* int bpf_sock_hash_update(struct bpf_sock_ops_kern skops, struct bpf_map map, void *key, u64 flags)	1882	* int bpf_sock_hash_update(struct bpf_sock_ops_kern skops, struct bpf_map map, void *key, u64 flags)
1881	* Description	1883	* Description
@@ -2612,6 +2614,18 @@ struct bpf_raw_tracepoint_args { · 730 unmodified lines
2612	#define BPF_FIB_LOOKUP_DIRECT BIT(0)	2614	#define BPF_FIB_LOOKUP_DIRECT BIT(0)
2613	#define BPF_FIB_LOOKUP_OUTPUT BIT(1)	2615	#define BPF_FIB_LOOKUP_OUTPUT BIT(1)
2614		2616
		2617	enum {
		2618	BPF_FIB_LKUP_RET_SUCCESS, /* lookup successful */
		2619	BPF_FIB_LKUP_RET_BLACKHOLE, /* dest is blackholed; can be dropped */
		2620	BPF_FIB_LKUP_RET_UNREACHABLE, /* dest is unreachable; can be dropped */
		2621	BPF_FIB_LKUP_RET_PROHIBIT, /* dest not allowed; can be dropped */
		2622	BPF_FIB_LKUP_RET_NOT_FWDED, /* packet is not forwarded */
		2623	BPF_FIB_LKUP_RET_FWD_DISABLED, /* fwding is not enabled on ingress */
		2624	BPF_FIB_LKUP_RET_UNSUPP_LWT, /* fwd requires encapsulation */
		2625	BPF_FIB_LKUP_RET_NO_NEIGH, /* no neighbor entry for nh */
		2626	BPF_FIB_LKUP_RET_FRAG_NEEDED, /* fragmentation required to fwd */
		2627	};
		2628
2615	struct bpf_fib_lookup {	2629	struct bpf_fib_lookup {
2616	/* input: network family for lookup (AF_INET, AF_INET6)	2630	/* input: network family for lookup (AF_INET, AF_INET6)
2617	* output: network family of egress nexthop	2631	* output: network family of egress nexthop
@@ -2625,7 +2639,11 @@ struct bpf_fib_lookup { · 7 unmodified lines
2625		2639
2626	/* total length of packet from network header - used for MTU check */	2640	/* total length of packet from network header - used for MTU check */
2627	__u16 tot_len;	2641	__u16 tot_len;
2628	__u32 ifindex; /* L3 device index for lookup */	2642
		2643	/* input: L3 device index for lookup
		2644	* output: device index from FIB lookup
		2645	*/
		2646	__u32 ifindex;
2629		2647
2630	union {	2648	union {
2631	/* inputs to lookup */	2649	/* inputs to lookup */

include/uapi/linux/target_core_user.h+3−1

 #define TCMU_MAILBOX_VERSION 2
 #define ALIGN_SIZE 64 /* Should be enough for most CPUs */
 #define TCMU_MAILBOX_FLAG_CAP_OOOC (1 << 0) /* Out-of-order completions */
+#define TCMU_MAILBOX_FLAG_CAP_READ_LEN (1 << 1) /* Read data length */
 struct tcmu_mailbox {
 	__u16 version;
 	__u16 cmd_id;
 	__u8 kflags;
 #define TCMU_UFLAG_UNKNOWN_OP 0x1
+#define TCMU_UFLAG_READ_LEN   0x2
 	__u8 uflags;
 } __packed;
 			__u8 scsi_status;
 			__u8 __pad1;
 			__u16 __pad2;
-			__u32 __pad3;
+			__u32 read_len;
 			char sense_buffer[TCMU_SENSE_BUFFERSIZE];
 		} rsp;
 	};

init/Kconfig+3−4

 	depends on HAVE_LD_DEAD_CODE_DATA_ELIMINATION
 	depends on EXPERT
 	help
-	  Select this if the architecture wants to do dead code and
+	  Enable this if you want to do dead code and data elimination with
-	  data elimination with the linker by compiling with
+	  the linker by compiling with -ffunction-sections -fdata-sections,
-	  -ffunction-sections -fdata-sections, and linking with
+	  and linking with --gc-sections.
-	  --gc-sections.
 	  This can reduce on disk and in-memory size of the kernel
 	  code and static data, particularly for small configs and

kernel/bpf/cgroup.c+54−0

@@ -428,6 +428,60 @@ int __cgroup_bpf_query(struct cgroup cgrp, const union bpf_attr attr, · 427 unmodified lines
428	return ret;	428	return ret;
429	}	429	}
430		430
		431	int cgroup_bpf_prog_attach(const union bpf_attr *attr,
		432	enum bpf_prog_type ptype, struct bpf_prog *prog)
		433	{
		434	struct cgroup *cgrp;
		435	int ret;
		436
		437	cgrp = cgroup_get_from_fd(attr->target_fd);
		438	if (IS_ERR(cgrp))
		439	return PTR_ERR(cgrp);
		440
		441	ret = cgroup_bpf_attach(cgrp, prog, attr->attach_type,
		442	attr->attach_flags);
		443	cgroup_put(cgrp);
		444	return ret;
		445	}
		446
		447	int cgroup_bpf_prog_detach(const union bpf_attr *attr, enum bpf_prog_type ptype)
		448	{
		449	struct bpf_prog *prog;
		450	struct cgroup *cgrp;
		451	int ret;
		452
		453	cgrp = cgroup_get_from_fd(attr->target_fd);
		454	if (IS_ERR(cgrp))
		455	return PTR_ERR(cgrp);
		456
		457	prog = bpf_prog_get_type(attr->attach_bpf_fd, ptype);
		458	if (IS_ERR(prog))
		459	prog = NULL;
		460
		461	ret = cgroup_bpf_detach(cgrp, prog, attr->attach_type, 0);
		462	if (prog)
		463	bpf_prog_put(prog);
		464
		465	cgroup_put(cgrp);
		466	return ret;
		467	}
		468
		469	int cgroup_bpf_prog_query(const union bpf_attr *attr,
		470	union bpf_attr __user *uattr)
		471	{
		472	struct cgroup *cgrp;
		473	int ret;
		474
		475	cgrp = cgroup_get_from_fd(attr->query.target_fd);
		476	if (IS_ERR(cgrp))
		477	return PTR_ERR(cgrp);
		478
		479	ret = cgroup_bpf_query(cgrp, attr, uattr);
		480
		481	cgroup_put(cgrp);
		482	return ret;
		483	}
		484
431	/**	485	/**
432	* __cgroup_bpf_run_filter_skb() - Run a program for packet filtering	486	* __cgroup_bpf_run_filter_skb() - Run a program for packet filtering
433	* @sk: The socket sending or receiving traffic	487	* @sk: The socket sending or receiving traffic

kernel/bpf/core.c+1−29

@@ -598,8 +598,6 @@ bpf_jit_binary_alloc(unsigned int proglen, u8 **image_ptr, · 597 unmodified lines
598	bpf_fill_ill_insns(hdr, size);	598	bpf_fill_ill_insns(hdr, size);
599		599
600	hdr->pages = size / PAGE_SIZE;	600	hdr->pages = size / PAGE_SIZE;
601	hdr->locked = 0;
602
603	hole = min_t(unsigned int, size - (proglen + sizeof(*hdr)),	601	hole = min_t(unsigned int, size - (proglen + sizeof(*hdr)),
604	PAGE_SIZE - sizeof(*hdr));	602	PAGE_SIZE - sizeof(*hdr));
605	start = (get_random_int() % hole) & ~(alignment - 1);	603	start = (get_random_int() % hole) & ~(alignment - 1);
@@ -1450,22 +1448,6 @@ static int bpf_check_tail_call(const struct bpf_prog *fp) · 844 unmodified lines
1450	return 0;	1448	return 0;
1451	}	1449	}
1452		1450
1453	static int bpf_prog_check_pages_ro_locked(const struct bpf_prog *fp)
1454	{
1455	#ifdef CONFIG_ARCH_HAS_SET_MEMORY
1456	int i, err;
1457
1458	for (i = 0; i < fp->aux->func_cnt; i++) {
1459	err = bpf_prog_check_pages_ro_single(fp->aux->func[i]);
1460	if (err)
1461	return err;
1462	}
1463
1464	return bpf_prog_check_pages_ro_single(fp);
1465	#endif
1466	return 0;
1467	}
1468
1469	static void bpf_prog_select_func(struct bpf_prog *fp)	1451	static void bpf_prog_select_func(struct bpf_prog *fp)
1470	{	1452	{
1471	#ifndef CONFIG_BPF_JIT_ALWAYS_ON	1453	#ifndef CONFIG_BPF_JIT_ALWAYS_ON
@@ -1524,17 +1506,7 @@ finalize: · 52 unmodified lines
1524	* all eBPF JITs might immediately support all features.	1506	* all eBPF JITs might immediately support all features.
1525	*/	1507	*/
1526	*err = bpf_check_tail_call(fp);	1508	*err = bpf_check_tail_call(fp);
1527	if (*err)	1509
1528	return fp;
1529
1530	/* Checkpoint: at this point onwards any cBPF -> eBPF or
1531	* native eBPF program is read-only. If we failed to change
1532	* the page attributes (e.g. allocation failure from
1533	* splitting large pages), then reject the whole program
1534	* in order to guarantee not ending up with any W+X pages
1535	* from BPF side in kernel.
1536	*/
1537	*err = bpf_prog_check_pages_ro_locked(fp);
1538	return fp;	1510	return fp;
1539	}	1511	}
1540	EXPORT_SYMBOL_GPL(bpf_prog_select_runtime);	1512	EXPORT_SYMBOL_GPL(bpf_prog_select_runtime);

kernel/bpf/sockmap.c+184−70

@@ -72,6 +72,7 @@ struct bpf_htab { · 71 unmodified lines
72	u32 n_buckets;	72	u32 n_buckets;
73	u32 elem_size;	73	u32 elem_size;
74	struct bpf_sock_progs progs;	74	struct bpf_sock_progs progs;
		75	struct rcu_head rcu;
75	};	76	};
76		77
77	struct htab_elem {	78	struct htab_elem {
@@ -89,8 +90,8 @@ enum smap_psock_state { · 11 unmodified lines
89	struct smap_psock_map_entry {	90	struct smap_psock_map_entry {
90	struct list_head list;	91	struct list_head list;
91	struct sock **entry;	92	struct sock **entry;
92	struct htab_elem *hash_link;	93	struct htab_elem __rcu *hash_link;
93	struct bpf_htab *htab;	94	struct bpf_htab __rcu *htab;
94	};	95	};
95		96
96	struct smap_psock {	97	struct smap_psock {
@@ -120,6 +121,7 @@ struct smap_psock { · 23 unmodified lines
120	struct bpf_prog *bpf_parse;	121	struct bpf_prog *bpf_parse;
121	struct bpf_prog *bpf_verdict;	122	struct bpf_prog *bpf_verdict;
122	struct list_head maps;	123	struct list_head maps;
		124	spinlock_t maps_lock;
123		125
124	/* Back reference used when sock callback trigger sockmap operations */	126	/* Back reference used when sock callback trigger sockmap operations */
125	struct sock *sock;	127	struct sock *sock;
@@ -140,6 +142,7 @@ static int bpf_tcp_recvmsg(struct sock sk, struct msghdr msg, size_t len, · 14 unmodified lines
140	static int bpf_tcp_sendmsg(struct sock sk, struct msghdr msg, size_t size);	142	static int bpf_tcp_sendmsg(struct sock sk, struct msghdr msg, size_t size);
141	static int bpf_tcp_sendpage(struct sock sk, struct page page,	143	static int bpf_tcp_sendpage(struct sock sk, struct page page,
142	int offset, size_t size, int flags);	144	int offset, size_t size, int flags);
		145	static void bpf_tcp_close(struct sock *sk, long timeout);
143		146
144	static inline struct smap_psock smap_psock_sk(const struct sock sk)	147	static inline struct smap_psock smap_psock_sk(const struct sock sk)
145	{	148	{
@@ -161,7 +164,42 @@ out: · 15 unmodified lines
161	return !empty;	164	return !empty;
162	}	165	}
163		166
164	static struct proto tcp_bpf_proto;	167	enum {
		168	SOCKMAP_IPV4,
		169	SOCKMAP_IPV6,
		170	SOCKMAP_NUM_PROTS,
		171	};
		172
		173	enum {
		174	SOCKMAP_BASE,
		175	SOCKMAP_TX,
		176	SOCKMAP_NUM_CONFIGS,
		177	};
		178
		179	static struct proto *saved_tcpv6_prot __read_mostly;
		180	static DEFINE_SPINLOCK(tcpv6_prot_lock);
		181	static struct proto bpf_tcp_prots[SOCKMAP_NUM_PROTS][SOCKMAP_NUM_CONFIGS];
		182	static void build_protos(struct proto prot[SOCKMAP_NUM_CONFIGS],
		183	struct proto *base)
		184	{
		185	prot[SOCKMAP_BASE] = *base;
		186	prot[SOCKMAP_BASE].close = bpf_tcp_close;
		187	prot[SOCKMAP_BASE].recvmsg = bpf_tcp_recvmsg;
		188	prot[SOCKMAP_BASE].stream_memory_read = bpf_tcp_stream_read;
		189
		190	prot[SOCKMAP_TX] = prot[SOCKMAP_BASE];
		191	prot[SOCKMAP_TX].sendmsg = bpf_tcp_sendmsg;
		192	prot[SOCKMAP_TX].sendpage = bpf_tcp_sendpage;
		193	}
		194
		195	static void update_sk_prot(struct sock sk, struct smap_psock psock)
		196	{
		197	int family = sk->sk_family == AF_INET6 ? SOCKMAP_IPV6 : SOCKMAP_IPV4;
		198	int conf = psock->bpf_tx_msg ? SOCKMAP_TX : SOCKMAP_BASE;
		199
		200	sk->sk_prot = &bpf_tcp_prots[family][conf];
		201	}
		202
165	static int bpf_tcp_init(struct sock *sk)	203	static int bpf_tcp_init(struct sock *sk)
166	{	204	{
167	struct smap_psock *psock;	205	struct smap_psock *psock;
@@ -181,14 +219,17 @@ static int bpf_tcp_init(struct sock *sk) · 13 unmodified lines
181	psock->save_close = sk->sk_prot->close;	219	psock->save_close = sk->sk_prot->close;
182	psock->sk_proto = sk->sk_prot;	220	psock->sk_proto = sk->sk_prot;
183		221
184	if (psock->bpf_tx_msg) {	222	/* Build IPv6 sockmap whenever the address of tcpv6_prot changes */
185	tcp_bpf_proto.sendmsg = bpf_tcp_sendmsg;	223	if (sk->sk_family == AF_INET6 &&
186	tcp_bpf_proto.sendpage = bpf_tcp_sendpage;	224	unlikely(sk->sk_prot != smp_load_acquire(&saved_tcpv6_prot))) {
187	tcp_bpf_proto.recvmsg = bpf_tcp_recvmsg;	225	spin_lock_bh(&tcpv6_prot_lock);
188	tcp_bpf_proto.stream_memory_read = bpf_tcp_stream_read;	226	if (likely(sk->sk_prot != saved_tcpv6_prot)) {
		227	build_protos(bpf_tcp_prots[SOCKMAP_IPV6], sk->sk_prot);
		228	smp_store_release(&saved_tcpv6_prot, sk->sk_prot);
		229	}
		230	spin_unlock_bh(&tcpv6_prot_lock);
189	}	231	}
190		232	update_sk_prot(sk, psock);
191	sk->sk_prot = &tcp_bpf_proto;
192	rcu_read_unlock();	233	rcu_read_unlock();
193	return 0;	234	return 0;
194	}	235	}
@@ -219,16 +260,54 @@ out: · 24 unmodified lines
219	rcu_read_unlock();	260	rcu_read_unlock();
220	}	261	}
221		262
		263	static struct htab_elem lookup_elem_raw(struct hlist_head head,
		264	u32 hash, void *key, u32 key_size)
		265	{
		266	struct htab_elem *l;
		267
		268	hlist_for_each_entry_rcu(l, head, hash_node) {
		269	if (l->hash == hash && !memcmp(&l->key, key, key_size))
		270	return l;
		271	}
		272
		273	return NULL;
		274	}
		275
		276	static inline struct bucket __select_bucket(struct bpf_htab htab, u32 hash)
		277	{
		278	return &htab->buckets[hash & (htab->n_buckets - 1)];
		279	}
		280
		281	static inline struct hlist_head select_bucket(struct bpf_htab htab, u32 hash)
		282	{
		283	return &__select_bucket(htab, hash)->head;
		284	}
		285
222	static void free_htab_elem(struct bpf_htab htab, struct htab_elem l)	286	static void free_htab_elem(struct bpf_htab htab, struct htab_elem l)
223	{	287	{
224	atomic_dec(&htab->count);	288	atomic_dec(&htab->count);
225	kfree_rcu(l, rcu);	289	kfree_rcu(l, rcu);
226	}	290	}
227		291
		292	static struct smap_psock_map_entry psock_map_pop(struct sock sk,
		293	struct smap_psock *psock)
		294	{
		295	struct smap_psock_map_entry *e;
		296
		297	spin_lock_bh(&psock->maps_lock);
		298	e = list_first_entry_or_null(&psock->maps,
		299	struct smap_psock_map_entry,
		300	list);
		301	if (e)
		302	list_del(&e->list);
		303	spin_unlock_bh(&psock->maps_lock);
		304	return e;
		305	}
		306
228	static void bpf_tcp_close(struct sock *sk, long timeout)	307	static void bpf_tcp_close(struct sock *sk, long timeout)
229	{	308	{
230	void (close_fun)(struct sock sk, long timeout);	309	void (close_fun)(struct sock sk, long timeout);
231	struct smap_psock_map_entry e, tmp;	310	struct smap_psock_map_entry *e;
232	struct sk_msg_buff md, mtmp;	311	struct sk_msg_buff md, mtmp;
233	struct smap_psock *psock;	312	struct smap_psock *psock;
234	struct sock *osk;	313	struct sock *osk;
@@ -247,7 +326,6 @@ static void bpf_tcp_close(struct sock *sk, long timeout) · 12 unmodified lines
247	*/	326	*/
248	close_fun = psock->save_close;	327	close_fun = psock->save_close;
249		328
250	write_lock_bh(&sk->sk_callback_lock);
251	if (psock->cork) {	329	if (psock->cork) {
252	free_start_sg(psock->sock, psock->cork);	330	free_start_sg(psock->sock, psock->cork);
253	kfree(psock->cork);	331	kfree(psock->cork);
@@ -260,20 +338,38 @@ static void bpf_tcp_close(struct sock *sk, long timeout) · 6 unmodified lines
260	kfree(md);	338	kfree(md);
261	}	339	}
262		340
263	list_for_each_entry_safe(e, tmp, &psock->maps, list) {	341	e = psock_map_pop(sk, psock);
		342	while (e) {
264	if (e->entry) {	343	if (e->entry) {
265	osk = cmpxchg(e->entry, sk, NULL);	344	osk = cmpxchg(e->entry, sk, NULL);
266	if (osk == sk) {	345	if (osk == sk) {
267	list_del(&e->list);
268	smap_release_sock(psock, sk);	346	smap_release_sock(psock, sk);
269	}	347	}
270	} else {	348	} else {
271	hlist_del_rcu(&e->hash_link->hash_node);	349	struct htab_elem *link = rcu_dereference(e->hash_link);
272	smap_release_sock(psock, e->hash_link->sk);	350	struct bpf_htab *htab = rcu_dereference(e->htab);
273	free_htab_elem(e->htab, e->hash_link);	351	struct hlist_head *head;
		352	struct htab_elem *l;
		353	struct bucket *b;
		354
		355	b = __select_bucket(htab, link->hash);
		356	head = &b->head;
		357	raw_spin_lock_bh(&b->lock);
		358	l = lookup_elem_raw(head,
		359	link->hash, link->key,
		360	htab->map.key_size);
		361	/* If another thread deleted this object skip deletion.
		362	* The refcnt on psock may or may not be zero.
		363	*/
		364	if (l) {
		365	hlist_del_rcu(&link->hash_node);
		366	smap_release_sock(psock, link->sk);
		367	free_htab_elem(htab, link);
		368	}
		369	raw_spin_unlock_bh(&b->lock);
274	}	370	}
		371	e = psock_map_pop(sk, psock);
275	}	372	}
276	write_unlock_bh(&sk->sk_callback_lock);
277	rcu_read_unlock();	373	rcu_read_unlock();
278	close_fun(sk, timeout);	374	close_fun(sk, timeout);
279	}	375	}
@@ -1111,8 +1207,7 @@ static void bpf_tcp_msg_add(struct smap_psock *psock, · 831 unmodified lines
1111		1207
1112	static int bpf_tcp_ulp_register(void)	1208	static int bpf_tcp_ulp_register(void)
1113	{	1209	{
1114	tcp_bpf_proto = tcp_prot;	1210	build_protos(bpf_tcp_prots[SOCKMAP_IPV4], &tcp_prot);
1115	tcp_bpf_proto.close = bpf_tcp_close;
1116	/* Once BPF TX ULP is registered it is never unregistered. It	1211	/* Once BPF TX ULP is registered it is never unregistered. It
1117	* will be in the ULP list for the lifetime of the system. Doing	1212	* will be in the ULP list for the lifetime of the system. Doing
1118	* duplicate registers is not a problem.	1213	* duplicate registers is not a problem.
@@ -1357,7 +1452,9 @@ static void smap_release_sock(struct smap_psock psock, struct sock sock) · 238 unmodified lines
1357	{	1452	{
1358	if (refcount_dec_and_test(&psock->refcnt)) {	1453	if (refcount_dec_and_test(&psock->refcnt)) {
1359	tcp_cleanup_ulp(sock);	1454	tcp_cleanup_ulp(sock);
		1455	write_lock_bh(&sock->sk_callback_lock);
1360	smap_stop_sock(psock, sock);	1456	smap_stop_sock(psock, sock);
		1457	write_unlock_bh(&sock->sk_callback_lock);
1361	clear_bit(SMAP_TX_RUNNING, &psock->state);	1458	clear_bit(SMAP_TX_RUNNING, &psock->state);
1362	rcu_assign_sk_user_data(sock, NULL);	1459	rcu_assign_sk_user_data(sock, NULL);
1363	call_rcu_sched(&psock->rcu, smap_destroy_psock);	1460	call_rcu_sched(&psock->rcu, smap_destroy_psock);
@@ -1508,6 +1605,7 @@ static struct smap_psock smap_init_psock(struct sock sock, int node) · 144 unmodified lines
1508	INIT_LIST_HEAD(&psock->maps);	1605	INIT_LIST_HEAD(&psock->maps);
1509	INIT_LIST_HEAD(&psock->ingress);	1606	INIT_LIST_HEAD(&psock->ingress);
1510	refcount_set(&psock->refcnt, 1);	1607	refcount_set(&psock->refcnt, 1);
		1608	spin_lock_init(&psock->maps_lock);
1511		1609
1512	rcu_assign_sk_user_data(sock, psock);	1610	rcu_assign_sk_user_data(sock, psock);
1513	sock_hold(sock);	1611	sock_hold(sock);
@@ -1564,18 +1662,32 @@ free_stab: · 50 unmodified lines
1564	return ERR_PTR(err);	1662	return ERR_PTR(err);
1565	}	1663	}
1566		1664
1567	static void smap_list_remove(struct smap_psock *psock,	1665	static void smap_list_map_remove(struct smap_psock *psock,
1568	struct sock **entry,	1666	struct sock **entry)
1569	struct htab_elem *hash_link)
1570	{	1667	{
1571	struct smap_psock_map_entry e, tmp;	1668	struct smap_psock_map_entry e, tmp;
1572		1669
		1670	spin_lock_bh(&psock->maps_lock);
1573	list_for_each_entry_safe(e, tmp, &psock->maps, list) {	1671	list_for_each_entry_safe(e, tmp, &psock->maps, list) {
1574	if (e->entry == entry \|\| e->hash_link == hash_link) {	1672	if (e->entry == entry)
1575	list_del(&e->list);	1673	list_del(&e->list);
1576	break;
1577	}
1578	}	1674	}
		1675	spin_unlock_bh(&psock->maps_lock);
		1676	}
		1677
		1678	static void smap_list_hash_remove(struct smap_psock *psock,
		1679	struct htab_elem *hash_link)
		1680	{
		1681	struct smap_psock_map_entry e, tmp;
		1682
		1683	spin_lock_bh(&psock->maps_lock);
		1684	list_for_each_entry_safe(e, tmp, &psock->maps, list) {
		1685	struct htab_elem *c = rcu_dereference(e->hash_link);
		1686
		1687	if (c == hash_link)
		1688	list_del(&e->list);
		1689	}
		1690	spin_unlock_bh(&psock->maps_lock);
1579	}	1691	}
1580		1692
1581	static void sock_map_free(struct bpf_map *map)	1693	static void sock_map_free(struct bpf_map *map)
@@ -1601,7 +1713,6 @@ static void sock_map_free(struct bpf_map *map) · 19 unmodified lines
1601	if (!sock)	1713	if (!sock)
1602	continue;	1714	continue;
1603		1715
1604	write_lock_bh(&sock->sk_callback_lock);
1605	psock = smap_psock_sk(sock);	1716	psock = smap_psock_sk(sock);
1606	/* This check handles a racing sock event that can get the	1717	/* This check handles a racing sock event that can get the
1607	* sk_callback_lock before this case but after xchg happens	1718	* sk_callback_lock before this case but after xchg happens
@@ -1609,10 +1720,9 @@ static void sock_map_free(struct bpf_map *map) · 1 unmodified line
1609	* to be null and queued for garbage collection.	1720	* to be null and queued for garbage collection.
1610	*/	1721	*/
1611	if (likely(psock)) {	1722	if (likely(psock)) {
1612	smap_list_remove(psock, &stab->sock_map[i], NULL);	1723	smap_list_map_remove(psock, &stab->sock_map[i]);
1613	smap_release_sock(psock, sock);	1724	smap_release_sock(psock, sock);
1614	}	1725	}
1615	write_unlock_bh(&sock->sk_callback_lock);
1616	}	1726	}
1617	rcu_read_unlock();	1727	rcu_read_unlock();
1618		1728
@@ -1661,17 +1771,15 @@ static int sock_map_delete_elem(struct bpf_map map, void key) · 42 unmodified lines
1661	if (!sock)	1771	if (!sock)
1662	return -EINVAL;	1772	return -EINVAL;
1663		1773
1664	write_lock_bh(&sock->sk_callback_lock);
1665	psock = smap_psock_sk(sock);	1774	psock = smap_psock_sk(sock);
1666	if (!psock)	1775	if (!psock)
1667	goto out;	1776	goto out;
1668		1777
1669	if (psock->bpf_parse)	1778	if (psock->bpf_parse)
1670	smap_stop_sock(psock, sock);	1779	smap_stop_sock(psock, sock);
1671	smap_list_remove(psock, &stab->sock_map[k], NULL);	1780	smap_list_map_remove(psock, &stab->sock_map[k]);
1672	smap_release_sock(psock, sock);	1781	smap_release_sock(psock, sock);
1673	out:	1782	out:
1674	write_unlock_bh(&sock->sk_callback_lock);
1675	return 0;	1783	return 0;
1676	}	1784	}
1677		1785
@@ -1752,7 +1860,6 @@ static int __sock_map_ctx_update_elem(struct bpf_map *map, · 74 unmodified lines
1752	}	1860	}
1753	}	1861	}
1754		1862
1755	write_lock_bh(&sock->sk_callback_lock);
1756	psock = smap_psock_sk(sock);	1863	psock = smap_psock_sk(sock);
1757		1864
1758	/* 2. Do not allow inheriting programs if psock exists and has	1865	/* 2. Do not allow inheriting programs if psock exists and has
@@ -1809,7 +1916,9 @@ static int __sock_map_ctx_update_elem(struct bpf_map *map, · 50 unmodified lines
1809	if (err)	1916	if (err)
1810	goto out_free;	1917	goto out_free;
1811	smap_init_progs(psock, verdict, parse);	1918	smap_init_progs(psock, verdict, parse);
		1919	write_lock_bh(&sock->sk_callback_lock);
1812	smap_start_sock(psock, sock);	1920	smap_start_sock(psock, sock);
		1921	write_unlock_bh(&sock->sk_callback_lock);
1813	}	1922	}
1814		1923
1815	/* 4. Place psock in sockmap for use and stop any programs on	1924	/* 4. Place psock in sockmap for use and stop any programs on
@@ -1819,9 +1928,10 @@ static int __sock_map_ctx_update_elem(struct bpf_map *map, · 3 unmodified lines
1819	*/	1928	*/
1820	if (map_link) {	1929	if (map_link) {
1821	e->entry = map_link;	1930	e->entry = map_link;
		1931	spin_lock_bh(&psock->maps_lock);
1822	list_add_tail(&e->list, &psock->maps);	1932	list_add_tail(&e->list, &psock->maps);
		1933	spin_unlock_bh(&psock->maps_lock);
1823	}	1934	}
1824	write_unlock_bh(&sock->sk_callback_lock);
1825	return err;	1935	return err;
1826	out_free:	1936	out_free:
1827	smap_release_sock(psock, sock);	1937	smap_release_sock(psock, sock);
@@ -1832,7 +1942,6 @@ out_progs: · 4 unmodified lines
1832	}	1942	}
1833	if (tx_msg)	1943	if (tx_msg)
1834	bpf_prog_put(tx_msg);	1944	bpf_prog_put(tx_msg);
1835	write_unlock_bh(&sock->sk_callback_lock);
1836	kfree(e);	1945	kfree(e);
1837	return err;	1946	return err;
1838	}	1947	}
@@ -1869,10 +1978,8 @@ static int sock_map_ctx_update_elem(struct bpf_sock_ops_kern *skops, · 30 unmodified lines
1869	if (osock) {	1978	if (osock) {
1870	struct smap_psock *opsock = smap_psock_sk(osock);	1979	struct smap_psock *opsock = smap_psock_sk(osock);
1871		1980
1872	write_lock_bh(&osock->sk_callback_lock);	1981	smap_list_map_remove(opsock, &stab->sock_map[i]);
1873	smap_list_remove(opsock, &stab->sock_map[i], NULL);
1874	smap_release_sock(opsock, osock);	1982	smap_release_sock(opsock, osock);
1875	write_unlock_bh(&osock->sk_callback_lock);
1876	}	1983	}
1877	out:	1984	out:
1878	return err;	1985	return err;
@@ -1915,6 +2022,24 @@ int sock_map_prog(struct bpf_map map, struct bpf_prog prog, u32 type) · 36 unmodified lines
1915	return 0;	2022	return 0;
1916	}	2023	}
1917		2024
		2025	int sockmap_get_from_fd(const union bpf_attr *attr, int type,
		2026	struct bpf_prog *prog)
		2027	{
		2028	int ufd = attr->target_fd;
		2029	struct bpf_map *map;
		2030	struct fd f;
		2031	int err;
		2032
		2033	f = fdget(ufd);
		2034	map = __bpf_map_get(f);
		2035	if (IS_ERR(map))
		2036	return PTR_ERR(map);
		2037
		2038	err = sock_map_prog(map, prog, attr->attach_type);
		2039	fdput(f);
		2040	return err;
		2041	}
		2042
1918	static void sock_map_lookup(struct bpf_map map, void *key)	2043	static void sock_map_lookup(struct bpf_map map, void *key)
1919	{	2044	{
1920	return NULL;	2045	return NULL;
@@ -2043,14 +2168,13 @@ free_htab: · 122 unmodified lines
2043	return ERR_PTR(err);	2168	return ERR_PTR(err);
2044	}	2169	}
2045		2170
2046	static inline struct bucket __select_bucket(struct bpf_htab htab, u32 hash)	2171	static void __bpf_htab_free(struct rcu_head *rcu)
2047	{	2172	{
2048	return &htab->buckets[hash & (htab->n_buckets - 1)];	2173	struct bpf_htab *htab;
2049	}
2050		2174
2051	static inline struct hlist_head select_bucket(struct bpf_htab htab, u32 hash)	2175	htab = container_of(rcu, struct bpf_htab, rcu);
2052	{	2176	bpf_map_area_free(htab->buckets);
2053	return &__select_bucket(htab, hash)->head;	2177	kfree(htab);
2054	}	2178	}
2055		2179
2056	static void sock_hash_free(struct bpf_map *map)	2180	static void sock_hash_free(struct bpf_map *map)
@@ -2069,16 +2193,18 @@ static void sock_hash_free(struct bpf_map *map) · 12 unmodified lines
2069	*/	2193	*/
2070	rcu_read_lock();	2194	rcu_read_lock();
2071	for (i = 0; i < htab->n_buckets; i++) {	2195	for (i = 0; i < htab->n_buckets; i++) {
2072	struct hlist_head *head = select_bucket(htab, i);	2196	struct bucket *b = __select_bucket(htab, i);
		2197	struct hlist_head *head;
2073	struct hlist_node *n;	2198	struct hlist_node *n;
2074	struct htab_elem *l;	2199	struct htab_elem *l;
2075		2200
		2201	raw_spin_lock_bh(&b->lock);
		2202	head = &b->head;
2076	hlist_for_each_entry_safe(l, n, head, hash_node) {	2203	hlist_for_each_entry_safe(l, n, head, hash_node) {
2077	struct sock *sock = l->sk;	2204	struct sock *sock = l->sk;
2078	struct smap_psock *psock;	2205	struct smap_psock *psock;
2079		2206
2080	hlist_del_rcu(&l->hash_node);	2207	hlist_del_rcu(&l->hash_node);
2081	write_lock_bh(&sock->sk_callback_lock);
2082	psock = smap_psock_sk(sock);	2208	psock = smap_psock_sk(sock);
2083	/* This check handles a racing sock event that can get	2209	/* This check handles a racing sock event that can get
2084	* the sk_callback_lock before this case but after xchg	2210	* the sk_callback_lock before this case but after xchg
@@ -2086,16 +2212,15 @@ static void sock_hash_free(struct bpf_map *map) · 1 unmodified line
2086	* (psock) to be null and queued for garbage collection.	2212	* (psock) to be null and queued for garbage collection.
2087	*/	2213	*/
2088	if (likely(psock)) {	2214	if (likely(psock)) {
2089	smap_list_remove(psock, NULL, l);	2215	smap_list_hash_remove(psock, l);
2090	smap_release_sock(psock, sock);	2216	smap_release_sock(psock, sock);
2091	}	2217	}
2092	write_unlock_bh(&sock->sk_callback_lock);	2218	free_htab_elem(htab, l);
2093	kfree(l);
2094	}	2219	}
		2220	raw_spin_unlock_bh(&b->lock);
2095	}	2221	}
2096	rcu_read_unlock();	2222	rcu_read_unlock();
2097	bpf_map_area_free(htab->buckets);	2223	call_rcu(&htab->rcu, __bpf_htab_free);
2098	kfree(htab);
2099	}	2224	}
2100		2225
2101	static struct htab_elem alloc_sock_hash_elem(struct bpf_htab htab,	2226	static struct htab_elem alloc_sock_hash_elem(struct bpf_htab htab,
@@ -2122,19 +2247,6 @@ static struct htab_elem alloc_sock_hash_elem(struct bpf_htab htab, · 20 unmodified lines
2122	return l_new;	2247	return l_new;
2123	}	2248	}
2124		2249
2125	static struct htab_elem lookup_elem_raw(struct hlist_head head,
2126	u32 hash, void *key, u32 key_size)
2127	{
2128	struct htab_elem *l;
2129
2130	hlist_for_each_entry_rcu(l, head, hash_node) {
2131	if (l->hash == hash && !memcmp(&l->key, key, key_size))
2132	return l;
2133	}
2134
2135	return NULL;
2136	}
2137
2138	static inline u32 htab_map_hash(const void *key, u32 key_len)	2250	static inline u32 htab_map_hash(const void *key, u32 key_len)
2139	{	2251	{
2140	return jhash(key, key_len, 0);	2252	return jhash(key, key_len, 0);
@@ -2254,9 +2366,12 @@ static int sock_hash_ctx_update_elem(struct bpf_sock_ops_kern *skops, · 113 unmodified lines
2254	goto bucket_err;	2366	goto bucket_err;
2255	}	2367	}
2256		2368
2257	e->hash_link = l_new;	2369	rcu_assign_pointer(e->hash_link, l_new);
2258	e->htab = container_of(map, struct bpf_htab, map);	2370	rcu_assign_pointer(e->htab,
		2371	container_of(map, struct bpf_htab, map));
		2372	spin_lock_bh(&psock->maps_lock);
2259	list_add_tail(&e->list, &psock->maps);	2373	list_add_tail(&e->list, &psock->maps);
		2374	spin_unlock_bh(&psock->maps_lock);
2260		2375
2261	/* add new element to the head of the list, so that	2376	/* add new element to the head of the list, so that
2262	* concurrent search will find it before old elem	2377	* concurrent search will find it before old elem
@@ -2266,7 +2381,7 @@ static int sock_hash_ctx_update_elem(struct bpf_sock_ops_kern *skops, · 3 unmodified lines
2266	psock = smap_psock_sk(l_old->sk);	2381	psock = smap_psock_sk(l_old->sk);
2267		2382
2268	hlist_del_rcu(&l_old->hash_node);	2383	hlist_del_rcu(&l_old->hash_node);
2269	smap_list_remove(psock, NULL, l_old);	2384	smap_list_hash_remove(psock, l_old);
2270	smap_release_sock(psock, l_old->sk);	2385	smap_release_sock(psock, l_old->sk);
2271	free_htab_elem(htab, l_old);	2386	free_htab_elem(htab, l_old);
2272	}	2387	}
@@ -2326,7 +2441,6 @@ static int sock_hash_delete_elem(struct bpf_map map, void key) · 53 unmodified lines
2326	struct smap_psock *psock;	2441	struct smap_psock *psock;
2327		2442
2328	hlist_del_rcu(&l->hash_node);	2443	hlist_del_rcu(&l->hash_node);
2329	write_lock_bh(&sock->sk_callback_lock);
2330	psock = smap_psock_sk(sock);	2444	psock = smap_psock_sk(sock);
2331	/* This check handles a racing sock event that can get the	2445	/* This check handles a racing sock event that can get the
2332	* sk_callback_lock before this case but after xchg happens	2446	* sk_callback_lock before this case but after xchg happens
@@ -2334,10 +2448,9 @@ static int sock_hash_delete_elem(struct bpf_map map, void key) · 1 unmodified line
2334	* to be null and queued for garbage collection.	2448	* to be null and queued for garbage collection.
2335	*/	2449	*/
2336	if (likely(psock)) {	2450	if (likely(psock)) {
2337	smap_list_remove(psock, NULL, l);	2451	smap_list_hash_remove(psock, l);
2338	smap_release_sock(psock, sock);	2452	smap_release_sock(psock, sock);
2339	}	2453	}
2340	write_unlock_bh(&sock->sk_callback_lock);
2341	free_htab_elem(htab, l);	2454	free_htab_elem(htab, l);
2342	ret = 0;	2455	ret = 0;
2343	}	2456	}
@@ -2383,6 +2496,7 @@ const struct bpf_map_ops sock_hash_ops = { · 39 unmodified lines
2383	.map_get_next_key = sock_hash_get_next_key,	2496	.map_get_next_key = sock_hash_get_next_key,
2384	.map_update_elem = sock_hash_update_elem,	2497	.map_update_elem = sock_hash_update_elem,
2385	.map_delete_elem = sock_hash_delete_elem,	2498	.map_delete_elem = sock_hash_delete_elem,
		2499	.map_release_uref = sock_map_release,
2386	};	2500	};
2387		2501
2388	BPF_CALL_4(bpf_sock_map_update, struct bpf_sock_ops_kern *, bpf_sock,	2502	BPF_CALL_4(bpf_sock_map_update, struct bpf_sock_ops_kern *, bpf_sock,

kernel/bpf/syscall.c+21−78

@@ -1483,8 +1483,6 @@ out_free_tp: · 1482 unmodified lines
1483	return err;	1483	return err;
1484	}	1484	}
1485		1485
1486	#ifdef CONFIG_CGROUP_BPF
1487
1488	static int bpf_prog_attach_check_attach_type(const struct bpf_prog *prog,	1486	static int bpf_prog_attach_check_attach_type(const struct bpf_prog *prog,
1489	enum bpf_attach_type attach_type)	1487	enum bpf_attach_type attach_type)
1490	{	1488	{
@@ -1499,40 +1497,6 @@ static int bpf_prog_attach_check_attach_type(const struct bpf_prog *prog, · 8 unmodified lines
1499		1497
1500	#define BPF_PROG_ATTACH_LAST_FIELD attach_flags	1498	#define BPF_PROG_ATTACH_LAST_FIELD attach_flags
1501		1499
1502	static int sockmap_get_from_fd(const union bpf_attr *attr,
1503	int type, bool attach)
1504	{
1505	struct bpf_prog *prog = NULL;
1506	int ufd = attr->target_fd;
1507	struct bpf_map *map;
1508	struct fd f;
1509	int err;
1510
1511	f = fdget(ufd);
1512	map = __bpf_map_get(f);
1513	if (IS_ERR(map))
1514	return PTR_ERR(map);
1515
1516	if (attach) {
1517	prog = bpf_prog_get_type(attr->attach_bpf_fd, type);
1518	if (IS_ERR(prog)) {
1519	fdput(f);
1520	return PTR_ERR(prog);
1521	}
1522	}
1523
1524	err = sock_map_prog(map, prog, attr->attach_type);
1525	if (err) {
1526	fdput(f);
1527	if (prog)
1528	bpf_prog_put(prog);
1529	return err;
1530	}
1531
1532	fdput(f);
1533	return 0;
1534	}
1535
1536	#define BPF_F_ATTACH_MASK \	1500	#define BPF_F_ATTACH_MASK \
1537	(BPF_F_ALLOW_OVERRIDE \| BPF_F_ALLOW_MULTI)	1501	(BPF_F_ALLOW_OVERRIDE \| BPF_F_ALLOW_MULTI)
1538		1502
@@ -1540,7 +1504,6 @@ static int bpf_prog_attach(const union bpf_attr *attr) · 1 unmodified line
1540	{	1504	{
1541	enum bpf_prog_type ptype;	1505	enum bpf_prog_type ptype;
1542	struct bpf_prog *prog;	1506	struct bpf_prog *prog;
1543	struct cgroup *cgrp;
1544	int ret;	1507	int ret;
1545		1508
1546	if (!capable(CAP_NET_ADMIN))	1509	if (!capable(CAP_NET_ADMIN))
@@ -1577,12 +1540,15 @@ static int bpf_prog_attach(const union bpf_attr *attr) · 30 unmodified lines
1577	ptype = BPF_PROG_TYPE_CGROUP_DEVICE;	1540	ptype = BPF_PROG_TYPE_CGROUP_DEVICE;
1578	break;	1541	break;
1579	case BPF_SK_MSG_VERDICT:	1542	case BPF_SK_MSG_VERDICT:
1580	return sockmap_get_from_fd(attr, BPF_PROG_TYPE_SK_MSG, true);	1543	ptype = BPF_PROG_TYPE_SK_MSG;
		1544	break;
1581	case BPF_SK_SKB_STREAM_PARSER:	1545	case BPF_SK_SKB_STREAM_PARSER:
1582	case BPF_SK_SKB_STREAM_VERDICT:	1546	case BPF_SK_SKB_STREAM_VERDICT:
1583	return sockmap_get_from_fd(attr, BPF_PROG_TYPE_SK_SKB, true);	1547	ptype = BPF_PROG_TYPE_SK_SKB;
		1548	break;
1584	case BPF_LIRC_MODE2:	1549	case BPF_LIRC_MODE2:
1585	return lirc_prog_attach(attr);	1550	ptype = BPF_PROG_TYPE_LIRC_MODE2;
		1551	break;
1586	default:	1552	default:
1587	return -EINVAL;	1553	return -EINVAL;
1588	}	1554	}
@@ -1596,18 +1562,20 @@ static int bpf_prog_attach(const union bpf_attr *attr) · 7 unmodified lines
1596	return -EINVAL;	1562	return -EINVAL;
1597	}	1563	}
1598		1564
1599	cgrp = cgroup_get_from_fd(attr->target_fd);	1565	switch (ptype) {
1600	if (IS_ERR(cgrp)) {	1566	case BPF_PROG_TYPE_SK_SKB:
1601	bpf_prog_put(prog);	1567	case BPF_PROG_TYPE_SK_MSG:
1602	return PTR_ERR(cgrp);	1568	ret = sockmap_get_from_fd(attr, ptype, prog);
		1569	break;
		1570	case BPF_PROG_TYPE_LIRC_MODE2:
		1571	ret = lirc_prog_attach(attr, prog);
		1572	break;
		1573	default:
		1574	ret = cgroup_bpf_prog_attach(attr, ptype, prog);
1603	}	1575	}
1604		1576
1605	ret = cgroup_bpf_attach(cgrp, prog, attr->attach_type,
1606	attr->attach_flags);
1607	if (ret)	1577	if (ret)
1608	bpf_prog_put(prog);	1578	bpf_prog_put(prog);
1609	cgroup_put(cgrp);
1610
1611	return ret;	1579	return ret;
1612	}	1580	}
1613		1581
@@ -1616,9 +1584,6 @@ static int bpf_prog_attach(const union bpf_attr *attr) · 2 unmodified lines
1616	static int bpf_prog_detach(const union bpf_attr *attr)	1584	static int bpf_prog_detach(const union bpf_attr *attr)
1617	{	1585	{
1618	enum bpf_prog_type ptype;	1586	enum bpf_prog_type ptype;
1619	struct bpf_prog *prog;
1620	struct cgroup *cgrp;
1621	int ret;
1622		1587
1623	if (!capable(CAP_NET_ADMIN))	1588	if (!capable(CAP_NET_ADMIN))
1624	return -EPERM;	1589	return -EPERM;
@@ -1651,29 +1616,17 @@ static int bpf_prog_detach(const union bpf_attr *attr) · 26 unmodified lines
1651	ptype = BPF_PROG_TYPE_CGROUP_DEVICE;	1616	ptype = BPF_PROG_TYPE_CGROUP_DEVICE;
1652	break;	1617	break;
1653	case BPF_SK_MSG_VERDICT:	1618	case BPF_SK_MSG_VERDICT:
1654	return sockmap_get_from_fd(attr, BPF_PROG_TYPE_SK_MSG, false);	1619	return sockmap_get_from_fd(attr, BPF_PROG_TYPE_SK_MSG, NULL);
1655	case BPF_SK_SKB_STREAM_PARSER:	1620	case BPF_SK_SKB_STREAM_PARSER:
1656	case BPF_SK_SKB_STREAM_VERDICT:	1621	case BPF_SK_SKB_STREAM_VERDICT:
1657	return sockmap_get_from_fd(attr, BPF_PROG_TYPE_SK_SKB, false);	1622	return sockmap_get_from_fd(attr, BPF_PROG_TYPE_SK_SKB, NULL);
1658	case BPF_LIRC_MODE2:	1623	case BPF_LIRC_MODE2:
1659	return lirc_prog_detach(attr);	1624	return lirc_prog_detach(attr);
1660	default:	1625	default:
1661	return -EINVAL;	1626	return -EINVAL;
1662	}	1627	}
1663		1628
1664	cgrp = cgroup_get_from_fd(attr->target_fd);	1629	return cgroup_bpf_prog_detach(attr, ptype);
1665	if (IS_ERR(cgrp))
1666	return PTR_ERR(cgrp);
1667
1668	prog = bpf_prog_get_type(attr->attach_bpf_fd, ptype);
1669	if (IS_ERR(prog))
1670	prog = NULL;
1671
1672	ret = cgroup_bpf_detach(cgrp, prog, attr->attach_type, 0);
1673	if (prog)
1674	bpf_prog_put(prog);
1675	cgroup_put(cgrp);
1676	return ret;
1677	}	1630	}
1678		1631
1679	#define BPF_PROG_QUERY_LAST_FIELD query.prog_cnt	1632	#define BPF_PROG_QUERY_LAST_FIELD query.prog_cnt
@@ -1681,9 +1634,6 @@ static int bpf_prog_detach(const union bpf_attr *attr) · 1 unmodified line
1681	static int bpf_prog_query(const union bpf_attr *attr,	1634	static int bpf_prog_query(const union bpf_attr *attr,
1682	union bpf_attr __user *uattr)	1635	union bpf_attr __user *uattr)
1683	{	1636	{
1684	struct cgroup *cgrp;
1685	int ret;
1686
1687	if (!capable(CAP_NET_ADMIN))	1637	if (!capable(CAP_NET_ADMIN))
1688	return -EPERM;	1638	return -EPERM;
1689	if (CHECK_ATTR(BPF_PROG_QUERY))	1639	if (CHECK_ATTR(BPF_PROG_QUERY))
@@ -1711,14 +1661,9 @@ static int bpf_prog_query(const union bpf_attr *attr, · 21 unmodified lines
1711	default:	1661	default:
1712	return -EINVAL;	1662	return -EINVAL;
1713	}	1663	}
1714	cgrp = cgroup_get_from_fd(attr->query.target_fd);	1664
1715	if (IS_ERR(cgrp))	1665	return cgroup_bpf_prog_query(attr, uattr);
1716	return PTR_ERR(cgrp);
1717	ret = cgroup_bpf_query(cgrp, attr, uattr);
1718	cgroup_put(cgrp);
1719	return ret;
1720	}	1666	}
1721	#endif /* CONFIG_CGROUP_BPF */
1722		1667
1723	#define BPF_PROG_TEST_RUN_LAST_FIELD test.duration	1668	#define BPF_PROG_TEST_RUN_LAST_FIELD test.duration
1724		1669
@@ -2365,7 +2310,6 @@ SYSCALL_DEFINE3(bpf, int, cmd, union bpf_attr __user *, uattr, unsigned int, siz · 640 unmodified lines
2365	case BPF_OBJ_GET:	2310	case BPF_OBJ_GET:
2366	err = bpf_obj_get(&attr);	2311	err = bpf_obj_get(&attr);
2367	break;	2312	break;
2368	#ifdef CONFIG_CGROUP_BPF
2369	case BPF_PROG_ATTACH:	2313	case BPF_PROG_ATTACH:
2370	err = bpf_prog_attach(&attr);	2314	err = bpf_prog_attach(&attr);
2371	break;	2315	break;
@@ -2375,7 +2319,6 @@ SYSCALL_DEFINE3(bpf, int, cmd, union bpf_attr __user *, uattr, unsigned int, siz · 3 unmodified lines
2375	case BPF_PROG_QUERY:	2319	case BPF_PROG_QUERY:
2376	err = bpf_prog_query(&attr, uattr);	2320	err = bpf_prog_query(&attr, uattr);
2377	break;	2321	break;
2378	#endif
2379	case BPF_PROG_TEST_RUN:	2322	case BPF_PROG_TEST_RUN:
2380	err = bpf_prog_test_run(&attr, uattr);	2323	err = bpf_prog_test_run(&attr, uattr);
2381	break;	2324	break;

kernel/dma/swiotlb.c+1−0

@@ -1085,3 +1085,4 @@ const struct dma_map_ops swiotlb_dma_ops = { · 1084 unmodified lines
1085	.unmap_page = swiotlb_unmap_page,	1085	.unmap_page = swiotlb_unmap_page,
1086	.dma_supported = dma_direct_supported,	1086	.dma_supported = dma_direct_supported,
1087	};	1087	};
		1088	EXPORT_SYMBOL(swiotlb_dma_ops);

kernel/events/core.c+1−1

@@ -6482,7 +6482,7 @@ void perf_prepare_sample(struct perf_event_header *header, · 6481 unmodified lines
6482	data->phys_addr = perf_virt_to_phys(data->addr);	6482	data->phys_addr = perf_virt_to_phys(data->addr);
6483	}	6483	}
6484		6484
6485	static void __always_inline	6485	static __always_inline void
6486	__perf_event_output(struct perf_event *event,	6486	__perf_event_output(struct perf_event *event,
6487	struct perf_sample_data *data,	6487	struct perf_sample_data *data,
6488	struct pt_regs *regs,	6488	struct pt_regs *regs,

lib/Kconfig.kasan+1−0

@@ -6,6 +6,7 @@ if HAVE_ARCH_KASAN · 5 unmodified lines
6	config KASAN	6	config KASAN
7	bool "KASan: runtime memory debugger"	7	bool "KASan: runtime memory debugger"
8	depends on SLUB \|\| (SLAB && !DEBUG_SLAB)	8	depends on SLUB \|\| (SLAB && !DEBUG_SLAB)
		9	select SLUB_DEBUG if SLUB
9	select CONSTRUCTORS	10	select CONSTRUCTORS
10	select STACKDEPOT	11	select STACKDEPOT
11	help	12	help

lib/percpu_ida.c+1−1

@@ -141,7 +141,7 @@ int percpu_ida_alloc(struct percpu_ida *pool, int state) · 140 unmodified lines
141	spin_lock_irqsave(&tags->lock, flags);	141	spin_lock_irqsave(&tags->lock, flags);
142		142
143	/* Fastpath */	143	/* Fastpath */
144	if (likely(tags->nr_free >= 0)) {	144	if (likely(tags->nr_free)) {
145	tag = tags->freelist[--tags->nr_free];	145	tag = tags->freelist[--tags->nr_free];
146	spin_unlock_irqrestore(&tags->lock, flags);	146	spin_unlock_irqrestore(&tags->lock, flags);
147	return tag;	147	return tag;

lib/scatterlist.c+0−6

  **/
 struct scatterlist *sg_next(struct scatterlist *sg)
 {
-#ifdef CONFIG_DEBUG_SG
-	BUG_ON(sg->sg_magic != SG_MAGIC);
-#endif
 	if (sg_is_last(sg))
 		return NULL;
 	for_each_sg(sgl, sg, nents, i)
 		ret = sg;
-#ifdef CONFIG_DEBUG_SG
-	BUG_ON(sgl[0].sg_magic != SG_MAGIC);
 	BUG_ON(!sg_is_last(ret));
-#endif
 	return ret;
 }
 EXPORT_SYMBOL(sg_last);

lib/test_bpf.c+20−0

 	{	/* Mainly checking JIT here. */
 		"BPF_MAXINSNS: Ctx heavy transformations",
 		{ },
+#if defined(CONFIG_BPF_JIT_ALWAYS_ON) && defined(CONFIG_S390)
+		CLASSIC | FLAG_EXPECTED_FAIL,
+#else
 		CLASSIC,
+#endif
 		{ },
 		{
 			{  1, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) },
 			{ 10, !!(SKB_VLAN_TCI & VLAN_TAG_PRESENT) }
 		},
 		.fill_helper = bpf_fill_maxinsns6,
+		.expected_errcode = -ENOTSUPP,
 	},
 	{	/* Mainly checking JIT here. */
 		"BPF_MAXINSNS: Call heavy transformations",
 		{ },
+#if defined(CONFIG_BPF_JIT_ALWAYS_ON) && defined(CONFIG_S390)
+		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
+#else
 		CLASSIC | FLAG_NO_DATA,
+#endif
 		{ },
 		{ { 1, 0 }, { 10, 0 } },
 		.fill_helper = bpf_fill_maxinsns7,
+		.expected_errcode = -ENOTSUPP,
 	},
 	{	/* Mainly checking JIT here. */
 		"BPF_MAXINSNS: Jump heavy test",
 	{
 		"BPF_MAXINSNS: exec all MSH",
 		{ },
+#if defined(CONFIG_BPF_JIT_ALWAYS_ON) && defined(CONFIG_S390)
+		CLASSIC | FLAG_EXPECTED_FAIL,
+#else
 		CLASSIC,
+#endif
 		{ 0xfa, 0xfb, 0xfc, 0xfd, },
 		{ { 4, 0xababab83 } },
 		.fill_helper = bpf_fill_maxinsns13,
+		.expected_errcode = -ENOTSUPP,
 	},
 	{
 		"BPF_MAXINSNS: ld_abs+get_processor_id",
 		{ },
+#if defined(CONFIG_BPF_JIT_ALWAYS_ON) && defined(CONFIG_S390)
+		CLASSIC | FLAG_EXPECTED_FAIL,
+#else
 		CLASSIC,
+#endif
 		{ },
 		{ { 1, 0xbee } },
 		.fill_helper = bpf_fill_ld_abs_get_processor_id,
+		.expected_errcode = -ENOTSUPP,
 	},
 	/*
 	 * LD_IND / LD_ABS on fragmented SKBs

lib/test_printf.c+0−7

@@ -260,13 +260,6 @@ plain(void) · 259 unmodified lines
260	{	260	{
261	int err;	261	int err;
262		262
263	/*
264	* Make sure crng is ready. Otherwise we get "(ptrval)" instead
265	* of a hashed address when printing '%p' in plain_hash() and
266	* plain_format().
267	*/
268	wait_for_random_bytes();
269
270	err = plain_hash();	263	err = plain_hash();
271	if (err) {	264	if (err) {
272	pr_warn("plain 'p' does not appear to be hashed\n");	265	pr_warn("plain 'p' does not appear to be hashed\n");

mm/slab_common.c+4−0

 	list_del(&s->list);
 	if (s->flags & SLAB_TYPESAFE_BY_RCU) {
+#ifdef SLAB_SUPPORTS_SYSFS
+		sysfs_slab_unlink(s);
+#endif
 		list_add_tail(&s->list, &slab_caches_to_rcu_destroy);
 		schedule_work(&slab_caches_to_rcu_destroy_work);
 	} else {
 #ifdef SLAB_SUPPORTS_SYSFS
+		sysfs_slab_unlink(s);
 		sysfs_slab_release(s);
 #else
 		slab_kmem_cache_release(s);

mm/slub.c+6−1

 	kset_unregister(s->memcg_kset);
 #endif
 	kobject_uevent(&s->kobj, KOBJ_REMOVE);
-	kobject_del(&s->kobj);
 out:
 	kobject_put(&s->kobj);
 }
 	schedule_work(&s->kobj_remove_work);
 }
+void sysfs_slab_unlink(struct kmem_cache *s)
+{
+	if (slab_state >= FULL)
+		kobject_del(&s->kobj);
+}
 void sysfs_slab_release(struct kmem_cache *s)
 {
 	if (slab_state >= FULL)

mm/vmstat.c+0−2

 		 * to occur in the future. Keep on running the
 		 * update worker thread.
 		 */
-		preempt_disable();
 		queue_delayed_work_on(smp_processor_id(), mm_percpu_wq,
 				this_cpu_ptr(&vmstat_work),
 				round_jiffies_relative(sysctl_stat_interval));
-		preempt_enable();
 	}
 }

net/8021q/vlan.c+1−1

@@ -694,7 +694,7 @@ static struct sk_buff vlan_gro_receive(struct list_head head, · 693 unmodified lines
694	out_unlock:	694	out_unlock:
695	rcu_read_unlock();	695	rcu_read_unlock();
696	out:	696	out:
697	NAPI_GRO_CB(skb)->flush \|= flush;	697	skb_gro_flush_final(skb, pp, flush);
698		698
699	return pp;	699	return pp;
700	}	700	}

net/Makefile+0−4

 obj-$(CONFIG_XFRM)		+= xfrm/
 obj-$(CONFIG_UNIX)		+= unix/
 obj-$(CONFIG_NET)		+= ipv6/
-ifneq ($(CC_CAN_LINK),y)
-$(warning CC cannot link executables. Skipping bpfilter.)
-else
 obj-$(CONFIG_BPFILTER)		+= bpfilter/
-endif
 obj-$(CONFIG_PACKET)		+= packet/
 obj-$(CONFIG_NET_KEY)		+= key/
 obj-$(CONFIG_BRIDGE)		+= bridge/

net/appletalk/ddp.c+1−1

@@ -1869,7 +1869,7 @@ static const struct proto_ops atalk_dgram_ops = { · 1868 unmodified lines
1869	.socketpair = sock_no_socketpair,	1869	.socketpair = sock_no_socketpair,
1870	.accept = sock_no_accept,	1870	.accept = sock_no_accept,
1871	.getname = atalk_getname,	1871	.getname = atalk_getname,
1872	.poll_mask = datagram_poll_mask,	1872	.poll = datagram_poll,
1873	.ioctl = atalk_ioctl,	1873	.ioctl = atalk_ioctl,
1874	#ifdef CONFIG_COMPAT	1874	#ifdef CONFIG_COMPAT
1875	.compat_ioctl = atalk_compat_ioctl,	1875	.compat_ioctl = atalk_compat_ioctl,

net/atm/common.c+8−3

 	return error;
 }
-__poll_t vcc_poll_mask(struct socket *sock, __poll_t events)
+__poll_t vcc_poll(struct file *file, struct socket *sock, poll_table *wait)
 {
 	struct sock *sk = sock->sk;
-	struct atm_vcc *vcc = ATM_SD(sock);
+	struct atm_vcc *vcc;
-	__poll_t mask = 0;
+	__poll_t mask;
+	sock_poll_wait(file, sk_sleep(sk), wait);
+	mask = 0;
+	vcc = ATM_SD(sock);
 	/* exceptional events */
 	if (sk->sk_err)

net/atm/common.h+1−1

@@ -17,7 +17,7 @@ int vcc_connect(struct socket *sock, int itf, short vpi, int vci); · 16 unmodified lines
17	int vcc_recvmsg(struct socket sock, struct msghdr msg, size_t size,	17	int vcc_recvmsg(struct socket sock, struct msghdr msg, size_t size,
18	int flags);	18	int flags);
19	int vcc_sendmsg(struct socket sock, struct msghdr m, size_t total_len);	19	int vcc_sendmsg(struct socket sock, struct msghdr m, size_t total_len);
20	__poll_t vcc_poll_mask(struct socket *sock, __poll_t events);	20	__poll_t vcc_poll(struct file file, struct socket sock, poll_table *wait);
21	int vcc_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg);	21	int vcc_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg);
22	int vcc_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg);	22	int vcc_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg);
23	int vcc_setsockopt(struct socket *sock, int level, int optname,	23	int vcc_setsockopt(struct socket *sock, int level, int optname,

net/atm/pvc.c+1−1

@@ -113,7 +113,7 @@ static const struct proto_ops pvc_proto_ops = { · 112 unmodified lines
113	.socketpair = sock_no_socketpair,	113	.socketpair = sock_no_socketpair,
114	.accept = sock_no_accept,	114	.accept = sock_no_accept,
115	.getname = pvc_getname,	115	.getname = pvc_getname,
116	.poll_mask = vcc_poll_mask,	116	.poll = vcc_poll,
117	.ioctl = vcc_ioctl,	117	.ioctl = vcc_ioctl,
118	#ifdef CONFIG_COMPAT	118	#ifdef CONFIG_COMPAT
119	.compat_ioctl = vcc_compat_ioctl,	119	.compat_ioctl = vcc_compat_ioctl,

net/atm/svc.c+1−1

@@ -636,7 +636,7 @@ static const struct proto_ops svc_proto_ops = { · 635 unmodified lines
636	.socketpair = sock_no_socketpair,	636	.socketpair = sock_no_socketpair,
637	.accept = svc_accept,	637	.accept = svc_accept,
638	.getname = svc_getname,	638	.getname = svc_getname,
639	.poll_mask = vcc_poll_mask,	639	.poll = vcc_poll,
640	.ioctl = svc_ioctl,	640	.ioctl = svc_ioctl,
641	#ifdef CONFIG_COMPAT	641	#ifdef CONFIG_COMPAT
642	.compat_ioctl = svc_compat_ioctl,	642	.compat_ioctl = svc_compat_ioctl,

net/ax25/af_ax25.c+1−1

@@ -1941,7 +1941,7 @@ static const struct proto_ops ax25_proto_ops = { · 1940 unmodified lines
1941	.socketpair = sock_no_socketpair,	1941	.socketpair = sock_no_socketpair,
1942	.accept = ax25_accept,	1942	.accept = ax25_accept,
1943	.getname = ax25_getname,	1943	.getname = ax25_getname,
1944	.poll_mask = datagram_poll_mask,	1944	.poll = datagram_poll,
1945	.ioctl = ax25_ioctl,	1945	.ioctl = ax25_ioctl,
1946	.listen = ax25_listen,	1946	.listen = ax25_listen,
1947	.shutdown = ax25_shutdown,	1947	.shutdown = ax25_shutdown,

net/bluetooth/af_bluetooth.c+5−2

 	return 0;
 }
-__poll_t bt_sock_poll_mask(struct socket *sock, __poll_t events)
+__poll_t bt_sock_poll(struct file *file, struct socket *sock,
+			  poll_table *wait)
 {
 	struct sock *sk = sock->sk;
 	__poll_t mask = 0;
 	BT_DBG("sock %p, sk %p", sock, sk);
+	poll_wait(file, sk_sleep(sk), wait);
 	if (sk->sk_state == BT_LISTEN)
 		return bt_accept_poll(sk);
 	return mask;
 }
-EXPORT_SYMBOL(bt_sock_poll_mask);
+EXPORT_SYMBOL(bt_sock_poll);
 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 {

net/bluetooth/hci_sock.c+1−1

@@ -1975,7 +1975,7 @@ static const struct proto_ops hci_sock_ops = { · 1974 unmodified lines
1975	.sendmsg = hci_sock_sendmsg,	1975	.sendmsg = hci_sock_sendmsg,
1976	.recvmsg = hci_sock_recvmsg,	1976	.recvmsg = hci_sock_recvmsg,
1977	.ioctl = hci_sock_ioctl,	1977	.ioctl = hci_sock_ioctl,
1978	.poll_mask = datagram_poll_mask,	1978	.poll = datagram_poll,
1979	.listen = sock_no_listen,	1979	.listen = sock_no_listen,
1980	.shutdown = sock_no_shutdown,	1980	.shutdown = sock_no_shutdown,
1981	.setsockopt = hci_sock_setsockopt,	1981	.setsockopt = hci_sock_setsockopt,

net/bluetooth/l2cap_sock.c+1−1

@@ -1653,7 +1653,7 @@ static const struct proto_ops l2cap_sock_ops = { · 1652 unmodified lines
1653	.getname = l2cap_sock_getname,	1653	.getname = l2cap_sock_getname,
1654	.sendmsg = l2cap_sock_sendmsg,	1654	.sendmsg = l2cap_sock_sendmsg,
1655	.recvmsg = l2cap_sock_recvmsg,	1655	.recvmsg = l2cap_sock_recvmsg,
1656	.poll_mask = bt_sock_poll_mask,	1656	.poll = bt_sock_poll,
1657	.ioctl = bt_sock_ioctl,	1657	.ioctl = bt_sock_ioctl,
1658	.mmap = sock_no_mmap,	1658	.mmap = sock_no_mmap,
1659	.socketpair = sock_no_socketpair,	1659	.socketpair = sock_no_socketpair,

net/bluetooth/rfcomm/sock.c+1−1

@@ -1049,7 +1049,7 @@ static const struct proto_ops rfcomm_sock_ops = { · 1048 unmodified lines
1049	.setsockopt = rfcomm_sock_setsockopt,	1049	.setsockopt = rfcomm_sock_setsockopt,
1050	.getsockopt = rfcomm_sock_getsockopt,	1050	.getsockopt = rfcomm_sock_getsockopt,
1051	.ioctl = rfcomm_sock_ioctl,	1051	.ioctl = rfcomm_sock_ioctl,
1052	.poll_mask = bt_sock_poll_mask,	1052	.poll = bt_sock_poll,
1053	.socketpair = sock_no_socketpair,	1053	.socketpair = sock_no_socketpair,
1054	.mmap = sock_no_mmap	1054	.mmap = sock_no_mmap
1055	};	1055	};

net/bluetooth/sco.c+1−1

@@ -1197,7 +1197,7 @@ static const struct proto_ops sco_sock_ops = { · 1196 unmodified lines
1197	.getname = sco_sock_getname,	1197	.getname = sco_sock_getname,
1198	.sendmsg = sco_sock_sendmsg,	1198	.sendmsg = sco_sock_sendmsg,
1199	.recvmsg = sco_sock_recvmsg,	1199	.recvmsg = sco_sock_recvmsg,
1200	.poll_mask = bt_sock_poll_mask,	1200	.poll = bt_sock_poll,
1201	.ioctl = bt_sock_ioctl,	1201	.ioctl = bt_sock_ioctl,
1202	.mmap = sock_no_mmap,	1202	.mmap = sock_no_mmap,
1203	.socketpair = sock_no_socketpair,	1203	.socketpair = sock_no_socketpair,

net/bpfilter/Kconfig+1−1

 menuconfig BPFILTER
 	bool "BPF based packet filtering framework (BPFILTER)"
-	default n
 	depends on NET && BPF && INET
 	help
 	  This builds experimental bpfilter framework that is aiming to
 if BPFILTER
 config BPFILTER_UMH
 	tristate "bpfilter kernel module with user mode helper"
+	depends on $(success,$(srctree)/scripts/cc-can-link.sh $(CC))
 	default m
 	help
 	  This builds bpfilter kernel module with embedded user mode helper

net/bpfilter/Makefile+2−15

@@ -15,20 +15,7 @@ ifeq ($(CONFIG_BPFILTER_UMH), y) · 14 unmodified lines
15	HOSTLDFLAGS += -static	15	HOSTLDFLAGS += -static
16	endif	16	endif
17		17
18	# a bit of elf magic to convert bpfilter_umh binary into a binary blob	18	$(obj)/bpfilter_umh_blob.o: $(obj)/bpfilter_umh
19	# inside bpfilter_umh.o elf file referenced by
20	# _binary_net_bpfilter_bpfilter_umh_start symbol
21	# which bpfilter_kern.c passes further into umh blob loader at run-time
22	quiet_cmd_copy_umh = GEN $@
23	cmd_copy_umh = echo ':' > $(obj)/.bpfilter_umh.o.cmd; \
24	$(OBJCOPY) -I binary \
25	`LC_ALL=C $(OBJDUMP) -f net/bpfilter/bpfilter_umh \
26	\|awk -F' \|,' '/file format/{print "-O",$$NF} \
27	/^architecture:/{print "-B",$$2}'` \
28	--rename-section .data=.init.rodata $< $@
29
30	$(obj)/bpfilter_umh.o: $(obj)/bpfilter_umh
31	$(call cmd,copy_umh)
32		19
33	obj-$(CONFIG_BPFILTER_UMH) += bpfilter.o	20	obj-$(CONFIG_BPFILTER_UMH) += bpfilter.o
34	bpfilter-objs += bpfilter_kern.o bpfilter_umh.o	21	bpfilter-objs += bpfilter_kern.o bpfilter_umh_blob.o

net/bpfilter/bpfilter_kern.c+5−6

 #include <linux/file.h>
 #include "msgfmt.h"
-#define UMH_start _binary_net_bpfilter_bpfilter_umh_start
+extern char bpfilter_umh_start;
-#define UMH_end _binary_net_bpfilter_bpfilter_umh_end
+extern char bpfilter_umh_end;
-extern char UMH_start;
-extern char UMH_end;
 static struct umh_info info;
 /* since ip_getsockopt() can run in parallel, serialize access to umh */
 	int err;
 	/* fork usermode process */
-	err = fork_usermode_blob(&UMH_start, &UMH_end - &UMH_start, &info);
+	err = fork_usermode_blob(&bpfilter_umh_start,
+				 &bpfilter_umh_end - &bpfilter_umh_start,
+				 &info);
 	if (err)
 		return err;
 	pr_info("Loaded bpfilter_umh pid %d\n", info.pid);

net/bpfilter/bpfilter_umh_blob.S+7−0

@@ -0,0 +1,7 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	.section .init.rodata, "a"
	3	.global bpfilter_umh_start
	4	bpfilter_umh_start:
	5	.incbin "net/bpfilter/bpfilter_umh"
	6	.global bpfilter_umh_end
	7	bpfilter_umh_end:

net/caif/caif_socket.c+8−4

@@ -934,11 +934,15 @@ static int caif_release(struct socket *sock) · 933 unmodified lines
934	}	934	}
935		935
936	/* Copied from af_unix.c:unix_poll(), added CAIF tx_flow handling */	936	/* Copied from af_unix.c:unix_poll(), added CAIF tx_flow handling */
937	static __poll_t caif_poll_mask(struct socket *sock, __poll_t events)	937	static __poll_t caif_poll(struct file *file,
		938	struct socket sock, poll_table wait)
938	{	939	{
939	struct sock *sk = sock->sk;	940	struct sock *sk = sock->sk;
		941	__poll_t mask;
940	struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);	942	struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
941	__poll_t mask = 0;	943
		944	sock_poll_wait(file, sk_sleep(sk), wait);
		945	mask = 0;
942		946
943	/* exceptional events? */	947	/* exceptional events? */
944	if (sk->sk_err)	948	if (sk->sk_err)
@@ -972,7 +976,7 @@ static const struct proto_ops caif_seqpacket_ops = { · 27 unmodified lines
972	.socketpair = sock_no_socketpair,	976	.socketpair = sock_no_socketpair,
973	.accept = sock_no_accept,	977	.accept = sock_no_accept,
974	.getname = sock_no_getname,	978	.getname = sock_no_getname,
975	.poll_mask = caif_poll_mask,	979	.poll = caif_poll,
976	.ioctl = sock_no_ioctl,	980	.ioctl = sock_no_ioctl,
977	.listen = sock_no_listen,	981	.listen = sock_no_listen,
978	.shutdown = sock_no_shutdown,	982	.shutdown = sock_no_shutdown,
@@ -993,7 +997,7 @@ static const struct proto_ops caif_stream_ops = { · 14 unmodified lines
993	.socketpair = sock_no_socketpair,	997	.socketpair = sock_no_socketpair,
994	.accept = sock_no_accept,	998	.accept = sock_no_accept,
995	.getname = sock_no_getname,	999	.getname = sock_no_getname,
996	.poll_mask = caif_poll_mask,	1000	.poll = caif_poll,
997	.ioctl = sock_no_ioctl,	1001	.ioctl = sock_no_ioctl,
998	.listen = sock_no_listen,	1002	.listen = sock_no_listen,
999	.shutdown = sock_no_shutdown,	1003	.shutdown = sock_no_shutdown,

net/can/bcm.c+1−1

@@ -1660,7 +1660,7 @@ static const struct proto_ops bcm_ops = { · 1659 unmodified lines
1660	.socketpair = sock_no_socketpair,	1660	.socketpair = sock_no_socketpair,
1661	.accept = sock_no_accept,	1661	.accept = sock_no_accept,
1662	.getname = sock_no_getname,	1662	.getname = sock_no_getname,
1663	.poll_mask = datagram_poll_mask,	1663	.poll = datagram_poll,
1664	.ioctl = can_ioctl, /* use can_ioctl() from af_can.c */	1664	.ioctl = can_ioctl, /* use can_ioctl() from af_can.c */
1665	.listen = sock_no_listen,	1665	.listen = sock_no_listen,
1666	.shutdown = sock_no_shutdown,	1666	.shutdown = sock_no_shutdown,

net/can/raw.c+1−1

@@ -843,7 +843,7 @@ static const struct proto_ops raw_ops = { · 842 unmodified lines
843	.socketpair = sock_no_socketpair,	843	.socketpair = sock_no_socketpair,
844	.accept = sock_no_accept,	844	.accept = sock_no_accept,
845	.getname = raw_getname,	845	.getname = raw_getname,
846	.poll_mask = datagram_poll_mask,	846	.poll = datagram_poll,
847	.ioctl = can_ioctl, /* use can_ioctl() from af_can.c */	847	.ioctl = can_ioctl, /* use can_ioctl() from af_can.c */
848	.listen = sock_no_listen,	848	.listen = sock_no_listen,
849	.shutdown = sock_no_shutdown,	849	.shutdown = sock_no_shutdown,

net/core/datagram.c+9−4

 /**
  * 	datagram_poll - generic datagram poll
+ *	@file: file struct
  *	@sock: socket
- *	@events to wait for
+ *	@wait: poll table
  *
  *	Datagram poll: Again totally generic. This also handles
  *	sequenced packet sockets providing the socket receive queue
  *	and you use a different write policy from sock_writeable()
  *	then please supply your own write_space callback.
  */
-__poll_t datagram_poll_mask(struct socket *sock, __poll_t events)
+__poll_t datagram_poll(struct file *file, struct socket *sock,
+			   poll_table *wait)
 {
 	struct sock *sk = sock->sk;
-	__poll_t mask = 0;
+	__poll_t mask;
+	sock_poll_wait(file, sk_sleep(sk), wait);
+	mask = 0;
 	/* exceptional events? */
 	if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
 	return mask;
 }
-EXPORT_SYMBOL(datagram_poll_mask);
+EXPORT_SYMBOL(datagram_poll);

net/core/dev_ioctl.c+2−9

@@ -285,16 +285,9 @@ static int dev_ifsioc(struct net net, struct ifreq ifr, unsigned int cmd) · 284 unmodified lines
285	if (ifr->ifr_qlen < 0)	285	if (ifr->ifr_qlen < 0)
286	return -EINVAL;	286	return -EINVAL;
287	if (dev->tx_queue_len ^ ifr->ifr_qlen) {	287	if (dev->tx_queue_len ^ ifr->ifr_qlen) {
288	unsigned int orig_len = dev->tx_queue_len;	288	err = dev_change_tx_queue_len(dev, ifr->ifr_qlen);
289		289	if (err)
290	dev->tx_queue_len = ifr->ifr_qlen;
291	err = call_netdevice_notifiers(
292	NETDEV_CHANGE_TX_QUEUE_LEN, dev);
293	err = notifier_to_errno(err);
294	if (err) {
295	dev->tx_queue_len = orig_len;
296	return err;	290	return err;
297	}
298	}	291	}
299	return 0;	292	return 0;
300		293

net/core/fib_rules.c+79−1

@@ -416,6 +416,14 @@ static struct fib_rule rule_find(struct fib_rules_ops ops, · 415 unmodified lines
416	if (rule->mark && r->mark != rule->mark)	416	if (rule->mark && r->mark != rule->mark)
417	continue;	417	continue;
418		418
		419	if (rule->suppress_ifgroup != -1 &&
		420	r->suppress_ifgroup != rule->suppress_ifgroup)
		421	continue;
		422
		423	if (rule->suppress_prefixlen != -1 &&
		424	r->suppress_prefixlen != rule->suppress_prefixlen)
		425	continue;
		426
419	if (rule->mark_mask && r->mark_mask != rule->mark_mask)	427	if (rule->mark_mask && r->mark_mask != rule->mark_mask)
420	continue;	428	continue;
421		429
@@ -436,6 +444,9 @@ static struct fib_rule rule_find(struct fib_rules_ops ops, · 14 unmodified lines
436	if (rule->ip_proto && r->ip_proto != rule->ip_proto)	444	if (rule->ip_proto && r->ip_proto != rule->ip_proto)
437	continue;	445	continue;
438		446
		447	if (rule->proto && r->proto != rule->proto)
		448	continue;
		449
439	if (fib_rule_port_range_set(&rule->sport_range) &&	450	if (fib_rule_port_range_set(&rule->sport_range) &&
440	!fib_rule_port_range_compare(&r->sport_range,	451	!fib_rule_port_range_compare(&r->sport_range,
441	&rule->sport_range))	452	&rule->sport_range))
@@ -645,6 +656,73 @@ errout: · 203 unmodified lines
645	return err;	656	return err;
646	}	657	}
647		658
		659	static int rule_exists(struct fib_rules_ops ops, struct fib_rule_hdr frh,
		660	struct nlattr *tb, struct fib_rule rule)
		661	{
		662	struct fib_rule *r;
		663
		664	list_for_each_entry(r, &ops->rules_list, list) {
		665	if (r->action != rule->action)
		666	continue;
		667
		668	if (r->table != rule->table)
		669	continue;
		670
		671	if (r->pref != rule->pref)
		672	continue;
		673
		674	if (memcmp(r->iifname, rule->iifname, IFNAMSIZ))
		675	continue;
		676
		677	if (memcmp(r->oifname, rule->oifname, IFNAMSIZ))
		678	continue;
		679
		680	if (r->mark != rule->mark)
		681	continue;
		682
		683	if (r->suppress_ifgroup != rule->suppress_ifgroup)
		684	continue;
		685
		686	if (r->suppress_prefixlen != rule->suppress_prefixlen)
		687	continue;
		688
		689	if (r->mark_mask != rule->mark_mask)
		690	continue;
		691
		692	if (r->tun_id != rule->tun_id)
		693	continue;
		694
		695	if (r->fr_net != rule->fr_net)
		696	continue;
		697
		698	if (r->l3mdev != rule->l3mdev)
		699	continue;
		700
		701	if (!uid_eq(r->uid_range.start, rule->uid_range.start) \|\|
		702	!uid_eq(r->uid_range.end, rule->uid_range.end))
		703	continue;
		704
		705	if (r->ip_proto != rule->ip_proto)
		706	continue;
		707
		708	if (r->proto != rule->proto)
		709	continue;
		710
		711	if (!fib_rule_port_range_compare(&r->sport_range,
		712	&rule->sport_range))
		713	continue;
		714
		715	if (!fib_rule_port_range_compare(&r->dport_range,
		716	&rule->dport_range))
		717	continue;
		718
		719	if (!ops->compare(r, frh, tb))
		720	continue;
		721	return 1;
		722	}
		723	return 0;
		724	}
		725
648	int fib_nl_newrule(struct sk_buff skb, struct nlmsghdr nlh,	726	int fib_nl_newrule(struct sk_buff skb, struct nlmsghdr nlh,
649	struct netlink_ext_ack *extack)	727	struct netlink_ext_ack *extack)
650	{	728	{
@@ -679,7 +757,7 @@ int fib_nl_newrule(struct sk_buff skb, struct nlmsghdr nlh, · 28 unmodified lines
679	goto errout;	757	goto errout;
680		758
681	if ((nlh->nlmsg_flags & NLM_F_EXCL) &&	759	if ((nlh->nlmsg_flags & NLM_F_EXCL) &&
682	rule_find(ops, frh, tb, rule, user_priority)) {	760	rule_exists(ops, frh, tb, rule)) {
683	err = -EEXIST;	761	err = -EEXIST;
684	goto errout_free;	762	goto errout_free;
685	}	763	}

net/core/filter.c+54−32

 	memcpy(params->smac, dev->dev_addr, ETH_ALEN);
 	params->h_vlan_TCI = 0;
 	params->h_vlan_proto = 0;
+	params->ifindex = dev->ifindex;
-	return dev->ifindex;
+	return 0;
 }
 #endif
 	/* verify forwarding is enabled on this interface */
 	in_dev = __in_dev_get_rcu(dev);
 	if (unlikely(!in_dev || !IN_DEV_FORWARD(in_dev)))
-		return 0;
+		return BPF_FIB_LKUP_RET_FWD_DISABLED;
 	if (flags & BPF_FIB_LOOKUP_OUTPUT) {
 		fl4.flowi4_iif = 1;
 		tb = fib_get_table(net, tbid);
 		if (unlikely(!tb))
-			return 0;
+			return BPF_FIB_LKUP_RET_NOT_FWDED;
 		err = fib_table_lookup(tb, &fl4, &res, FIB_LOOKUP_NOREF);
 	} else {
 		err = fib_lookup(net, &fl4, &res, FIB_LOOKUP_NOREF);
 	}
-	if (err || res.type != RTN_UNICAST)
+	if (err) {
-		return 0;
+		/* map fib lookup errors to RTN_ type */
+		if (err == -EINVAL)
+			return BPF_FIB_LKUP_RET_BLACKHOLE;
+		if (err == -EHOSTUNREACH)
+			return BPF_FIB_LKUP_RET_UNREACHABLE;
+		if (err == -EACCES)
+			return BPF_FIB_LKUP_RET_PROHIBIT;
+		return BPF_FIB_LKUP_RET_NOT_FWDED;
+	}
+	if (res.type != RTN_UNICAST)
+		return BPF_FIB_LKUP_RET_NOT_FWDED;
 	if (res.fi->fib_nhs > 1)
 		fib_select_path(net, &res, &fl4, NULL);
 	if (check_mtu) {
 		mtu = ip_mtu_from_fib_result(&res, params->ipv4_dst);
 		if (params->tot_len > mtu)
-			return 0;
+			return BPF_FIB_LKUP_RET_FRAG_NEEDED;
 	}
 	nh = &res.fi->fib_nh[res.nh_sel];
 	/* do not handle lwt encaps right now */
 	if (nh->nh_lwtstate)
-		return 0;
+		return BPF_FIB_LKUP_RET_UNSUPP_LWT;
 	dev = nh->nh_dev;
-	if (unlikely(!dev))
-		return 0;
 	if (nh->nh_gw)
 		params->ipv4_dst = nh->nh_gw;
 	 * rcu_read_lock_bh is not needed here
 	 */
 	neigh = __ipv4_neigh_lookup_noref(dev, (__force u32)params->ipv4_dst);
-	if (neigh)
+	if (!neigh)
-		return bpf_fib_set_fwd_params(params, neigh, dev);
+		return BPF_FIB_LKUP_RET_NO_NEIGH;
-	return 0;
+	return bpf_fib_set_fwd_params(params, neigh, dev);
 }
 #endif
 	/* link local addresses are never forwarded */
 	if (rt6_need_strict(dst) || rt6_need_strict(src))
-		return 0;
+		return BPF_FIB_LKUP_RET_NOT_FWDED;
 	dev = dev_get_by_index_rcu(net, params->ifindex);
 	if (unlikely(!dev))
 	idev = __in6_dev_get_safely(dev);
 	if (unlikely(!idev || !net->ipv6.devconf_all->forwarding))
-		return 0;
+		return BPF_FIB_LKUP_RET_FWD_DISABLED;
 	if (flags & BPF_FIB_LOOKUP_OUTPUT) {
 		fl6.flowi6_iif = 1;
 		tb = ipv6_stub->fib6_get_table(net, tbid);
 		if (unlikely(!tb))
-			return 0;
+			return BPF_FIB_LKUP_RET_NOT_FWDED;
 		f6i = ipv6_stub->fib6_table_lookup(net, tb, oif, &fl6, strict);
 	} else {
 	}
 	if (unlikely(IS_ERR_OR_NULL(f6i) || f6i == net->ipv6.fib6_null_entry))
-		return 0;
+		return BPF_FIB_LKUP_RET_NOT_FWDED;
+	if (unlikely(f6i->fib6_flags & RTF_REJECT)) {
+		switch (f6i->fib6_type) {
+		case RTN_BLACKHOLE:
+			return BPF_FIB_LKUP_RET_BLACKHOLE;
+		case RTN_UNREACHABLE:
+			return BPF_FIB_LKUP_RET_UNREACHABLE;
+		case RTN_PROHIBIT:
+			return BPF_FIB_LKUP_RET_PROHIBIT;
+		default:
+			return BPF_FIB_LKUP_RET_NOT_FWDED;
+		}
+	}
-	if (unlikely(f6i->fib6_flags & RTF_REJECT ||
+	if (f6i->fib6_type != RTN_UNICAST)
-	    f6i->fib6_type != RTN_UNICAST))
+		return BPF_FIB_LKUP_RET_NOT_FWDED;
-		return 0;
 	if (f6i->fib6_nsiblings && fl6.flowi6_oif == 0)
 		f6i = ipv6_stub->fib6_multipath_select(net, f6i, &fl6,
 	if (check_mtu) {
 		mtu = ipv6_stub->ip6_mtu_from_fib6(f6i, dst, src);
 		if (params->tot_len > mtu)
-			return 0;
+			return BPF_FIB_LKUP_RET_FRAG_NEEDED;
 	}
 	if (f6i->fib6_nh.nh_lwtstate)
-		return 0;
+		return BPF_FIB_LKUP_RET_UNSUPP_LWT;
 	if (f6i->fib6_flags & RTF_GATEWAY)
 		*dst = f6i->fib6_nh.nh_gw;
 	 */
 	neigh = ___neigh_lookup_noref(ipv6_stub->nd_tbl, neigh_key_eq128,
 				      ndisc_hashfn, dst, dev);
-	if (neigh)
+	if (!neigh)
-		return bpf_fib_set_fwd_params(params, neigh, dev);
+		return BPF_FIB_LKUP_RET_NO_NEIGH;
-	return 0;
+	return bpf_fib_set_fwd_params(params, neigh, dev);
 }
 #endif
 	   struct bpf_fib_lookup *, params, int, plen, u32, flags)
 {
 	struct net *net = dev_net(skb->dev);
-	int index = -EAFNOSUPPORT;
+	int rc = -EAFNOSUPPORT;
 	if (plen < sizeof(*params))
 		return -EINVAL;
 	switch (params->family) {
 #if IS_ENABLED(CONFIG_INET)
 	case AF_INET:
-		index = bpf_ipv4_fib_lookup(net, params, flags, false);
+		rc = bpf_ipv4_fib_lookup(net, params, flags, false);
 		break;
 #endif
 #if IS_ENABLED(CONFIG_IPV6)
 	case AF_INET6:
-		index = bpf_ipv6_fib_lookup(net, params, flags, false);
+		rc = bpf_ipv6_fib_lookup(net, params, flags, false);
 		break;
 #endif
 	}
-	if (index > 0) {
+	if (!rc) {
 		struct net_device *dev;
-		dev = dev_get_by_index_rcu(net, index);
+		dev = dev_get_by_index_rcu(net, params->ifindex);
 		if (!is_skb_forwardable(dev, skb))
-			index = 0;
+			rc = BPF_FIB_LKUP_RET_FRAG_NEEDED;
 	}
-	return index;
+	return rc;
 }
 static const struct bpf_func_proto bpf_skb_fib_lookup_proto = {

net/core/skbuff.c+1−2

 			if (npages >= 1 << order) {
 				page = alloc_pages((gfp_mask & ~__GFP_DIRECT_RECLAIM) |
 						   __GFP_COMP |
-						   __GFP_NOWARN |
+						   __GFP_NOWARN,
-						   __GFP_NORETRY,
 						   order);
 				if (page)
 					goto fill_page;

net/core/sock.c+5−2

 	rsk_prot->slab = kmem_cache_create(rsk_prot->slab_name,
 					   rsk_prot->obj_size, 0,
-					   prot->slab_flags, NULL);
+					   SLAB_ACCOUNT | prot->slab_flags,
+					   NULL);
 	if (!rsk_prot->slab) {
 		pr_crit("%s: Can't create request sock SLAB cache!\n",
 	if (alloc_slab) {
 		prot->slab = kmem_cache_create_usercopy(prot->name,
 					prot->obj_size, 0,
-					SLAB_HWCACHE_ALIGN | prot->slab_flags,
+					SLAB_HWCACHE_ALIGN | SLAB_ACCOUNT |
+					prot->slab_flags,
 					prot->useroffset, prot->usersize,
 					NULL);
 				kmem_cache_create(prot->twsk_prot->twsk_slab_name,
 						  prot->twsk_prot->twsk_obj_size,
 						  0,
+						  SLAB_ACCOUNT |
 						  prot->slab_flags,
 						  NULL);
 			if (prot->twsk_prot->twsk_slab == NULL)

net/dccp/dccp.h+2−1

@@ -316,7 +316,8 @@ int dccp_recvmsg(struct sock sk, struct msghdr msg, size_t len, int nonblock, · 315 unmodified lines
316	int flags, int *addr_len);	316	int flags, int *addr_len);
317	void dccp_shutdown(struct sock *sk, int how);	317	void dccp_shutdown(struct sock *sk, int how);
318	int inet_dccp_listen(struct socket *sock, int backlog);	318	int inet_dccp_listen(struct socket *sock, int backlog);
319	__poll_t dccp_poll_mask(struct socket *sock, __poll_t events);	319	__poll_t dccp_poll(struct file file, struct socket sock,
		320	poll_table *wait);
320	int dccp_v4_connect(struct sock sk, struct sockaddr uaddr, int addr_len);	321	int dccp_v4_connect(struct sock sk, struct sockaddr uaddr, int addr_len);
321	void dccp_req_err(struct sock *sk, u64 seq);	322	void dccp_req_err(struct sock *sk, u64 seq);
322		323

net/dccp/ipv4.c+1−1

@@ -984,7 +984,7 @@ static const struct proto_ops inet_dccp_ops = { · 983 unmodified lines
984	.accept = inet_accept,	984	.accept = inet_accept,
985	.getname = inet_getname,	985	.getname = inet_getname,
986	/* FIXME: work on tcp_poll to rename it to inet_csk_poll */	986	/* FIXME: work on tcp_poll to rename it to inet_csk_poll */
987	.poll_mask = dccp_poll_mask,	987	.poll = dccp_poll,
988	.ioctl = inet_ioctl,	988	.ioctl = inet_ioctl,
989	/* FIXME: work on inet_listen to rename it to sock_common_listen */	989	/* FIXME: work on inet_listen to rename it to sock_common_listen */
990	.listen = inet_dccp_listen,	990	.listen = inet_dccp_listen,

net/dccp/ipv6.c+1−1

@@ -1070,7 +1070,7 @@ static const struct proto_ops inet6_dccp_ops = { · 1069 unmodified lines
1070	.socketpair = sock_no_socketpair,	1070	.socketpair = sock_no_socketpair,
1071	.accept = inet_accept,	1071	.accept = inet_accept,
1072	.getname = inet6_getname,	1072	.getname = inet6_getname,
1073	.poll_mask = dccp_poll_mask,	1073	.poll = dccp_poll,
1074	.ioctl = inet6_ioctl,	1074	.ioctl = inet6_ioctl,
1075	.listen = inet_dccp_listen,	1075	.listen = inet_dccp_listen,
1076	.shutdown = inet_shutdown,	1076	.shutdown = inet_shutdown,

net/dccp/proto.c+11−2

 EXPORT_SYMBOL_GPL(dccp_disconnect);
-__poll_t dccp_poll_mask(struct socket *sock, __poll_t events)
+/*
+ *	Wait for a DCCP event.
+ *
+ *	Note that we don't need to lock the socket, as the upper poll layers
+ *	take care of normal races (between the test and the event) and we don't
+ *	go look at any of the socket buffers directly.
+ */
+__poll_t dccp_poll(struct file *file, struct socket *sock,
+		       poll_table *wait)
 {
 	__poll_t mask;
 	struct sock *sk = sock->sk;
+	sock_poll_wait(file, sk_sleep(sk), wait);
 	if (sk->sk_state == DCCP_LISTEN)
 		return inet_csk_listen_poll(sk);
 	return mask;
 }
-EXPORT_SYMBOL_GPL(dccp_poll_mask);
+EXPORT_SYMBOL_GPL(dccp_poll);
 int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg)
 {

net/decnet/af_decnet.c+3−3

@@ -1207,11 +1207,11 @@ static int dn_getname(struct socket sock, struct sockaddr uaddr,int peer) · 1206 unmodified lines
1207	}	1207	}
1208		1208
1209		1209
1210	static __poll_t dn_poll_mask(struct socket *sock, __poll_t events)	1210	static __poll_t dn_poll(struct file file, struct socket sock, poll_table *wait)
1211	{	1211	{
1212	struct sock *sk = sock->sk;	1212	struct sock *sk = sock->sk;
1213	struct dn_scp *scp = DN_SK(sk);	1213	struct dn_scp *scp = DN_SK(sk);
1214	__poll_t mask = datagram_poll_mask(sock, events);	1214	__poll_t mask = datagram_poll(file, sock, wait);
1215		1215
1216	if (!skb_queue_empty(&scp->other_receive_queue))	1216	if (!skb_queue_empty(&scp->other_receive_queue))
1217	mask \|= EPOLLRDBAND;	1217	mask \|= EPOLLRDBAND;
@@ -2331,7 +2331,7 @@ static const struct proto_ops dn_proto_ops = { · 1113 unmodified lines
2331	.socketpair = sock_no_socketpair,	2331	.socketpair = sock_no_socketpair,
2332	.accept = dn_accept,	2332	.accept = dn_accept,
2333	.getname = dn_getname,	2333	.getname = dn_getname,
2334	.poll_mask = dn_poll_mask,	2334	.poll = dn_poll,
2335	.ioctl = dn_ioctl,	2335	.ioctl = dn_ioctl,
2336	.listen = dn_listen,	2336	.listen = dn_listen,
2337	.shutdown = dn_shutdown,	2337	.shutdown = dn_shutdown,

net/ieee802154/socket.c+2−2

@@ -423,7 +423,7 @@ static const struct proto_ops ieee802154_raw_ops = { · 422 unmodified lines
423	.socketpair = sock_no_socketpair,	423	.socketpair = sock_no_socketpair,
424	.accept = sock_no_accept,	424	.accept = sock_no_accept,
425	.getname = sock_no_getname,	425	.getname = sock_no_getname,
426	.poll_mask = datagram_poll_mask,	426	.poll = datagram_poll,
427	.ioctl = ieee802154_sock_ioctl,	427	.ioctl = ieee802154_sock_ioctl,
428	.listen = sock_no_listen,	428	.listen = sock_no_listen,
429	.shutdown = sock_no_shutdown,	429	.shutdown = sock_no_shutdown,
@@ -969,7 +969,7 @@ static const struct proto_ops ieee802154_dgram_ops = { · 539 unmodified lines
969	.socketpair = sock_no_socketpair,	969	.socketpair = sock_no_socketpair,
970	.accept = sock_no_accept,	970	.accept = sock_no_accept,
971	.getname = sock_no_getname,	971	.getname = sock_no_getname,
972	.poll_mask = datagram_poll_mask,	972	.poll = datagram_poll,
973	.ioctl = ieee802154_sock_ioctl,	973	.ioctl = ieee802154_sock_ioctl,
974	.listen = sock_no_listen,	974	.listen = sock_no_listen,
975	.shutdown = sock_no_shutdown,	975	.shutdown = sock_no_shutdown,

net/ipv4/af_inet.c+4−4

@@ -986,7 +986,7 @@ const struct proto_ops inet_stream_ops = { · 985 unmodified lines
986	.socketpair = sock_no_socketpair,	986	.socketpair = sock_no_socketpair,
987	.accept = inet_accept,	987	.accept = inet_accept,
988	.getname = inet_getname,	988	.getname = inet_getname,
989	.poll_mask = tcp_poll_mask,	989	.poll = tcp_poll,
990	.ioctl = inet_ioctl,	990	.ioctl = inet_ioctl,
991	.listen = inet_listen,	991	.listen = inet_listen,
992	.shutdown = inet_shutdown,	992	.shutdown = inet_shutdown,
@@ -1021,7 +1021,7 @@ const struct proto_ops inet_dgram_ops = { · 28 unmodified lines
1021	.socketpair = sock_no_socketpair,	1021	.socketpair = sock_no_socketpair,
1022	.accept = sock_no_accept,	1022	.accept = sock_no_accept,
1023	.getname = inet_getname,	1023	.getname = inet_getname,
1024	.poll_mask = udp_poll_mask,	1024	.poll = udp_poll,
1025	.ioctl = inet_ioctl,	1025	.ioctl = inet_ioctl,
1026	.listen = sock_no_listen,	1026	.listen = sock_no_listen,
1027	.shutdown = inet_shutdown,	1027	.shutdown = inet_shutdown,
@@ -1042,7 +1042,7 @@ EXPORT_SYMBOL(inet_dgram_ops); · 14 unmodified lines
1042		1042
1043	/*	1043	/*
1044	* For SOCK_RAW sockets; should be the same as inet_dgram_ops but without	1044	* For SOCK_RAW sockets; should be the same as inet_dgram_ops but without
1045	* udp_poll_mask	1045	* udp_poll
1046	*/	1046	*/
1047	static const struct proto_ops inet_sockraw_ops = {	1047	static const struct proto_ops inet_sockraw_ops = {
1048	.family = PF_INET,	1048	.family = PF_INET,
@@ -1053,7 +1053,7 @@ static const struct proto_ops inet_sockraw_ops = { · 4 unmodified lines
1053	.socketpair = sock_no_socketpair,	1053	.socketpair = sock_no_socketpair,
1054	.accept = sock_no_accept,	1054	.accept = sock_no_accept,
1055	.getname = inet_getname,	1055	.getname = inet_getname,
1056	.poll_mask = datagram_poll_mask,	1056	.poll = datagram_poll,
1057	.ioctl = inet_ioctl,	1057	.ioctl = inet_ioctl,
1058	.listen = sock_no_listen,	1058	.listen = sock_no_listen,
1059	.shutdown = inet_shutdown,	1059	.shutdown = inet_shutdown,

net/ipv4/fou.c+1−3

 out_unlock:
 	rcu_read_unlock();
 out:
-	NAPI_GRO_CB(skb)->flush |= flush;
+	skb_gro_flush_final_remcsum(skb, pp, flush, &grc);
-	skb_gro_remcsum_cleanup(skb, &grc);
-	skb->remcsum_offload = 0;
 	return pp;
 }

net/ipv4/gre_offload.c+1−1

@@ -223,7 +223,7 @@ static struct sk_buff gre_gro_receive(struct list_head head, · 222 unmodified lines
223	out_unlock:	223	out_unlock:
224	rcu_read_unlock();	224	rcu_read_unlock();
225	out:	225	out:
226	NAPI_GRO_CB(skb)->flush \|= flush;	226	skb_gro_flush_final(skb, pp, flush);
227		227
228	return pp;	228	return pp;
229	}	229	}

net/ipv4/sysctl_net_ipv4.c+13−5

@@ -265,8 +265,9 @@ static int proc_tcp_fastopen_key(struct ctl_table *table, int write, · 264 unmodified lines
265	ipv4.sysctl_tcp_fastopen);	265	ipv4.sysctl_tcp_fastopen);
266	struct ctl_table tbl = { .maxlen = (TCP_FASTOPEN_KEY_LENGTH * 2 + 10) };	266	struct ctl_table tbl = { .maxlen = (TCP_FASTOPEN_KEY_LENGTH * 2 + 10) };
267	struct tcp_fastopen_context *ctxt;	267	struct tcp_fastopen_context *ctxt;
268	int ret;
269	u32 user_key[4]; /* 16 bytes, matching TCP_FASTOPEN_KEY_LENGTH */	268	u32 user_key[4]; /* 16 bytes, matching TCP_FASTOPEN_KEY_LENGTH */
		269	__le32 key[4];
		270	int ret, i;
270		271
271	tbl.data = kmalloc(tbl.maxlen, GFP_KERNEL);	272	tbl.data = kmalloc(tbl.maxlen, GFP_KERNEL);
272	if (!tbl.data)	273	if (!tbl.data)
@@ -275,11 +276,14 @@ static int proc_tcp_fastopen_key(struct ctl_table *table, int write, · 2 unmodified lines
275	rcu_read_lock();	276	rcu_read_lock();
276	ctxt = rcu_dereference(net->ipv4.tcp_fastopen_ctx);	277	ctxt = rcu_dereference(net->ipv4.tcp_fastopen_ctx);
277	if (ctxt)	278	if (ctxt)
278	memcpy(user_key, ctxt->key, TCP_FASTOPEN_KEY_LENGTH);	279	memcpy(key, ctxt->key, TCP_FASTOPEN_KEY_LENGTH);
279	else	280	else
280	memset(user_key, 0, sizeof(user_key));	281	memset(key, 0, sizeof(key));
281	rcu_read_unlock();	282	rcu_read_unlock();
282		283
		284	for (i = 0; i < ARRAY_SIZE(key); i++)
		285	user_key[i] = le32_to_cpu(key[i]);
		286
283	snprintf(tbl.data, tbl.maxlen, "%08x-%08x-%08x-%08x",	287	snprintf(tbl.data, tbl.maxlen, "%08x-%08x-%08x-%08x",
284	user_key[0], user_key[1], user_key[2], user_key[3]);	288	user_key[0], user_key[1], user_key[2], user_key[3]);
285	ret = proc_dostring(&tbl, write, buffer, lenp, ppos);	289	ret = proc_dostring(&tbl, write, buffer, lenp, ppos);
@@ -290,13 +294,17 @@ static int proc_tcp_fastopen_key(struct ctl_table *table, int write, · 4 unmodified lines
290	ret = -EINVAL;	294	ret = -EINVAL;
291	goto bad_key;	295	goto bad_key;
292	}	296	}
293	tcp_fastopen_reset_cipher(net, NULL, user_key,	297
		298	for (i = 0; i < ARRAY_SIZE(user_key); i++)
		299	key[i] = cpu_to_le32(user_key[i]);
		300
		301	tcp_fastopen_reset_cipher(net, NULL, key,
294	TCP_FASTOPEN_KEY_LENGTH);	302	TCP_FASTOPEN_KEY_LENGTH);
295	}	303	}
296		304
297	bad_key:	305	bad_key:
298	pr_debug("proc FO key set 0x%x-%x-%x-%x <- 0x%s: %u\n",	306	pr_debug("proc FO key set 0x%x-%x-%x-%x <- 0x%s: %u\n",
299	user_key[0], user_key[1], user_key[2], user_key[3],	307	user_key[0], user_key[1], user_key[2], user_key[3],
300	(char *)tbl.data, ret);	308	(char *)tbl.data, ret);
301	kfree(tbl.data);	309	kfree(tbl.data);
302	return ret;	310	return ret;

net/ipv4/tcp.c+17−6

 }
 /*
- * Socket is not locked. We are protected from async events by poll logic and
+ *	Wait for a TCP event.
- * correct handling of state changes made by other threads is impossible in
+ *
- * any case.
+ *	Note that we don't need to lock the socket, as the upper poll layers
+ *	take care of normal races (between the test and the event) and we don't
+ *	go look at any of the socket buffers directly.
  */
-__poll_t tcp_poll_mask(struct socket *sock, __poll_t events)
+__poll_t tcp_poll(struct file *file, struct socket *sock, poll_table *wait)
 {
+	__poll_t mask;
 	struct sock *sk = sock->sk;
 	const struct tcp_sock *tp = tcp_sk(sk);
-	__poll_t mask = 0;
 	int state;
+	sock_poll_wait(file, sk_sleep(sk), wait);
 	state = inet_sk_state_load(sk);
 	if (state == TCP_LISTEN)
 		return inet_csk_listen_poll(sk);
+	/* Socket is not locked. We are protected from async events
+	 * by poll logic and correct handling of state changes
+	 * made by other threads is impossible in any case.
+	 */
+	mask = 0;
 	/*
 	 * EPOLLHUP is certainly not done right. But poll() doesn't
 	 * have a notion of HUP in just one direction, and for a
 	return mask;
 }
-EXPORT_SYMBOL(tcp_poll_mask);
+EXPORT_SYMBOL(tcp_poll);
 int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg)
 {

net/ipv4/tcp_input.c+11−2

 		 * it is probably a retransmit.
 		 */
 		if (tp->ecn_flags & TCP_ECN_SEEN)
-			tcp_enter_quickack_mode(sk, 1);
+			tcp_enter_quickack_mode(sk, 2);
 		break;
 	case INET_ECN_CE:
 		if (tcp_ca_needs_ecn(sk))
 		if (!(tp->ecn_flags & TCP_ECN_DEMAND_CWR)) {
 			/* Better not delay acks, sender can have a very low cwnd */
-			tcp_enter_quickack_mode(sk, 1);
+			tcp_enter_quickack_mode(sk, 2);
 			tp->ecn_flags |= TCP_ECN_DEMAND_CWR;
 		}
 		tp->ecn_flags |= TCP_ECN_SEEN;
 		if (tcp_is_reno(tp)) {
 			tcp_remove_reno_sacks(sk, pkts_acked);
+			/* If any of the cumulatively ACKed segments was
+			 * retransmitted, non-SACK case cannot confirm that
+			 * progress was due to original transmission due to
+			 * lack of TCPCB_SACKED_ACKED bits even if some of
+			 * the packets may have been never retransmitted.
+			 */
+			if (flag & FLAG_RETRANS_DATA_ACKED)
+				flag &= ~FLAG_ORIG_SACK_ACKED;
 		} else {
 			int delta;

net/ipv4/udp.c+5−5

@@ -2591,7 +2591,7 @@ int compat_udp_getsockopt(struct sock *sk, int level, int optname, · 2590 unmodified lines
2591	* udp_poll - wait for a UDP event.	2591	* udp_poll - wait for a UDP event.
2592	* @file - file struct	2592	* @file - file struct
2593	* @sock - socket	2593	* @sock - socket
2594	* @events - events to wait for	2594	* @wait - poll table
2595	*	2595	*
2596	* This is same as datagram poll, except for the special case of	2596	* This is same as datagram poll, except for the special case of
2597	* blocking sockets. If application is using a blocking fd	2597	* blocking sockets. If application is using a blocking fd
@@ -2600,23 +2600,23 @@ int compat_udp_getsockopt(struct sock *sk, int level, int optname, · 2 unmodified lines
2600	* but then block when reading it. Add special case code	2600	* but then block when reading it. Add special case code
2601	* to work around these arguably broken applications.	2601	* to work around these arguably broken applications.
2602	*/	2602	*/
2603	__poll_t udp_poll_mask(struct socket *sock, __poll_t events)	2603	__poll_t udp_poll(struct file file, struct socket sock, poll_table *wait)
2604	{	2604	{
2605	__poll_t mask = datagram_poll_mask(sock, events);	2605	__poll_t mask = datagram_poll(file, sock, wait);
2606	struct sock *sk = sock->sk;	2606	struct sock *sk = sock->sk;
2607		2607
2608	if (!skb_queue_empty(&udp_sk(sk)->reader_queue))	2608	if (!skb_queue_empty(&udp_sk(sk)->reader_queue))
2609	mask \|= EPOLLIN \| EPOLLRDNORM;	2609	mask \|= EPOLLIN \| EPOLLRDNORM;
2610		2610
2611	/* Check for false positives due to checksum errors */	2611	/* Check for false positives due to checksum errors */
2612	if ((mask & EPOLLRDNORM) && !(sock->file->f_flags & O_NONBLOCK) &&	2612	if ((mask & EPOLLRDNORM) && !(file->f_flags & O_NONBLOCK) &&
2613	!(sk->sk_shutdown & RCV_SHUTDOWN) && first_packet_length(sk) == -1)	2613	!(sk->sk_shutdown & RCV_SHUTDOWN) && first_packet_length(sk) == -1)
2614	mask &= ~(EPOLLIN \| EPOLLRDNORM);	2614	mask &= ~(EPOLLIN \| EPOLLRDNORM);
2615		2615
2616	return mask;	2616	return mask;
2617		2617
2618	}	2618	}
2619	EXPORT_SYMBOL(udp_poll_mask);	2619	EXPORT_SYMBOL(udp_poll);
2620		2620
2621	int udp_abort(struct sock *sk, int err)	2621	int udp_abort(struct sock *sk, int err)
2622	{	2622	{

net/ipv4/udp_offload.c+1−1

@@ -395,7 +395,7 @@ unflush: · 394 unmodified lines
395	out_unlock:	395	out_unlock:
396	rcu_read_unlock();	396	rcu_read_unlock();
397	out:	397	out:
398	NAPI_GRO_CB(skb)->flush \|= flush;	398	skb_gro_flush_final(skb, pp, flush);
399	return pp;	399	return pp;
400	}	400	}
401	EXPORT_SYMBOL(udp_gro_receive);	401	EXPORT_SYMBOL(udp_gro_receive);

net/ipv6/addrconf.c+6−3

 			       unsigned long expires, u32 flags)
 {
 	struct fib6_info *f6i;
+	u32 prio;
 	f6i = addrconf_get_prefix_route(&ifp->addr,
 					ifp->prefix_len,
 	if (!f6i)
 		return -ENOENT;
-	if (f6i->fib6_metric != ifp->rt_priority) {
+	prio = ifp->rt_priority ? : IP6_RT_PRIO_ADDRCONF;
+	if (f6i->fib6_metric != prio) {
+		/* delete old one */
+		ip6_del_rt(dev_net(ifp->idev->dev), f6i);
 		/* add new one */
 		addrconf_prefix_route(&ifp->addr, ifp->prefix_len,
 				      ifp->rt_priority, ifp->idev->dev,
 				      expires, flags, GFP_KERNEL);
-		/* delete old one */
-		ip6_del_rt(dev_net(ifp->idev->dev), f6i);
 	} else {
 		if (!expires)
 			fib6_clean_expires(f6i);

net/ipv6/af_inet6.c+2−2

net/ipv6/netfilter/nf_conntrack_reasm.c+3−3

@@ -107,7 +107,7 @@ static int nf_ct_frag6_sysctl_register(struct net *net) · 106 unmodified lines
107	if (hdr == NULL)	107	if (hdr == NULL)
108	goto err_reg;	108	goto err_reg;
109		109
110	net->nf_frag.sysctl.frags_hdr = hdr;	110	net->nf_frag_frags_hdr = hdr;
111	return 0;	111	return 0;
112		112
113	err_reg:	113	err_reg:
@@ -121,8 +121,8 @@ static void __net_exit nf_ct_frags6_sysctl_unregister(struct net *net) · 7 unmodified lines
121	{	121	{
122	struct ctl_table *table;	122	struct ctl_table *table;
123		123
124	table = net->nf_frag.sysctl.frags_hdr->ctl_table_arg;	124	table = net->nf_frag_frags_hdr->ctl_table_arg;
125	unregister_net_sysctl_table(net->nf_frag.sysctl.frags_hdr);	125	unregister_net_sysctl_table(net->nf_frag_frags_hdr);
126	if (!net_eq(net, &init_net))	126	if (!net_eq(net, &init_net))
127	kfree(table);	127	kfree(table);
128	}	128	}

net/ipv6/raw.c+2−2

@@ -1334,7 +1334,7 @@ void raw6_proc_exit(void) · 1333 unmodified lines
1334	}	1334	}
1335	#endif /* CONFIG_PROC_FS */	1335	#endif /* CONFIG_PROC_FS */
1336		1336
1337	/* Same as inet6_dgram_ops, sans udp_poll_mask. */	1337	/* Same as inet6_dgram_ops, sans udp_poll. */
1338	const struct proto_ops inet6_sockraw_ops = {	1338	const struct proto_ops inet6_sockraw_ops = {
1339	.family = PF_INET6,	1339	.family = PF_INET6,
1340	.owner = THIS_MODULE,	1340	.owner = THIS_MODULE,
@@ -1344,7 +1344,7 @@ const struct proto_ops inet6_sockraw_ops = { · 3 unmodified lines
1344	.socketpair = sock_no_socketpair, /* a do nothing */	1344	.socketpair = sock_no_socketpair, /* a do nothing */
1345	.accept = sock_no_accept, /* a do nothing */	1345	.accept = sock_no_accept, /* a do nothing */
1346	.getname = inet6_getname,	1346	.getname = inet6_getname,
1347	.poll_mask = datagram_poll_mask, /* ok */	1347	.poll = datagram_poll, /* ok */
1348	.ioctl = inet6_ioctl, /* must change */	1348	.ioctl = inet6_ioctl, /* must change */
1349	.listen = sock_no_listen, /* ok */	1349	.listen = sock_no_listen, /* ok */
1350	.shutdown = inet_shutdown, /* ok */	1350	.shutdown = inet_shutdown, /* ok */

net/ipv6/seg6_hmac.c+1−1

@@ -374,7 +374,7 @@ static int seg6_hmac_init_algo(void) · 373 unmodified lines
374	return -ENOMEM;	374	return -ENOMEM;
375		375
376	for_each_possible_cpu(cpu) {	376	for_each_possible_cpu(cpu) {
377	tfm = crypto_alloc_shash(algo->name, 0, GFP_KERNEL);	377	tfm = crypto_alloc_shash(algo->name, 0, 0);
378	if (IS_ERR(tfm))	378	if (IS_ERR(tfm))
379	return PTR_ERR(tfm);	379	return PTR_ERR(tfm);
380	p_tfm = per_cpu_ptr(algo->tfms, cpu);	380	p_tfm = per_cpu_ptr(algo->tfms, cpu);

net/iucv/af_iucv.c+5−2

 	return 0;
 }
-static __poll_t iucv_sock_poll_mask(struct socket *sock, __poll_t events)
+__poll_t iucv_sock_poll(struct file *file, struct socket *sock,
+			    poll_table *wait)
 {
 	struct sock *sk = sock->sk;
 	__poll_t mask = 0;
+	sock_poll_wait(file, sk_sleep(sk), wait);
 	if (sk->sk_state == IUCV_LISTEN)
 		return iucv_accept_poll(sk);
 	.getname	= iucv_sock_getname,
 	.sendmsg	= iucv_sock_sendmsg,
 	.recvmsg	= iucv_sock_recvmsg,
-	.poll_mask	= iucv_sock_poll_mask,
+	.poll		= iucv_sock_poll,
 	.ioctl		= sock_no_ioctl,
 	.mmap		= sock_no_mmap,
 	.socketpair	= sock_no_socketpair,

net/kcm/kcmsock.c+5−5

@@ -1336,9 +1336,9 @@ static void init_kcm_sock(struct kcm_sock kcm, struct kcm_mux mux) · 1335 unmodified lines
1336	struct list_head *head;	1336	struct list_head *head;
1337	int index = 0;	1337	int index = 0;
1338		1338
1339	/* For SOCK_SEQPACKET sock type, datagram_poll_mask checks the sk_state,	1339	/* For SOCK_SEQPACKET sock type, datagram_poll checks the sk_state, so
1340	* so we set sk_state, otherwise epoll_wait always returns right away	1340	* we set sk_state, otherwise epoll_wait always returns right away with
1341	* with EPOLLHUP	1341	* EPOLLHUP
1342	*/	1342	*/
1343	kcm->sk.sk_state = TCP_ESTABLISHED;	1343	kcm->sk.sk_state = TCP_ESTABLISHED;
1344		1344
@@ -1903,7 +1903,7 @@ static const struct proto_ops kcm_dgram_ops = { · 558 unmodified lines
1903	.socketpair = sock_no_socketpair,	1903	.socketpair = sock_no_socketpair,
1904	.accept = sock_no_accept,	1904	.accept = sock_no_accept,
1905	.getname = sock_no_getname,	1905	.getname = sock_no_getname,
1906	.poll_mask = datagram_poll_mask,	1906	.poll = datagram_poll,
1907	.ioctl = kcm_ioctl,	1907	.ioctl = kcm_ioctl,
1908	.listen = sock_no_listen,	1908	.listen = sock_no_listen,
1909	.shutdown = sock_no_shutdown,	1909	.shutdown = sock_no_shutdown,
@@ -1924,7 +1924,7 @@ static const struct proto_ops kcm_seqpacket_ops = { · 14 unmodified lines
1924	.socketpair = sock_no_socketpair,	1924	.socketpair = sock_no_socketpair,
1925	.accept = sock_no_accept,	1925	.accept = sock_no_accept,
1926	.getname = sock_no_getname,	1926	.getname = sock_no_getname,
1927	.poll_mask = datagram_poll_mask,	1927	.poll = datagram_poll,
1928	.ioctl = kcm_ioctl,	1928	.ioctl = kcm_ioctl,
1929	.listen = sock_no_listen,	1929	.listen = sock_no_listen,
1930	.shutdown = sock_no_shutdown,	1930	.shutdown = sock_no_shutdown,

net/key/af_key.c+1−1

@@ -3751,7 +3751,7 @@ static const struct proto_ops pfkey_ops = { · 3750 unmodified lines
3751		3751
3752	/* Now the operations that really occur. */	3752	/* Now the operations that really occur. */
3753	.release = pfkey_release,	3753	.release = pfkey_release,
3754	.poll_mask = datagram_poll_mask,	3754	.poll = datagram_poll,
3755	.sendmsg = pfkey_sendmsg,	3755	.sendmsg = pfkey_sendmsg,
3756	.recvmsg = pfkey_recvmsg,	3756	.recvmsg = pfkey_recvmsg,
3757	};	3757	};

net/l2tp/l2tp_ip.c+1−1

@@ -613,7 +613,7 @@ static const struct proto_ops l2tp_ip_ops = { · 612 unmodified lines
613	.socketpair = sock_no_socketpair,	613	.socketpair = sock_no_socketpair,
614	.accept = sock_no_accept,	614	.accept = sock_no_accept,
615	.getname = l2tp_ip_getname,	615	.getname = l2tp_ip_getname,
616	.poll_mask = datagram_poll_mask,	616	.poll = datagram_poll,
617	.ioctl = inet_ioctl,	617	.ioctl = inet_ioctl,
618	.listen = sock_no_listen,	618	.listen = sock_no_listen,
619	.shutdown = inet_shutdown,	619	.shutdown = inet_shutdown,

net/l2tp/l2tp_ip6.c+1−1

@@ -754,7 +754,7 @@ static const struct proto_ops l2tp_ip6_ops = { · 753 unmodified lines
754	.socketpair = sock_no_socketpair,	754	.socketpair = sock_no_socketpair,
755	.accept = sock_no_accept,	755	.accept = sock_no_accept,
756	.getname = l2tp_ip6_getname,	756	.getname = l2tp_ip6_getname,
757	.poll_mask = datagram_poll_mask,	757	.poll = datagram_poll,
758	.ioctl = inet6_ioctl,	758	.ioctl = inet6_ioctl,
759	.listen = sock_no_listen,	759	.listen = sock_no_listen,
760	.shutdown = inet_shutdown,	760	.shutdown = inet_shutdown,

net/l2tp/l2tp_ppp.c+1−1

@@ -1844,7 +1844,7 @@ static const struct proto_ops pppol2tp_ops = { · 1843 unmodified lines
1844	.socketpair = sock_no_socketpair,	1844	.socketpair = sock_no_socketpair,
1845	.accept = sock_no_accept,	1845	.accept = sock_no_accept,
1846	.getname = pppol2tp_getname,	1846	.getname = pppol2tp_getname,
1847	.poll_mask = datagram_poll_mask,	1847	.poll = datagram_poll,
1848	.listen = sock_no_listen,	1848	.listen = sock_no_listen,
1849	.shutdown = sock_no_shutdown,	1849	.shutdown = sock_no_shutdown,
1850	.setsockopt = pppol2tp_setsockopt,	1850	.setsockopt = pppol2tp_setsockopt,

net/llc/af_llc.c+1−1

@@ -1192,7 +1192,7 @@ static const struct proto_ops llc_ui_ops = { · 1191 unmodified lines
1192	.socketpair = sock_no_socketpair,	1192	.socketpair = sock_no_socketpair,
1193	.accept = llc_ui_accept,	1193	.accept = llc_ui_accept,
1194	.getname = llc_ui_getname,	1194	.getname = llc_ui_getname,
1195	.poll_mask = datagram_poll_mask,	1195	.poll = datagram_poll,
1196	.ioctl = llc_ui_ioctl,	1196	.ioctl = llc_ui_ioctl,
1197	.listen = llc_ui_listen,	1197	.listen = llc_ui_listen,
1198	.shutdown = llc_ui_shutdown,	1198	.shutdown = llc_ui_shutdown,

net/mac80211/tx.c+2−0

@@ -4850,7 +4850,9 @@ int ieee80211_tx_control_port(struct wiphy wiphy, struct net_device dev, · 4849 unmodified lines
4850	skb_reset_network_header(skb);	4850	skb_reset_network_header(skb);
4851	skb_reset_mac_header(skb);	4851	skb_reset_mac_header(skb);
4852		4852
		4853	local_bh_disable();
4853	__ieee80211_subif_start_xmit(skb, skb->dev, flags);	4854	__ieee80211_subif_start_xmit(skb, skb->dev, flags);
		4855	local_bh_enable();
4854		4856
4855	return 0;	4857	return 0;
4856	}	4858	}

net/netfilter/nf_conncount.c+47−5

@@ -47,6 +47,8 @@ struct nf_conncount_tuple { · 46 unmodified lines
47	struct hlist_node node;	47	struct hlist_node node;
48	struct nf_conntrack_tuple tuple;	48	struct nf_conntrack_tuple tuple;
49	struct nf_conntrack_zone zone;	49	struct nf_conntrack_zone zone;
		50	int cpu;
		51	u32 jiffies32;
50	};	52	};
51		53
52	struct nf_conncount_rb {	54	struct nf_conncount_rb {
@@ -91,11 +93,42 @@ bool nf_conncount_add(struct hlist_head *head, · 38 unmodified lines
91	return false;	93	return false;
92	conn->tuple = *tuple;	94	conn->tuple = *tuple;
93	conn->zone = *zone;	95	conn->zone = *zone;
		96	conn->cpu = raw_smp_processor_id();
		97	conn->jiffies32 = (u32)jiffies;
94	hlist_add_head(&conn->node, head);	98	hlist_add_head(&conn->node, head);
95	return true;	99	return true;
96	}	100	}
97	EXPORT_SYMBOL_GPL(nf_conncount_add);	101	EXPORT_SYMBOL_GPL(nf_conncount_add);
98		102
		103	static const struct nf_conntrack_tuple_hash *
		104	find_or_evict(struct net net, struct nf_conncount_tuple conn)
		105	{
		106	const struct nf_conntrack_tuple_hash *found;
		107	unsigned long a, b;
		108	int cpu = raw_smp_processor_id();
		109	__s32 age;
		110
		111	found = nf_conntrack_find_get(net, &conn->zone, &conn->tuple);
		112	if (found)
		113	return found;
		114	b = conn->jiffies32;
		115	a = (u32)jiffies;
		116
		117	/* conn might have been added just before by another cpu and
		118	* might still be unconfirmed. In this case, nf_conntrack_find()
		119	* returns no result. Thus only evict if this cpu added the
		120	* stale entry or if the entry is older than two jiffies.
		121	*/
		122	age = a - b;
		123	if (conn->cpu == cpu \|\| age >= 2) {
		124	hlist_del(&conn->node);
		125	kmem_cache_free(conncount_conn_cachep, conn);
		126	return ERR_PTR(-ENOENT);
		127	}
		128
		129	return ERR_PTR(-EAGAIN);
		130	}
		131
99	unsigned int nf_conncount_lookup(struct net net, struct hlist_head head,	132	unsigned int nf_conncount_lookup(struct net net, struct hlist_head head,
100	const struct nf_conntrack_tuple *tuple,	133	const struct nf_conntrack_tuple *tuple,
101	const struct nf_conntrack_zone *zone,	134	const struct nf_conntrack_zone *zone,
@@ -103,18 +136,27 @@ unsigned int nf_conncount_lookup(struct net net, struct hlist_head head, · 1 unmodified line
103	{	136	{
104	const struct nf_conntrack_tuple_hash *found;	137	const struct nf_conntrack_tuple_hash *found;
105	struct nf_conncount_tuple *conn;	138	struct nf_conncount_tuple *conn;
106	struct hlist_node *n;
107	struct nf_conn *found_ct;	139	struct nf_conn *found_ct;
		140	struct hlist_node *n;
108	unsigned int length = 0;	141	unsigned int length = 0;
109		142
110	*addit = tuple ? true : false;	143	*addit = tuple ? true : false;
111		144
112	/* check the saved connections */	145	/* check the saved connections */
113	hlist_for_each_entry_safe(conn, n, head, node) {	146	hlist_for_each_entry_safe(conn, n, head, node) {
114	found = nf_conntrack_find_get(net, &conn->zone, &conn->tuple);	147	found = find_or_evict(net, conn);
115	if (found == NULL) {	148	if (IS_ERR(found)) {
116	hlist_del(&conn->node);	149	/* Not found, but might be about to be confirmed */
117	kmem_cache_free(conncount_conn_cachep, conn);	150	if (PTR_ERR(found) == -EAGAIN) {
		151	length++;
		152	if (!tuple)
		153	continue;
		154
		155	if (nf_ct_tuple_equal(&conn->tuple, tuple) &&
		156	nf_ct_zone_id(&conn->zone, conn->zone.dir) ==
		157	nf_ct_zone_id(zone, zone->dir))
		158	*addit = false;
		159	}
118	continue;	160	continue;
119	}	161	}
120		162

net/netfilter/nf_conntrack_helper.c+5−0

 	nf_ct_expect_iterate_destroy(expect_iter_me, NULL);
 	nf_ct_iterate_destroy(unhelp, me);
+	/* Maybe someone has gotten the helper already when unhelp above.
+	 * So need to wait it.
+	 */
+	synchronize_rcu();
 }
 EXPORT_SYMBOL_GPL(nf_conntrack_helper_unregister);

net/netfilter/nf_log.c+10−3

 	if (write) {
 		struct ctl_table tmp = *table;
+		/* proc_dostring() can append to existing strings, so we need to
+		 * initialize it as an empty string.
+		 */
+		buf[0] = '\0';
 		tmp.data = buf;
 		r = proc_dostring(&tmp, write, buffer, lenp, ppos);
 		if (r)
 		rcu_assign_pointer(net->nf.nf_loggers[tindex], logger);
 		mutex_unlock(&nf_log_mutex);
 	} else {
+		struct ctl_table tmp = *table;
+		tmp.data = buf;
 		mutex_lock(&nf_log_mutex);
 		logger = nft_log_dereference(net->nf.nf_loggers[tindex]);
 		if (!logger)
-			table->data = "NONE";
+			strlcpy(buf, "NONE", sizeof(buf));
 		else
-			table->data = logger->name;
+			strlcpy(buf, logger->name, sizeof(buf));
-		r = proc_dostring(table, write, buffer, lenp, ppos);
 		mutex_unlock(&nf_log_mutex);
+		r = proc_dostring(&tmp, write, buffer, lenp, ppos);
 	}
 	return r;

net/netfilter/nfnetlink_queue.c+3−0

 static const struct nla_policy nfqa_cfg_policy[NFQA_CFG_MAX+1] = {
 	[NFQA_CFG_CMD]		= { .len = sizeof(struct nfqnl_msg_config_cmd) },
 	[NFQA_CFG_PARAMS]	= { .len = sizeof(struct nfqnl_msg_config_params) },
+	[NFQA_CFG_QUEUE_MAXLEN]	= { .type = NLA_U32 },
+	[NFQA_CFG_MASK]		= { .type = NLA_U32 },
+	[NFQA_CFG_FLAGS]	= { .type = NLA_U32 },
 };
 static const struct nf_queue_handler nfqh = {

net/netlink/af_netlink.c+1−1

@@ -2658,7 +2658,7 @@ static const struct proto_ops netlink_ops = { · 2657 unmodified lines
2658	.socketpair = sock_no_socketpair,	2658	.socketpair = sock_no_socketpair,
2659	.accept = sock_no_accept,	2659	.accept = sock_no_accept,
2660	.getname = netlink_getname,	2660	.getname = netlink_getname,
2661	.poll_mask = datagram_poll_mask,	2661	.poll = datagram_poll,
2662	.ioctl = netlink_ioctl,	2662	.ioctl = netlink_ioctl,
2663	.listen = sock_no_listen,	2663	.listen = sock_no_listen,
2664	.shutdown = sock_no_shutdown,	2664	.shutdown = sock_no_shutdown,

net/netrom/af_netrom.c+1−1

@@ -1355,7 +1355,7 @@ static const struct proto_ops nr_proto_ops = { · 1354 unmodified lines
1355	.socketpair = sock_no_socketpair,	1355	.socketpair = sock_no_socketpair,
1356	.accept = nr_accept,	1356	.accept = nr_accept,
1357	.getname = nr_getname,	1357	.getname = nr_getname,
1358	.poll_mask = datagram_poll_mask,	1358	.poll = datagram_poll,
1359	.ioctl = nr_ioctl,	1359	.ioctl = nr_ioctl,
1360	.listen = nr_listen,	1360	.listen = nr_listen,
1361	.shutdown = sock_no_shutdown,	1361	.shutdown = sock_no_shutdown,

net/nfc/llcp_sock.c+6−3

 	return 0;
 }
-static __poll_t llcp_sock_poll_mask(struct socket *sock, __poll_t events)
+static __poll_t llcp_sock_poll(struct file *file, struct socket *sock,
+				   poll_table *wait)
 {
 	struct sock *sk = sock->sk;
 	__poll_t mask = 0;
 	pr_debug("%p\n", sk);
+	sock_poll_wait(file, sk_sleep(sk), wait);
 	if (sk->sk_state == LLCP_LISTEN)
 		return llcp_accept_poll(sk);
 	.socketpair     = sock_no_socketpair,
 	.accept         = llcp_sock_accept,
 	.getname        = llcp_sock_getname,
-	.poll_mask      = llcp_sock_poll_mask,
+	.poll           = llcp_sock_poll,
 	.ioctl          = sock_no_ioctl,
 	.listen         = llcp_sock_listen,
 	.shutdown       = sock_no_shutdown,
 	.socketpair     = sock_no_socketpair,
 	.accept         = sock_no_accept,
 	.getname        = llcp_sock_getname,
-	.poll_mask      = llcp_sock_poll_mask,
+	.poll           = llcp_sock_poll,
 	.ioctl          = sock_no_ioctl,
 	.listen         = sock_no_listen,
 	.shutdown       = sock_no_shutdown,

net/nfc/rawsock.c+2−2

@@ -284,7 +284,7 @@ static const struct proto_ops rawsock_ops = { · 283 unmodified lines
284	.socketpair = sock_no_socketpair,	284	.socketpair = sock_no_socketpair,
285	.accept = sock_no_accept,	285	.accept = sock_no_accept,
286	.getname = sock_no_getname,	286	.getname = sock_no_getname,
287	.poll_mask = datagram_poll_mask,	287	.poll = datagram_poll,
288	.ioctl = sock_no_ioctl,	288	.ioctl = sock_no_ioctl,
289	.listen = sock_no_listen,	289	.listen = sock_no_listen,
290	.shutdown = sock_no_shutdown,	290	.shutdown = sock_no_shutdown,
@@ -304,7 +304,7 @@ static const struct proto_ops rawsock_raw_ops = { · 13 unmodified lines
304	.socketpair = sock_no_socketpair,	304	.socketpair = sock_no_socketpair,
305	.accept = sock_no_accept,	305	.accept = sock_no_accept,
306	.getname = sock_no_getname,	306	.getname = sock_no_getname,
307	.poll_mask = datagram_poll_mask,	307	.poll = datagram_poll,
308	.ioctl = sock_no_ioctl,	308	.ioctl = sock_no_ioctl,
309	.listen = sock_no_listen,	309	.listen = sock_no_listen,
310	.shutdown = sock_no_shutdown,	310	.shutdown = sock_no_shutdown,

net/packet/af_packet.c+5−4

 	return 0;
 }
-static __poll_t packet_poll_mask(struct socket *sock, __poll_t events)
+static __poll_t packet_poll(struct file *file, struct socket *sock,
+				poll_table *wait)
 {
 	struct sock *sk = sock->sk;
 	struct packet_sock *po = pkt_sk(sk);
-	__poll_t mask = datagram_poll_mask(sock, events);
+	__poll_t mask = datagram_poll(file, sock, wait);
 	spin_lock_bh(&sk->sk_receive_queue.lock);
 	if (po->rx_ring.pg_vec) {
 	.socketpair =	sock_no_socketpair,
 	.accept =	sock_no_accept,
 	.getname =	packet_getname_spkt,
-	.poll_mask =	datagram_poll_mask,
+	.poll =		datagram_poll,
 	.ioctl =	packet_ioctl,
 	.listen =	sock_no_listen,
 	.shutdown =	sock_no_shutdown,
 	.socketpair =	sock_no_socketpair,
 	.accept =	sock_no_accept,
 	.getname =	packet_getname,
-	.poll_mask =	packet_poll_mask,
+	.poll =		packet_poll,
 	.ioctl =	packet_ioctl,
 	.listen =	sock_no_listen,
 	.shutdown =	sock_no_shutdown,

net/phonet/socket.c+6−3

 	return sizeof(struct sockaddr_pn);
 }
-static __poll_t pn_socket_poll_mask(struct socket *sock, __poll_t events)
+static __poll_t pn_socket_poll(struct file *file, struct socket *sock,
+					poll_table *wait)
 {
 	struct sock *sk = sock->sk;
 	struct pep_sock *pn = pep_sk(sk);
 	__poll_t mask = 0;
+	poll_wait(file, sk_sleep(sk), wait);
 	if (sk->sk_state == TCP_CLOSE)
 		return EPOLLERR;
 	if (!skb_queue_empty(&sk->sk_receive_queue))
 	.socketpair	= sock_no_socketpair,
 	.accept		= sock_no_accept,
 	.getname	= pn_socket_getname,
-	.poll_mask	= datagram_poll_mask,
+	.poll		= datagram_poll,
 	.ioctl		= pn_socket_ioctl,
 	.listen		= sock_no_listen,
 	.shutdown	= sock_no_shutdown,
 	.socketpair	= sock_no_socketpair,
 	.accept		= pn_socket_accept,
 	.getname	= pn_socket_getname,
-	.poll_mask	= pn_socket_poll_mask,
+	.poll		= pn_socket_poll,
 	.ioctl		= pn_socket_ioctl,
 	.listen		= pn_socket_listen,
 	.shutdown	= sock_no_shutdown,

net/qrtr/qrtr.c+1−1

@@ -1023,7 +1023,7 @@ static const struct proto_ops qrtr_proto_ops = { · 1022 unmodified lines
1023	.recvmsg = qrtr_recvmsg,	1023	.recvmsg = qrtr_recvmsg,
1024	.getname = qrtr_getname,	1024	.getname = qrtr_getname,
1025	.ioctl = qrtr_ioctl,	1025	.ioctl = qrtr_ioctl,
1026	.poll_mask = datagram_poll_mask,	1026	.poll = datagram_poll,
1027	.shutdown = sock_no_shutdown,	1027	.shutdown = sock_no_shutdown,
1028	.setsockopt = sock_no_setsockopt,	1028	.setsockopt = sock_no_setsockopt,
1029	.getsockopt = sock_no_getsockopt,	1029	.getsockopt = sock_no_getsockopt,

net/rds/connection.c+10−1

 int rds_conn_init(void)
 {
+	int ret;
+	ret = rds_loop_net_init(); /* register pernet callback */
+	if (ret)
+		return ret;
 	rds_conn_slab = kmem_cache_create("rds_connection",
 					  sizeof(struct rds_connection),
 					  0, 0, NULL);
-	if (!rds_conn_slab)
+	if (!rds_conn_slab) {
+		rds_loop_net_exit();
 		return -ENOMEM;
+	}
 	rds_info_register_func(RDS_INFO_CONNECTIONS, rds_conn_info);
 	rds_info_register_func(RDS_INFO_SEND_MESSAGES,
 void rds_conn_exit(void)
 {
+	rds_loop_net_exit(); /* unregister pernet callback */
 	rds_loop_exit();
 	WARN_ON(!hlist_empty(rds_conn_hash));

net/rds/loop.c+56−0

@@ -33,6 +33,8 @@ · 32 unmodified lines
33	#include <linux/kernel.h>	33	#include <linux/kernel.h>
34	#include <linux/slab.h>	34	#include <linux/slab.h>
35	#include <linux/in.h>	35	#include <linux/in.h>
		36	#include <net/net_namespace.h>
		37	#include <net/netns/generic.h>
36		38
37	#include "rds_single_path.h"	39	#include "rds_single_path.h"
38	#include "rds.h"	40	#include "rds.h"
@@ -40,6 +42,17 @@ · 1 unmodified line
40		42
41	static DEFINE_SPINLOCK(loop_conns_lock);	43	static DEFINE_SPINLOCK(loop_conns_lock);
42	static LIST_HEAD(loop_conns);	44	static LIST_HEAD(loop_conns);
		45	static atomic_t rds_loop_unloading = ATOMIC_INIT(0);
		46
		47	static void rds_loop_set_unloading(void)
		48	{
		49	atomic_set(&rds_loop_unloading, 1);
		50	}
		51
		52	static bool rds_loop_is_unloading(struct rds_connection *conn)
		53	{
		54	return atomic_read(&rds_loop_unloading) != 0;
		55	}
43		56
44	/*	57	/*
45	* This 'loopback' transport is a special case for flows that originate	58	* This 'loopback' transport is a special case for flows that originate
@@ -165,6 +178,8 @@ void rds_loop_exit(void) · 119 unmodified lines
165	struct rds_loop_connection lc, _lc;	178	struct rds_loop_connection lc, _lc;
166	LIST_HEAD(tmp_list);	179	LIST_HEAD(tmp_list);
167		180
		181	rds_loop_set_unloading();
		182	synchronize_rcu();
168	/* avoid calling conn_destroy with irqs off */	183	/* avoid calling conn_destroy with irqs off */
169	spin_lock_irq(&loop_conns_lock);	184	spin_lock_irq(&loop_conns_lock);
170	list_splice(&loop_conns, &tmp_list);	185	list_splice(&loop_conns, &tmp_list);
@@ -177,6 +192,46 @@ void rds_loop_exit(void) · 6 unmodified lines
177	}	192	}
178	}	193	}
179		194
		195	static void rds_loop_kill_conns(struct net *net)
		196	{
		197	struct rds_loop_connection lc, _lc;
		198	LIST_HEAD(tmp_list);
		199
		200	spin_lock_irq(&loop_conns_lock);
		201	list_for_each_entry_safe(lc, _lc, &loop_conns, loop_node) {
		202	struct net *c_net = read_pnet(&lc->conn->c_net);
		203
		204	if (net != c_net)
		205	continue;
		206	list_move_tail(&lc->loop_node, &tmp_list);
		207	}
		208	spin_unlock_irq(&loop_conns_lock);
		209
		210	list_for_each_entry_safe(lc, _lc, &tmp_list, loop_node) {
		211	WARN_ON(lc->conn->c_passive);
		212	rds_conn_destroy(lc->conn);
		213	}
		214	}
		215
		216	static void __net_exit rds_loop_exit_net(struct net *net)
		217	{
		218	rds_loop_kill_conns(net);
		219	}
		220
		221	static struct pernet_operations rds_loop_net_ops = {
		222	.exit = rds_loop_exit_net,
		223	};
		224
		225	int rds_loop_net_init(void)
		226	{
		227	return register_pernet_device(&rds_loop_net_ops);
		228	}
		229
		230	void rds_loop_net_exit(void)
		231	{
		232	unregister_pernet_device(&rds_loop_net_ops);
		233	}
		234
180	/*	235	/*
181	* This is missing .xmit_* because loop doesn't go through generic	236	* This is missing .xmit_* because loop doesn't go through generic
182	* rds_send_xmit() and doesn't call rds_recv_incoming(). .listen_stop and	237	* rds_send_xmit() and doesn't call rds_recv_incoming(). .listen_stop and
@@ -194,4 +249,5 @@ struct rds_transport rds_loop_transport = { · 11 unmodified lines
194	.inc_free = rds_loop_inc_free,	249	.inc_free = rds_loop_inc_free,
195	.t_name = "loopback",	250	.t_name = "loopback",
196	.t_type = RDS_TRANS_LOOP,	251	.t_type = RDS_TRANS_LOOP,
		252	.t_unloading = rds_loop_is_unloading,
197	};	253	};

net/rds/loop.h+2−0

@@ -5,6 +5,8 @@ · 4 unmodified lines
5	/* loop.c */	5	/* loop.c */
6	extern struct rds_transport rds_loop_transport;	6	extern struct rds_transport rds_loop_transport;
7		7
		8	int rds_loop_net_init(void);
		9	void rds_loop_net_exit(void);
8	void rds_loop_exit(void);	10	void rds_loop_exit(void);
9		11
10	#endif	12	#endif

net/rose/af_rose.c+1−1

@@ -1470,7 +1470,7 @@ static const struct proto_ops rose_proto_ops = { · 1469 unmodified lines
1470	.socketpair = sock_no_socketpair,	1470	.socketpair = sock_no_socketpair,
1471	.accept = rose_accept,	1471	.accept = rose_accept,
1472	.getname = rose_getname,	1472	.getname = rose_getname,
1473	.poll_mask = datagram_poll_mask,	1473	.poll = datagram_poll,
1474	.ioctl = rose_ioctl,	1474	.ioctl = rose_ioctl,
1475	.listen = rose_listen,	1475	.listen = rose_listen,
1476	.shutdown = sock_no_shutdown,	1476	.shutdown = sock_no_shutdown,

net/rxrpc/af_rxrpc.c+7−3

 /*
  * permit an RxRPC socket to be polled
  */
-static __poll_t rxrpc_poll_mask(struct socket *sock, __poll_t events)
+static __poll_t rxrpc_poll(struct file *file, struct socket *sock,
+			       poll_table *wait)
 {
 	struct sock *sk = sock->sk;
 	struct rxrpc_sock *rx = rxrpc_sk(sk);
-	__poll_t mask = 0;
+	__poll_t mask;
+	sock_poll_wait(file, sk_sleep(sk), wait);
+	mask = 0;
 	/* the socket is readable if there are any messages waiting on the Rx
 	 * queue */
 	.socketpair	= sock_no_socketpair,
 	.accept		= sock_no_accept,
 	.getname	= sock_no_getname,
-	.poll_mask	= rxrpc_poll_mask,
+	.poll		= rxrpc_poll,
 	.ioctl		= sock_no_ioctl,
 	.listen		= rxrpc_listen,
 	.shutdown	= rxrpc_shutdown,

net/sctp/ipv6.c+1−1

@@ -1010,7 +1010,7 @@ static const struct proto_ops inet6_seqpacket_ops = { · 1009 unmodified lines
1010	.socketpair = sock_no_socketpair,	1010	.socketpair = sock_no_socketpair,
1011	.accept = inet_accept,	1011	.accept = inet_accept,
1012	.getname = sctp_getname,	1012	.getname = sctp_getname,
1013	.poll_mask = sctp_poll_mask,	1013	.poll = sctp_poll,
1014	.ioctl = inet6_ioctl,	1014	.ioctl = inet6_ioctl,
1015	.listen = sctp_inet_listen,	1015	.listen = sctp_inet_listen,
1016	.shutdown = inet_shutdown,	1016	.shutdown = inet_shutdown,

net/sctp/protocol.c+1−1

@@ -1016,7 +1016,7 @@ static const struct proto_ops inet_seqpacket_ops = { · 1015 unmodified lines
1016	.socketpair = sock_no_socketpair,	1016	.socketpair = sock_no_socketpair,
1017	.accept = inet_accept,	1017	.accept = inet_accept,
1018	.getname = inet_getname, /* Semantics are different. */	1018	.getname = inet_getname, /* Semantics are different. */
1019	.poll_mask = sctp_poll_mask,	1019	.poll = sctp_poll,
1020	.ioctl = inet_ioctl,	1020	.ioctl = inet_ioctl,
1021	.listen = sctp_inet_listen,	1021	.listen = sctp_inet_listen,
1022	.shutdown = inet_shutdown, /* Looks harmless. */	1022	.shutdown = inet_shutdown, /* Looks harmless. */

net/sctp/socket.c+3−1

  * here, again, by modeling the current TCP/UDP code.  We don't have
  * a good way to test with it yet.
  */
-__poll_t sctp_poll_mask(struct socket *sock, __poll_t events)
+__poll_t sctp_poll(struct file *file, struct socket *sock, poll_table *wait)
 {
 	struct sock *sk = sock->sk;
 	struct sctp_sock *sp = sctp_sk(sk);
 	__poll_t mask;
+	poll_wait(file, sk_sleep(sk), wait);
 	sock_rps_record_flow(sk);
 	/* A TCP-style listening socket becomes readable when the accept queue

net/smc/af_smc.c+67−31

 						 */
 static void smc_tcp_listen_work(struct work_struct *);
+static void smc_connect_work(struct work_struct *);
 static void smc_set_keepalive(struct sock *sk, int val)
 {
 		goto out;
 	smc = smc_sk(sk);
+	/* cleanup for a dangling non-blocking connect */
+	flush_work(&smc->connect_work);
+	kfree(smc->connect_info);
+	smc->connect_info = NULL;
 	if (sk->sk_state == SMC_LISTEN)
 		/* smc_close_non_accepted() is called and acquires
 		 * sock lock for child sockets again
 	sk->sk_protocol = protocol;
 	smc = smc_sk(sk);
 	INIT_WORK(&smc->tcp_listen_work, smc_tcp_listen_work);
+	INIT_WORK(&smc->connect_work, smc_connect_work);
 	INIT_DELAYED_WORK(&smc->conn.tx_work, smc_tx_work);
 	INIT_LIST_HEAD(&smc->accept_q);
 	spin_lock_init(&smc->accept_q_lock);
 	return 0;
 }
+static void smc_connect_work(struct work_struct *work)
+{
+	struct smc_sock *smc = container_of(work, struct smc_sock,
+					    connect_work);
+	int rc;
+	lock_sock(&smc->sk);
+	rc = kernel_connect(smc->clcsock, &smc->connect_info->addr,
+			    smc->connect_info->alen, smc->connect_info->flags);
+	if (smc->clcsock->sk->sk_err) {
+		smc->sk.sk_err = smc->clcsock->sk->sk_err;
+		goto out;
+	}
+	if (rc < 0) {
+		smc->sk.sk_err = -rc;
+		goto out;
+	}
+	rc = __smc_connect(smc);
+	if (rc < 0)
+		smc->sk.sk_err = -rc;
+out:
+	smc->sk.sk_state_change(&smc->sk);
+	kfree(smc->connect_info);
+	smc->connect_info = NULL;
+	release_sock(&smc->sk);
+}
 static int smc_connect(struct socket *sock, struct sockaddr *addr,
 		       int alen, int flags)
 {
 	smc_copy_sock_settings_to_clc(smc);
 	tcp_sk(smc->clcsock->sk)->syn_smc = 1;
-	rc = kernel_connect(smc->clcsock, addr, alen, flags);
+	if (flags & O_NONBLOCK) {
-	if (rc)
+		if (smc->connect_info) {
-		goto out;
+			rc = -EALREADY;
+			goto out;
+		}
+		smc->connect_info = kzalloc(alen + 2 * sizeof(int), GFP_KERNEL);
+		if (!smc->connect_info) {
+			rc = -ENOMEM;
+			goto out;
+		}
+		smc->connect_info->alen = alen;
+		smc->connect_info->flags = flags ^ O_NONBLOCK;
+		memcpy(&smc->connect_info->addr, addr, alen);
+		schedule_work(&smc->connect_work);
+		rc = -EINPROGRESS;
+	} else {
+		rc = kernel_connect(smc->clcsock, addr, alen, flags);
+		if (rc)
+			goto out;
-	rc = __smc_connect(smc);
+		rc = __smc_connect(smc);
-	if (rc < 0)
+		if (rc < 0)
-		goto out;
+			goto out;
-	else
+		else
-		rc = 0; /* success cases including fallback */
+			rc = 0; /* success cases including fallback */
+	}
 out:
 	release_sock(sk);
 	return mask;
 }
-static __poll_t smc_poll_mask(struct socket *sock, __poll_t events)
+static __poll_t smc_poll(struct file *file, struct socket *sock,
+			     poll_table *wait)
 {
 	struct sock *sk = sock->sk;
 	__poll_t mask = 0;
 	struct smc_sock *smc;
-	int rc;
 	if (!sk)
 		return EPOLLNVAL;
 	smc = smc_sk(sock->sk);
-	sock_hold(sk);
-	lock_sock(sk);
 	if ((sk->sk_state == SMC_INIT) || smc->use_fallback) {
 		/* delegate to CLC child sock */
-		release_sock(sk);
+		mask = smc->clcsock->ops->poll(file, smc->clcsock, wait);
-		mask = smc->clcsock->ops->poll_mask(smc->clcsock, events);
-		lock_sock(sk);
 		sk->sk_err = smc->clcsock->sk->sk_err;
-		if (sk->sk_err) {
+		if (sk->sk_err)
 			mask |= EPOLLERR;
-		} else {
-			/* if non-blocking connect finished ... */
-			if (sk->sk_state == SMC_INIT &&
-			    mask & EPOLLOUT &&
-			    smc->clcsock->sk->sk_state != TCP_CLOSE) {
-				rc = __smc_connect(smc);
-				if (rc < 0)
-					mask |= EPOLLERR;
-				/* success cases including fallback */
-				mask |= EPOLLOUT | EPOLLWRNORM;
-			}
-		}
 	} else {
 		if (sk->sk_err)
 			mask |= EPOLLERR;
 			mask |= EPOLLPRI;
 	}
-	release_sock(sk);
-	sock_put(sk);
 	return mask;
 }
 	.socketpair	= sock_no_socketpair,
 	.accept		= smc_accept,
 	.getname	= smc_getname,
-	.poll_mask	= smc_poll_mask,
+	.poll		= smc_poll,
 	.ioctl		= smc_ioctl,
 	.listen		= smc_listen,
 	.shutdown	= smc_shutdown,

net/smc/smc.h+8−0

 	u64			peer_token;	/* SMC-D token of peer */
 };
+struct smc_connect_info {
+	int			flags;
+	int			alen;
+	struct sockaddr		addr;
+};
 struct smc_sock {				/* smc sock container */
 	struct sock		sk;
 	struct socket		*clcsock;	/* internal tcp socket */
 	struct smc_connection	conn;		/* smc connection */
 	struct smc_sock		*listen_smc;	/* listen parent */
+	struct smc_connect_info *connect_info;	/* connect address & flags */
+	struct work_struct	connect_work;	/* handle non-blocking connect*/
 	struct work_struct	tcp_listen_work;/* handle tcp socket accepts */
 	struct work_struct	smc_listen_work;/* prepare new accept socket */
 	struct list_head	accept_q;	/* sockets to be accepted */

net/socket.c+7−43

@@ -117,10 +117,8 @@ static ssize_t sock_write_iter(struct kiocb iocb, struct iov_iter from); · 116 unmodified lines
117	static int sock_mmap(struct file file, struct vm_area_struct vma);	117	static int sock_mmap(struct file file, struct vm_area_struct vma);
118		118
119	static int sock_close(struct inode inode, struct file file);	119	static int sock_close(struct inode inode, struct file file);
120	static struct wait_queue_head sock_get_poll_head(struct file file,	120	static __poll_t sock_poll(struct file *file,
121	__poll_t events);	121	struct poll_table_struct *wait);
122	static __poll_t sock_poll_mask(struct file *file, __poll_t);
123	static __poll_t sock_poll(struct file file, struct poll_table_struct wait);
124	static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg);	122	static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
125	#ifdef CONFIG_COMPAT	123	#ifdef CONFIG_COMPAT
126	static long compat_sock_ioctl(struct file *file,	124	static long compat_sock_ioctl(struct file *file,
@@ -143,8 +141,6 @@ static const struct file_operations socket_file_ops = { · 16 unmodified lines
143	.llseek = no_llseek,	141	.llseek = no_llseek,
144	.read_iter = sock_read_iter,	142	.read_iter = sock_read_iter,
145	.write_iter = sock_write_iter,	143	.write_iter = sock_write_iter,
146	.get_poll_head = sock_get_poll_head,
147	.poll_mask = sock_poll_mask,
148	.poll = sock_poll,	144	.poll = sock_poll,
149	.unlocked_ioctl = sock_ioctl,	145	.unlocked_ioctl = sock_ioctl,
150	#ifdef CONFIG_COMPAT	146	#ifdef CONFIG_COMPAT
@@ -1130,48 +1126,16 @@ out_release: · 979 unmodified lines
1130	}	1126	}
1131	EXPORT_SYMBOL(sock_create_lite);	1127	EXPORT_SYMBOL(sock_create_lite);
1132		1128
1133	static struct wait_queue_head sock_get_poll_head(struct file file,
1134	__poll_t events)
1135	{
1136	struct socket *sock = file->private_data;
1137
1138	if (!sock->ops->poll_mask)
1139	return NULL;
1140	sock_poll_busy_loop(sock, events);
1141	return sk_sleep(sock->sk);
1142	}
1143
1144	static __poll_t sock_poll_mask(struct file *file, __poll_t events)
1145	{
1146	struct socket *sock = file->private_data;
1147
1148	/*
1149	* We need to be sure we are in sync with the socket flags modification.
1150	*
1151	* This memory barrier is paired in the wq_has_sleeper.
1152	*/
1153	smp_mb();
1154
1155	/* this socket can poll_ll so tell the system call */
1156	return sock->ops->poll_mask(sock, events) \|
1157	(sk_can_busy_loop(sock->sk) ? POLL_BUSY_LOOP : 0);
1158	}
1159
1160	/* No kernel lock held - perfect */	1129	/* No kernel lock held - perfect */
1161	static __poll_t sock_poll(struct file file, poll_table wait)	1130	static __poll_t sock_poll(struct file file, poll_table wait)
1162	{	1131	{
1163	struct socket *sock = file->private_data;	1132	struct socket *sock = file->private_data;
1164	__poll_t events = poll_requested_events(wait), mask = 0;	1133	__poll_t events = poll_requested_events(wait);
1165
1166	if (sock->ops->poll) {
1167	sock_poll_busy_loop(sock, events);
1168	mask = sock->ops->poll(file, sock, wait);
1169	} else if (sock->ops->poll_mask) {
1170	sock_poll_wait(file, sock_get_poll_head(file, events), wait);
1171	mask = sock->ops->poll_mask(sock, events);
1172	}
1173		1134
1174	return mask \| sock_poll_busy_flag(sock);	1135	sock_poll_busy_loop(sock, events);
		1136	if (!sock->ops->poll)
		1137	return 0;
		1138	return sock->ops->poll(file, sock, wait) \| sock_poll_busy_flag(sock);
1175	}	1139	}
1176		1140
1177	static int sock_mmap(struct file file, struct vm_area_struct vma)	1141	static int sock_mmap(struct file file, struct vm_area_struct vma)

net/strparser/strparser.c+1−16

 	 */
 	struct strp_msg strp;
 	int accum_len;
-	int early_eaten;
 };
 static inline struct _strp_msg *_strp_msg(struct sk_buff *skb)
 	head = strp->skb_head;
 	if (head) {
 		/* Message already in progress */
-		stm = _strp_msg(head);
-		if (unlikely(stm->early_eaten)) {
-			/* Already some number of bytes on the receive sock
-			 * data saved in skb_head, just indicate they
-			 * are consumed.
-			 */
-			eaten = orig_len <= stm->early_eaten ?
-				orig_len : stm->early_eaten;
-			stm->early_eaten -= eaten;
-			return eaten;
-		}
 		if (unlikely(orig_offset)) {
 			/* Getting data with a non-zero offset when a message is
 			 * in progress is not expected. If it does happen, we
 				}
 				stm->accum_len += cand_len;
+				eaten += cand_len;
 				strp->need_bytes = stm->strp.full_len -
 						       stm->accum_len;
-				stm->early_eaten = cand_len;
 				STRP_STATS_ADD(strp->stats.bytes, cand_len);
 				desc->count = 0; /* Stop reading socket */
 				break;

net/tipc/socket.c+9−5

 }
 /**
- * tipc_poll - read pollmask
+ * tipc_poll - read and possibly block on pollmask
  * @file: file structure associated with the socket
  * @sock: socket for which to calculate the poll bits
+ * @wait: ???
  *
  * Returns pollmask value
  *
  * imply that the operation will succeed, merely that it should be performed
  * and will not block.
  */
-static __poll_t tipc_poll_mask(struct socket *sock, __poll_t events)
+static __poll_t tipc_poll(struct file *file, struct socket *sock,
+			      poll_table *wait)
 {
 	struct sock *sk = sock->sk;
 	struct tipc_sock *tsk = tipc_sk(sk);
 	__poll_t revents = 0;
+	sock_poll_wait(file, sk_sleep(sk), wait);
 	if (sk->sk_shutdown & RCV_SHUTDOWN)
 		revents |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
 	if (sk->sk_shutdown == SHUTDOWN_MASK)
 	.socketpair	= tipc_socketpair,
 	.accept		= sock_no_accept,
 	.getname	= tipc_getname,
-	.poll_mask	= tipc_poll_mask,
+	.poll		= tipc_poll,
 	.ioctl		= tipc_ioctl,
 	.listen		= sock_no_listen,
 	.shutdown	= tipc_shutdown,
 	.socketpair	= tipc_socketpair,
 	.accept		= tipc_accept,
 	.getname	= tipc_getname,
-	.poll_mask	= tipc_poll_mask,
+	.poll		= tipc_poll,
 	.ioctl		= tipc_ioctl,
 	.listen		= tipc_listen,
 	.shutdown	= tipc_shutdown,
 	.socketpair	= tipc_socketpair,
 	.accept		= tipc_accept,
 	.getname	= tipc_getname,
-	.poll_mask	= tipc_poll_mask,
+	.poll		= tipc_poll,
 	.ioctl		= tipc_ioctl,
 	.listen		= tipc_listen,
 	.shutdown	= tipc_shutdown,

net/tls/tls_main.c+1−1

@@ -712,7 +712,7 @@ static int __init tls_register(void) · 711 unmodified lines
712	build_protos(tls_prots[TLSV4], &tcp_prot);	712	build_protos(tls_prots[TLSV4], &tcp_prot);
713		713
714	tls_sw_proto_ops = inet_stream_ops;	714	tls_sw_proto_ops = inet_stream_ops;
715	tls_sw_proto_ops.poll_mask = tls_sw_poll_mask;	715	tls_sw_proto_ops.poll = tls_sw_poll;
716	tls_sw_proto_ops.splice_read = tls_sw_splice_read;	716	tls_sw_proto_ops.splice_read = tls_sw_splice_read;
717		717
718	#ifdef CONFIG_TLS_DEVICE	718	#ifdef CONFIG_TLS_DEVICE

net/tls/tls_sw.c+10−9

 	return copied ? : err;
 }
-__poll_t tls_sw_poll_mask(struct socket *sock, __poll_t events)
+unsigned int tls_sw_poll(struct file *file, struct socket *sock,
+			 struct poll_table_struct *wait)
 {
+	unsigned int ret;
 	struct sock *sk = sock->sk;
 	struct tls_context *tls_ctx = tls_get_ctx(sk);
 	struct tls_sw_context_rx *ctx = tls_sw_ctx_rx(tls_ctx);
-	__poll_t mask;
-	/* Grab EPOLLOUT and EPOLLHUP from the underlying socket */
+	/* Grab POLLOUT and POLLHUP from the underlying socket */
-	mask = ctx->sk_poll_mask(sock, events);
+	ret = ctx->sk_poll(file, sock, wait);
-	/* Clear EPOLLIN bits, and set based on recv_pkt */
+	/* Clear POLLIN bits, and set based on recv_pkt */
-	mask &= ~(EPOLLIN | EPOLLRDNORM);
+	ret &= ~(POLLIN | POLLRDNORM);
 	if (ctx->recv_pkt)
-		mask |= EPOLLIN | EPOLLRDNORM;
+		ret |= POLLIN | POLLRDNORM;
-	return mask;
+	return ret;
 }
 static int tls_read_size(struct strparser *strp, struct sk_buff *skb)
 		sk->sk_data_ready = tls_data_ready;
 		write_unlock_bh(&sk->sk_callback_lock);
-		sw_ctx_rx->sk_poll_mask = sk->sk_socket->ops->poll_mask;
+		sw_ctx_rx->sk_poll = sk->sk_socket->ops->poll;
 		strp_check_rcv(&sw_ctx_rx->strp);
 	}

net/unix/af_unix.c+19−11

 static int unix_socketpair(struct socket *, struct socket *);
 static int unix_accept(struct socket *, struct socket *, int, bool);
 static int unix_getname(struct socket *, struct sockaddr *, int);
-static __poll_t unix_poll_mask(struct socket *, __poll_t);
+static __poll_t unix_poll(struct file *, struct socket *, poll_table *);
-static __poll_t unix_dgram_poll_mask(struct socket *, __poll_t);
+static __poll_t unix_dgram_poll(struct file *, struct socket *,
+				    poll_table *);
 static int unix_ioctl(struct socket *, unsigned int, unsigned long);
 static int unix_shutdown(struct socket *, int);
 static int unix_stream_sendmsg(struct socket *, struct msghdr *, size_t);
 	.socketpair =	unix_socketpair,
 	.accept =	unix_accept,
 	.getname =	unix_getname,
-	.poll_mask =	unix_poll_mask,
+	.poll =		unix_poll,
 	.ioctl =	unix_ioctl,
 	.listen =	unix_listen,
 	.shutdown =	unix_shutdown,
 	.socketpair =	unix_socketpair,
 	.accept =	sock_no_accept,
 	.getname =	unix_getname,
-	.poll_mask =	unix_dgram_poll_mask,
+	.poll =		unix_dgram_poll,
 	.ioctl =	unix_ioctl,
 	.listen =	sock_no_listen,
 	.shutdown =	unix_shutdown,
 	.socketpair =	unix_socketpair,
 	.accept =	unix_accept,
 	.getname =	unix_getname,
-	.poll_mask =	unix_dgram_poll_mask,
+	.poll =		unix_dgram_poll,
 	.ioctl =	unix_ioctl,
 	.listen =	unix_listen,
 	.shutdown =	unix_shutdown,
 	return err;
 }
-static __poll_t unix_poll_mask(struct socket *sock, __poll_t events)
+static __poll_t unix_poll(struct file *file, struct socket *sock, poll_table *wait)
 {
 	struct sock *sk = sock->sk;
-	__poll_t mask = 0;
+	__poll_t mask;
+	sock_poll_wait(file, sk_sleep(sk), wait);
+	mask = 0;
 	/* exceptional events? */
 	if (sk->sk_err)
 	return mask;
 }
-static __poll_t unix_dgram_poll_mask(struct socket *sock, __poll_t events)
+static __poll_t unix_dgram_poll(struct file *file, struct socket *sock,
+				    poll_table *wait)
 {
 	struct sock *sk = sock->sk, *other;
-	int writable;
+	unsigned int writable;
-	__poll_t mask = 0;
+	__poll_t mask;
+	sock_poll_wait(file, sk_sleep(sk), wait);
+	mask = 0;
 	/* exceptional events? */
 	if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
 	}
 	/* No write status requested, avoid expensive OUT tests. */
-	if (!(events & (EPOLLWRBAND|EPOLLWRNORM|EPOLLOUT)))
+	if (!(poll_requested_events(wait) & (EPOLLWRBAND|EPOLLWRNORM|EPOLLOUT)))
 		return mask;
 	writable = unix_writable(sk);

net/vmw_vsock/af_vsock.c+13−6

 	return err;
 }
-static __poll_t vsock_poll_mask(struct socket *sock, __poll_t events)
+static __poll_t vsock_poll(struct file *file, struct socket *sock,
+			       poll_table *wait)
 {
-	struct sock *sk = sock->sk;
+	struct sock *sk;
-	struct vsock_sock *vsk = vsock_sk(sk);
+	__poll_t mask;
-	__poll_t mask = 0;
+	struct vsock_sock *vsk;
+	sk = sock->sk;
+	vsk = vsock_sk(sk);
+	poll_wait(file, sk_sleep(sk), wait);
+	mask = 0;
 	if (sk->sk_err)
 		/* Signify that there has been an error on this socket. */
 	.socketpair = sock_no_socketpair,
 	.accept = sock_no_accept,
 	.getname = vsock_getname,
-	.poll_mask = vsock_poll_mask,
+	.poll = vsock_poll,
 	.ioctl = sock_no_ioctl,
 	.listen = sock_no_listen,
 	.shutdown = vsock_shutdown,
 	.socketpair = sock_no_socketpair,
 	.accept = vsock_accept,
 	.getname = vsock_getname,
-	.poll_mask = vsock_poll_mask,
+	.poll = vsock_poll,
 	.ioctl = sock_no_ioctl,
 	.listen = vsock_listen,
 	.shutdown = vsock_shutdown,

net/wireless/nl80211.c+14−21

 				  nl80211_check_s32);
 	/*
 	 * Check HT operation mode based on
-	 * IEEE 802.11 2012 8.4.2.59 HT Operation element.
+	 * IEEE 802.11-2016 9.4.2.57 HT Operation element.
 	 */
 	if (tb[NL80211_MESHCONF_HT_OPMODE]) {
 		ht_opmode = nla_get_u16(tb[NL80211_MESHCONF_HT_OPMODE]);
 				  IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT))
 			return -EINVAL;
-		if ((ht_opmode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT) &&
+		/* NON_HT_STA bit is reserved, but some programs set it */
-		    (ht_opmode & IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT))
+		ht_opmode &= ~IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT;
-			return -EINVAL;
-		switch (ht_opmode & IEEE80211_HT_OP_MODE_PROTECTION) {
-		case IEEE80211_HT_OP_MODE_PROTECTION_NONE:
-		case IEEE80211_HT_OP_MODE_PROTECTION_20MHZ:
-			if (ht_opmode & IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT)
-				return -EINVAL;
-			break;
-		case IEEE80211_HT_OP_MODE_PROTECTION_NONMEMBER:
-		case IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED:
-			if (!(ht_opmode & IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT))
-				return -EINVAL;
-			break;
-		}
 		cfg->ht_opmode = ht_opmode;
 		mask |= (1 << (NL80211_MESHCONF_HT_OPMODE - 1));
 	}
 				    rem) {
 			u8 *mask_pat;
-			nla_parse_nested(pat_tb, MAX_NL80211_PKTPAT, pat,
+			err = nla_parse_nested(pat_tb, MAX_NL80211_PKTPAT, pat,
-					 nl80211_packet_pattern_policy,
+					       nl80211_packet_pattern_policy,
-					 info->extack);
+					       info->extack);
+			if (err)
+				goto error;
 			err = -EINVAL;
 			if (!pat_tb[NL80211_PKTPAT_MASK] ||
 			    !pat_tb[NL80211_PKTPAT_PATTERN])
 			    rem) {
 		u8 *mask_pat;
-		nla_parse_nested(pat_tb, MAX_NL80211_PKTPAT, pat,
+		err = nla_parse_nested(pat_tb, MAX_NL80211_PKTPAT, pat,
-				 nl80211_packet_pattern_policy, NULL);
+				       nl80211_packet_pattern_policy, NULL);
+		if (err)
+			return err;
 		if (!pat_tb[NL80211_PKTPAT_MASK] ||
 		    !pat_tb[NL80211_PKTPAT_PATTERN])
 			return -EINVAL;

net/x25/af_x25.c+1−1

@@ -1750,7 +1750,7 @@ static const struct proto_ops x25_proto_ops = { · 1749 unmodified lines
1750	.socketpair = sock_no_socketpair,	1750	.socketpair = sock_no_socketpair,
1751	.accept = x25_accept,	1751	.accept = x25_accept,
1752	.getname = x25_getname,	1752	.getname = x25_getname,
1753	.poll_mask = datagram_poll_mask,	1753	.poll = datagram_poll,
1754	.ioctl = x25_ioctl,	1754	.ioctl = x25_ioctl,
1755	#ifdef CONFIG_COMPAT	1755	#ifdef CONFIG_COMPAT
1756	.compat_ioctl = compat_x25_ioctl,	1756	.compat_ioctl = compat_x25_ioctl,

net/xdp/xsk.c+4−3

 	return (xs->zc) ? xsk_zc_xmit(sk) : xsk_generic_xmit(sk, m, total_len);
 }
-static __poll_t xsk_poll_mask(struct socket *sock, __poll_t events)
+static unsigned int xsk_poll(struct file *file, struct socket *sock,
+			     struct poll_table_struct *wait)
 {
-	__poll_t mask = datagram_poll_mask(sock, events);
+	unsigned int mask = datagram_poll(file, sock, wait);
 	struct sock *sk = sock->sk;
 	struct xdp_sock *xs = xdp_sk(sk);
 	.socketpair	= sock_no_socketpair,
 	.accept		= sock_no_accept,
 	.getname	= sock_no_getname,
-	.poll_mask	= xsk_poll_mask,
+	.poll		= xsk_poll,
 	.ioctl		= sock_no_ioctl,
 	.listen		= sock_no_listen,
 	.shutdown	= sock_no_shutdown,

samples/bpf/xdp_fwd_kern.c+4−4

 	struct ethhdr *eth = data;
 	struct ipv6hdr *ip6h;
 	struct iphdr *iph;
-	int out_index;
 	u16 h_proto;
 	u64 nh_off;
+	int rc;
 	nh_off = sizeof(*eth);
 	if (data + nh_off > data_end)
 	fib_params.ifindex = ctx->ingress_ifindex;
-	out_index = bpf_fib_lookup(ctx, &fib_params, sizeof(fib_params), flags);
+	rc = bpf_fib_lookup(ctx, &fib_params, sizeof(fib_params), flags);
 	/* verify egress index has xdp support
 	 * TO-DO bpf_map_lookup_elem(&tx_port, &key) fails with
 	 * NOTE: without verification that egress index supports XDP
 	 *       forwarding packets are dropped.
 	 */
-	if (out_index > 0) {
+	if (rc == 0) {
 		if (h_proto == htons(ETH_P_IP))
 			ip_decrease_ttl(iph);
 		else if (h_proto == htons(ETH_P_IPV6))
 		memcpy(eth->h_dest, fib_params.dmac, ETH_ALEN);
 		memcpy(eth->h_source, fib_params.smac, ETH_ALEN);
-		return bpf_redirect_map(&tx_port, out_index, 0);
+		return bpf_redirect_map(&tx_port, fib_params.ifindex, 0);
 	}
 	return XDP_PASS;

scripts/cc-can-link.sh+1−1

@@ -1,7 +1,7 @@
1	#!/bin/sh	1	#!/bin/sh
2	# SPDX-License-Identifier: GPL-2.0	2	# SPDX-License-Identifier: GPL-2.0
3		3
4	cat << "END" \| $@ -x c - -o /dev/null >/dev/null 2>&1 && echo "y"	4	cat << "END" \| $@ -x c - -o /dev/null >/dev/null 2>&1
5	#include <stdio.h>	5	#include <stdio.h>
6	int main(void)	6	int main(void)
7	{	7	{

scripts/checkpatch.pl+0−6

 			     "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
 		}
-# Check for old stable address
-		if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
-			ERROR("STABLE_ADDRESS",
-			      "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
-		}
 # Check for unwanted Gerrit info
 		if ($in_commit_log && $line =~ /^\s*change-id:/i) {
 			ERROR("GERRIT_CHANGE_ID",

scripts/gcc-x86_64-has-stack-protector.sh+1−1

@@ -1,4 +1,4 @@
1	#!/bin/sh	1	#!/bin/sh
2	# SPDX-License-Identifier: GPL-2.0	2	# SPDX-License-Identifier: GPL-2.0
3		3
4	echo "int foo(void) { char X[200]; return 3; }" \| $* -S -x c -c -O0 -mcmodel=kernel -fno-PIE -fstack-protector - -o - 2> /dev/null \| grep -q "%gs"	4	echo "int foo(void) { char X[200]; return 3; }" \| $* -S -x c -c -m64 -O0 -mcmodel=kernel -fno-PIE -fstack-protector - -o - 2> /dev/null \| grep -q "%gs"

scripts/kconfig/expr.h+3−0

  * config BAZ
  *         int "BAZ Value"
  *         range 1..255
+ *
+ * Please, also check zconf.y:print_symbol() when modifying the
+ * list of property types!
  */
 enum prop_type {
 	P_UNKNOWN,

scripts/kconfig/preprocess.c+1−1

@@ -156,7 +156,7 @@ static char do_shell(int argc, char argv[]) · 155 unmodified lines
156	nread--;	156	nread--;
157		157
158	/* remove trailing new lines */	158	/* remove trailing new lines */
159	while (buf[nread - 1] == '\n')	159	while (nread > 0 && buf[nread - 1] == '\n')
160	nread--;	160	nread--;
161		161
162	buf[nread] = 0;	162	buf[nread] = 0;

scripts/kconfig/zconf.y+6−2

 static struct menu *current_menu, *current_entry;
 %}
-%expect 32
+%expect 31
 %union
 {
 /* if entry */
-if_entry: T_IF expr nl
+if_entry: T_IF expr T_EOL
 {
 	printd(DEBUG_PARSE, "%s:%d:if\n", zconf_curname(), zconf_lineno());
 	menu_add_entry(NULL);
 			print_quoted_string(out, prop->text);
 			fputc('\n', out);
 			break;
+		case P_SYMBOL:
+			fputs( "  symbol ", out);
+			fprintf(out, "%s\n", prop->sym->name);
+			break;
 		default:
 			fprintf(out, "  unknown prop %d!\n", prop->type);
 			break;

security/keys/dh.c+4−2

  * The src pointer is defined as Z || other info where Z is the shared secret
  * from DH and other info is an arbitrary string (see SP800-56A section
  * 5.8.1.2).
+ *
+ * 'dlen' must be a multiple of the digest size.
  */
 static int kdf_ctr(struct kdf_sdesc *sdesc, const u8 *src, unsigned int slen,
 		   u8 *dst, unsigned int dlen, unsigned int zlen)
 {
 	uint8_t *outbuf = NULL;
 	int ret;
-	size_t outbuf_len = round_up(buflen,
+	size_t outbuf_len = roundup(buflen,
-			             crypto_shash_digestsize(sdesc->shash.tfm));
+				    crypto_shash_digestsize(sdesc->shash.tfm));
 	outbuf = kmalloc(outbuf_len, GFP_KERNEL);
 	if (!outbuf) {

security/selinux/selinuxfs.c+33−45

 static ssize_t sel_read_policy(struct file *filp, char __user *buf,
 			       size_t count, loff_t *ppos)
 {
-	struct selinux_fs_info *fsi = file_inode(filp)->i_sb->s_fs_info;
 	struct policy_load_memory *plm = filp->private_data;
 	int ret;
-	mutex_lock(&fsi->mutex);
 	ret = avc_has_perm(&selinux_state,
 			   current_sid(), SECINITSID_SECURITY,
 			  SECCLASS_SECURITY, SECURITY__READ_POLICY, NULL);
 	if (ret)
-		goto out;
+		return ret;
-	ret = simple_read_from_buffer(buf, count, ppos, plm->data, plm->len);
+	return simple_read_from_buffer(buf, count, ppos, plm->data, plm->len);
-out:
-	mutex_unlock(&fsi->mutex);
-	return ret;
 }
 static vm_fault_t sel_mmap_policy_fault(struct vm_fault *vmf)
 	ret = -EINVAL;
 	if (index >= fsi->bool_num || strcmp(name,
 					     fsi->bool_pending_names[index]))
-		goto out;
+		goto out_unlock;
 	ret = -ENOMEM;
 	page = (char *)get_zeroed_page(GFP_KERNEL);
 	if (!page)
-		goto out;
+		goto out_unlock;
 	cur_enforcing = security_get_bool_value(fsi->state, index);
 	if (cur_enforcing < 0) {
 		ret = cur_enforcing;
-		goto out;
+		goto out_unlock;
 	}
 	length = scnprintf(page, PAGE_SIZE, "%d %d", cur_enforcing,
 			  fsi->bool_pending_values[index]);
-	ret = simple_read_from_buffer(buf, count, ppos, page, length);
-out:
 	mutex_unlock(&fsi->mutex);
+	ret = simple_read_from_buffer(buf, count, ppos, page, length);
+out_free:
 	free_page((unsigned long)page);
 	return ret;
+out_unlock:
+	mutex_unlock(&fsi->mutex);
+	goto out_free;
 }
 static ssize_t sel_write_bool(struct file *filep, const char __user *buf,
 	unsigned index = file_inode(filep)->i_ino & SEL_INO_MASK;
 	const char *name = filep->f_path.dentry->d_name.name;
+	if (count >= PAGE_SIZE)
+		return -ENOMEM;
+	/* No partial writes. */
+	if (*ppos != 0)
+		return -EINVAL;
+	page = memdup_user_nul(buf, count);
+	if (IS_ERR(page))
+		return PTR_ERR(page);
 	mutex_lock(&fsi->mutex);
 	length = avc_has_perm(&selinux_state,
 					     fsi->bool_pending_names[index]))
 		goto out;
-	length = -ENOMEM;
-	if (count >= PAGE_SIZE)
-		goto out;
-	/* No partial writes. */
-	length = -EINVAL;
-	if (*ppos != 0)
-		goto out;
-	page = memdup_user_nul(buf, count);
-	if (IS_ERR(page)) {
-		length = PTR_ERR(page);
-		page = NULL;
-		goto out;
-	}
 	length = -EINVAL;
 	if (sscanf(page, "%d", &new_value) != 1)
 		goto out;
 	ssize_t length;
 	int new_value;
+	if (count >= PAGE_SIZE)
+		return -ENOMEM;
+	/* No partial writes. */
+	if (*ppos != 0)
+		return -EINVAL;
+	page = memdup_user_nul(buf, count);
+	if (IS_ERR(page))
+		return PTR_ERR(page);
 	mutex_lock(&fsi->mutex);
 	length = avc_has_perm(&selinux_state,
 	if (length)
 		goto out;
-	length = -ENOMEM;
-	if (count >= PAGE_SIZE)
-		goto out;
-	/* No partial writes. */
-	length = -EINVAL;
-	if (*ppos != 0)
-		goto out;
-	page = memdup_user_nul(buf, count);
-	if (IS_ERR(page)) {
-		length = PTR_ERR(page);
-		page = NULL;
-		goto out;
-	}
 	length = -EINVAL;
 	if (sscanf(page, "%d", &new_value) != 1)
 		goto out;

security/smack/smack_lsm.c+1−0

@@ -2296,6 +2296,7 @@ static void smack_task_to_inode(struct task_struct p, struct inode inode) · 2295 unmodified lines
2296	struct smack_known *skp = smk_of_task_struct(p);	2296	struct smack_known *skp = smk_of_task_struct(p);
2297		2297
2298	isp->smk_inode = skp;	2298	isp->smk_inode = skp;
		2299	isp->smk_flags \|= SMK_INODE_INSTANT;
2299	}	2300	}
2300		2301
2301	/*	2302	/*

sound/core/seq/seq_clientmgr.c+2−1

@@ -2004,7 +2004,8 @@ static int snd_seq_ioctl_query_next_client(struct snd_seq_client *client, · 2003 unmodified lines
2004	struct snd_seq_client *cptr = NULL;	2004	struct snd_seq_client *cptr = NULL;
2005		2005
2006	/* search for next client */	2006	/* search for next client */
2007	info->client++;	2007	if (info->client < INT_MAX)
		2008	info->client++;
2008	if (info->client < 0)	2009	if (info->client < 0)
2009	info->client = 0;	2010	info->client = 0;
2010	for (; info->client < SNDRV_SEQ_MAX_CLIENTS; info->client++) {	2011	for (; info->client < SNDRV_SEQ_MAX_CLIENTS; info->client++) {

sound/core/timer.c+1−1

@@ -1520,7 +1520,7 @@ static int snd_timer_user_next_device(struct snd_timer_id __user *_tid) · 1519 unmodified lines
1520	} else {	1520	} else {
1521	if (id.subdevice < 0)	1521	if (id.subdevice < 0)
1522	id.subdevice = 0;	1522	id.subdevice = 0;
1523	else	1523	else if (id.subdevice < INT_MAX)
1524	id.subdevice++;	1524	id.subdevice++;
1525	}	1525	}
1526	}	1526	}

sound/pci/hda/hda_codec.c+3−2

 	list_for_each_entry(pcm, &codec->pcm_list_head, list)
 		snd_pcm_suspend_all(pcm->pcm);
 	state = hda_call_codec_suspend(codec);
-	if (codec_has_clkstop(codec) && codec_has_epss(codec) &&
+	if (codec->link_down_at_suspend ||
-	    (state & AC_PWRST_CLK_STOP_OK))
+	    (codec_has_clkstop(codec) && codec_has_epss(codec) &&
+	     (state & AC_PWRST_CLK_STOP_OK)))
 		snd_hdac_codec_link_down(&codec->core);
 	snd_hdac_link_power(&codec->core, false);
 	return 0;

sound/pci/hda/hda_codec.h+1−0

@@ -258,6 +258,7 @@ struct hda_codec { · 257 unmodified lines
258	unsigned int power_save_node:1; /* advanced PM for each widget */	258	unsigned int power_save_node:1; /* advanced PM for each widget */
259	unsigned int auto_runtime_pm:1; /* enable automatic codec runtime pm */	259	unsigned int auto_runtime_pm:1; /* enable automatic codec runtime pm */
260	unsigned int force_pin_prefix:1; /* Add location prefix */	260	unsigned int force_pin_prefix:1; /* Add location prefix */
		261	unsigned int link_down_at_suspend:1; /* link down at runtime suspend */
261	#ifdef CONFIG_PM	262	#ifdef CONFIG_PM
262	unsigned long power_on_acct;	263	unsigned long power_on_acct;
263	unsigned long power_off_acct;	264	unsigned long power_off_acct;

sound/pci/hda/patch_ca0132.c+23−41

 enum {
 	QUIRK_NONE,
 	QUIRK_ALIENWARE,
+	QUIRK_ALIENWARE_M17XR4,
 	QUIRK_SBZ,
 	QUIRK_R3DI,
 };
 };
 static const struct snd_pci_quirk ca0132_quirks[] = {
+	SND_PCI_QUIRK(0x1028, 0x057b, "Alienware M17x R4", QUIRK_ALIENWARE_M17XR4),
 	SND_PCI_QUIRK(0x1028, 0x0685, "Alienware 15 2015", QUIRK_ALIENWARE),
 	SND_PCI_QUIRK(0x1028, 0x0688, "Alienware 17 2015", QUIRK_ALIENWARE),
 	SND_PCI_QUIRK(0x1028, 0x0708, "Alienware 15 R2 2016", QUIRK_ALIENWARE),
  * I think this has to do with the pin for rear surround being 0x11,
  * and the center/lfe being 0x10. Usually the pin order is the opposite.
  */
-const struct snd_pcm_chmap_elem ca0132_alt_chmaps[] = {
+static const struct snd_pcm_chmap_elem ca0132_alt_chmaps[] = {
 	{ .channels = 2,
 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
 	{ .channels = 4,
 	info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adcs[0];
 	/* With the DSP enabled, desktops don't use this ADC. */
-	if (spec->use_alt_functions) {
+	if (!spec->use_alt_functions) {
 		info = snd_hda_codec_pcm_new(codec, "CA0132 Analog Mic-In2");
 		if (!info)
 			return -ENOMEM;
 	 * Bit   6: set to select Data2, clear for Data1
 	 * Bit   7: set to enable DMic, clear for AMic
 	 */
-	val = 0x23;
+	if (spec->quirk == QUIRK_ALIENWARE_M17XR4)
+		val = 0x33;
+	else
+		val = 0x23;
 	/* keep a copy of dmic ctl val for enable/disable dmic purpuse */
 	spec->dmic_ctl = val;
 	snd_hda_codec_write(codec, spec->input_pins[0], 0,
 	snd_hda_sequence_write(codec, spec->base_init_verbs);
-	if (spec->quirk != QUIRK_NONE)
+	if (spec->use_alt_functions)
 		ca0132_alt_init(codec);
 	ca0132_download_dsp(codec);
 	case QUIRK_R3DI:
 		r3di_setup_defaults(codec);
 		break;
-	case QUIRK_NONE:
+	case QUIRK_SBZ:
-	case QUIRK_ALIENWARE:
+		break;
+	default:
 		ca0132_setup_defaults(codec);
 		ca0132_init_analog_mic2(codec);
 		ca0132_init_dmic(codec);
 static void ca0132_config(struct hda_codec *codec)
 {
 	struct ca0132_spec *spec = codec->spec;
-	struct auto_pin_cfg *cfg = &spec->autocfg;
 	spec->dacs[0] = 0x2;
 	spec->dacs[1] = 0x3;
 		/* SPDIF I/O */
 		spec->dig_out = 0x05;
 		spec->multiout.dig_out_nid = spec->dig_out;
-		cfg->dig_out_pins[0] = 0x0c;
-		cfg->dig_outs = 1;
-		cfg->dig_out_type[0] = HDA_PCM_TYPE_SPDIF;
 		spec->dig_in = 0x09;
-		cfg->dig_in_pin = 0x0e;
-		cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
 		break;
 	case QUIRK_R3DI:
 		codec_dbg(codec, "%s: QUIRK_R3DI applied.\n", __func__);
 		/* SPDIF I/O */
 		spec->dig_out = 0x05;
 		spec->multiout.dig_out_nid = spec->dig_out;
-		cfg->dig_out_pins[0] = 0x0c;
-		cfg->dig_outs = 1;
-		cfg->dig_out_type[0] = HDA_PCM_TYPE_SPDIF;
 		break;
 	default:
 		spec->num_outputs = 2;
 		/* SPDIF I/O */
 		spec->dig_out = 0x05;
 		spec->multiout.dig_out_nid = spec->dig_out;
-		cfg->dig_out_pins[0] = 0x0c;
-		cfg->dig_outs = 1;
-		cfg->dig_out_type[0] = HDA_PCM_TYPE_SPDIF;
 		spec->dig_in = 0x09;
-		cfg->dig_in_pin = 0x0e;
-		cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
 		break;
 	}
 }
 static int ca0132_prepare_verbs(struct hda_codec *codec)
 {
 /* Verbs + terminator (an empty element) */
-#define NUM_SPEC_VERBS 4
+#define NUM_SPEC_VERBS 2
 	struct ca0132_spec *spec = codec->spec;
 	spec->chip_init_verbs = ca0132_init_verbs0;
 	if (!spec->spec_init_verbs)
 		return -ENOMEM;
-	/* HP jack autodetection */
-	spec->spec_init_verbs[0].nid = spec->unsol_tag_hp;
-	spec->spec_init_verbs[0].param = AC_VERB_SET_UNSOLICITED_ENABLE;
-	spec->spec_init_verbs[0].verb = AC_USRSP_EN | spec->unsol_tag_hp;
-	/* MIC1 jack autodetection */
-	spec->spec_init_verbs[1].nid = spec->unsol_tag_amic1;
-	spec->spec_init_verbs[1].param = AC_VERB_SET_UNSOLICITED_ENABLE;
-	spec->spec_init_verbs[1].verb = AC_USRSP_EN | spec->unsol_tag_amic1;
 	/* config EAPD */
-	spec->spec_init_verbs[2].nid = 0x0b;
+	spec->spec_init_verbs[0].nid = 0x0b;
-	spec->spec_init_verbs[2].param = 0x78D;
+	spec->spec_init_verbs[0].param = 0x78D;
-	spec->spec_init_verbs[2].verb = 0x00;
+	spec->spec_init_verbs[0].verb = 0x00;
 	/* Previously commented configuration */
 	/*
-	spec->spec_init_verbs[3].nid = 0x0b;
+	spec->spec_init_verbs[2].nid = 0x0b;
-	spec->spec_init_verbs[3].param = AC_VERB_SET_EAPD_BTLENABLE;
+	spec->spec_init_verbs[2].param = AC_VERB_SET_EAPD_BTLENABLE;
+	spec->spec_init_verbs[2].verb = 0x02;
+	spec->spec_init_verbs[3].nid = 0x10;
+	spec->spec_init_verbs[3].param = 0x78D;
 	spec->spec_init_verbs[3].verb = 0x02;
 	spec->spec_init_verbs[4].nid = 0x10;
-	spec->spec_init_verbs[4].param = 0x78D;
+	spec->spec_init_verbs[4].param = AC_VERB_SET_EAPD_BTLENABLE;
 	spec->spec_init_verbs[4].verb = 0x02;
-	spec->spec_init_verbs[5].nid = 0x10;
-	spec->spec_init_verbs[5].param = AC_VERB_SET_EAPD_BTLENABLE;
-	spec->spec_init_verbs[5].verb = 0x02;
 	*/
 	/* Terminator: spec->spec_init_verbs[NUM_SPEC_VERBS-1] */

sound/pci/hda/patch_hdmi.c+5−0

@@ -3741,6 +3741,11 @@ static int patch_atihdmi(struct hda_codec *codec) · 3740 unmodified lines
3741		3741
3742	spec->chmap.channels_max = max(spec->chmap.channels_max, 8u);	3742	spec->chmap.channels_max = max(spec->chmap.channels_max, 8u);
3743		3743
		3744	/* AMD GPUs have neither EPSS nor CLKSTOP bits, hence preventing
		3745	* the link-down as is. Tell the core to allow it.
		3746	*/
		3747	codec->link_down_at_suspend = 1;
		3748
3744	return 0;	3749	return 0;
3745	}	3750	}
3746		3751

sound/pci/hda/patch_realtek.c+17−3

 	SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
 	SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
 	SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
+	SND_PCI_QUIRK(0x1734, 0x1141, "FSC ESPRIMO U9210", ALC262_FIXUP_FSC_H270),
 	SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
 	SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
 	SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
 	struct alc_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
-		spec->shutup = alc_no_shutup; /* reduce click noise */
 		spec->reboot_notify = alc_d3_at_reboot; /* reduce noise */
 		spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
 		codec->power_save_node = 0; /* avoid click noises */
 /* for hda_fixup_thinkpad_acpi() */
 #include "thinkpad_helper.c"
+static void alc_fixup_thinkpad_acpi(struct hda_codec *codec,
+				    const struct hda_fixup *fix, int action)
+{
+	alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */
+	hda_fixup_thinkpad_acpi(codec, fix, action);
+}
 /* for dell wmi mic mute led */
 #include "dell_wmi_helper.c"
 	},
 	[ALC269_FIXUP_THINKPAD_ACPI] = {
 		.type = HDA_FIXUP_FUNC,
-		.v.func = hda_fixup_thinkpad_acpi,
+		.v.func = alc_fixup_thinkpad_acpi,
 		.chained = true,
 		.chain_id = ALC269_FIXUP_SKU_IGNORE,
 	},
 	SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
 	SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
 	SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
+	SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
 	SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
-	SND_PCI_QUIRK(0x17aa, 0x3138, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
+	SND_PCI_QUIRK(0x17aa, 0x3136, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
 	SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
 	SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
 	SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
 		{0x14, 0x90170110},
 		{0x19, 0x02a11030},
 		{0x21, 0x02211020}),
+	SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
+		{0x14, 0x90170110},
+		{0x19, 0x02a11030},
+		{0x1a, 0x02a11040},
+		{0x1b, 0x01014020},
+		{0x21, 0x0221101f}),
 	SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
 		{0x12, 0x90a60140},
 		{0x14, 0x90170110},

sound/pci/lx6464es/lx6464es.c+1−0

@@ -1018,6 +1018,7 @@ static int snd_lx6464es_create(struct snd_card *card, · 1017 unmodified lines
1018	chip->port_dsp_bar = pci_ioremap_bar(pci, 2);	1018	chip->port_dsp_bar = pci_ioremap_bar(pci, 2);
1019	if (!chip->port_dsp_bar) {	1019	if (!chip->port_dsp_bar) {
1020	dev_err(card->dev, "cannot remap PCI memory region\n");	1020	dev_err(card->dev, "cannot remap PCI memory region\n");
		1021	err = -ENOMEM;
1021	goto remap_pci_failed;	1022	goto remap_pci_failed;
1022	}	1023	}
1023		1024

tools/arch/arm/include/uapi/asm/kvm.h+1−0

@@ -91,6 +91,7 @@ struct kvm_regs { · 90 unmodified lines
91	#define KVM_VGIC_V3_ADDR_TYPE_DIST 2	91	#define KVM_VGIC_V3_ADDR_TYPE_DIST 2
92	#define KVM_VGIC_V3_ADDR_TYPE_REDIST 3	92	#define KVM_VGIC_V3_ADDR_TYPE_REDIST 3
93	#define KVM_VGIC_ITS_ADDR_TYPE 4	93	#define KVM_VGIC_ITS_ADDR_TYPE 4
		94	#define KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION 5
94		95
95	#define KVM_VGIC_V3_DIST_SIZE SZ_64K	96	#define KVM_VGIC_V3_DIST_SIZE SZ_64K
96	#define KVM_VGIC_V3_REDIST_SIZE (2 * SZ_64K)	97	#define KVM_VGIC_V3_REDIST_SIZE (2 * SZ_64K)

tools/arch/arm64/include/uapi/asm/kvm.h+1−0

@@ -91,6 +91,7 @@ struct kvm_regs { · 90 unmodified lines
91	#define KVM_VGIC_V3_ADDR_TYPE_DIST 2	91	#define KVM_VGIC_V3_ADDR_TYPE_DIST 2
92	#define KVM_VGIC_V3_ADDR_TYPE_REDIST 3	92	#define KVM_VGIC_V3_ADDR_TYPE_REDIST 3
93	#define KVM_VGIC_ITS_ADDR_TYPE 4	93	#define KVM_VGIC_ITS_ADDR_TYPE 4
		94	#define KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION 5
94		95
95	#define KVM_VGIC_V3_DIST_SIZE SZ_64K	96	#define KVM_VGIC_V3_DIST_SIZE SZ_64K
96	#define KVM_VGIC_V3_REDIST_SIZE (2 * SZ_64K)	97	#define KVM_VGIC_V3_REDIST_SIZE (2 * SZ_64K)

tools/arch/powerpc/include/uapi/asm/kvm.h+1−0

@@ -633,6 +633,7 @@ struct kvm_ppc_cpu_char { · 632 unmodified lines
633	#define KVM_REG_PPC_PSSCR (KVM_REG_PPC \| KVM_REG_SIZE_U64 \| 0xbd)	633	#define KVM_REG_PPC_PSSCR (KVM_REG_PPC \| KVM_REG_SIZE_U64 \| 0xbd)
634		634
635	#define KVM_REG_PPC_DEC_EXPIRY (KVM_REG_PPC \| KVM_REG_SIZE_U64 \| 0xbe)	635	#define KVM_REG_PPC_DEC_EXPIRY (KVM_REG_PPC \| KVM_REG_SIZE_U64 \| 0xbe)
		636	#define KVM_REG_PPC_ONLINE (KVM_REG_PPC \| KVM_REG_SIZE_U32 \| 0xbf)
636		637
637	/* Transactional Memory checkpointed state:	638	/* Transactional Memory checkpointed state:
638	* This is all GPRs, all VSX regs and a subset of SPRs	639	* This is all GPRs, all VSX regs and a subset of SPRs

tools/arch/powerpc/include/uapi/asm/unistd.h+1−0

@@ -398,5 +398,6 @@ · 397 unmodified lines
398	#define __NR_pkey_alloc 384	398	#define __NR_pkey_alloc 384
399	#define __NR_pkey_free 385	399	#define __NR_pkey_free 385
400	#define __NR_pkey_mprotect 386	400	#define __NR_pkey_mprotect 386
		401	#define __NR_rseq 387
401		402
402	#endif /* _UAPI_ASM_POWERPC_UNISTD_H_ */	403	#endif /* _UAPI_ASM_POWERPC_UNISTD_H_ */

tools/arch/x86/include/asm/cpufeatures.h+2−0

 #define X86_FEATURE_AMD_IBPB		(13*32+12) /* "" Indirect Branch Prediction Barrier */
 #define X86_FEATURE_AMD_IBRS		(13*32+14) /* "" Indirect Branch Restricted Speculation */
 #define X86_FEATURE_AMD_STIBP		(13*32+15) /* "" Single Thread Indirect Branch Predictors */
+#define X86_FEATURE_AMD_SSBD		(13*32+24) /* "" Speculative Store Bypass Disable */
 #define X86_FEATURE_VIRT_SSBD		(13*32+25) /* Virtualized Speculative Store Bypass Disable */
+#define X86_FEATURE_AMD_SSB_NO		(13*32+26) /* "" Speculative Store Bypass is fixed in hardware. */
 /* Thermal and Power Management Leaf, CPUID level 0x00000006 (EAX), word 14 */
 #define X86_FEATURE_DTHERM		(14*32+ 0) /* Digital Thermal Sensor */

tools/bpf/bpftool/prog.c+8−4

 		return -1;
 	}
-	if (do_pin_fd(prog_fd, argv[1])) {
+	if (do_pin_fd(prog_fd, argv[1]))
-		p_err("failed to pin program");
+		goto err_close_obj;
-		return -1;
-	}
 	if (json_output)
 		jsonw_null(json_wtr);
+	bpf_object__close(obj);
 	return 0;
+err_close_obj:
+	bpf_object__close(obj);
+	return -1;
 }
 static int do_help(int argc, char **argv)

tools/include/uapi/drm/drm.h+7−0

@@ -680,6 +680,13 @@ struct drm_get_cap { · 679 unmodified lines
680	*/	680	*/
681	#define DRM_CLIENT_CAP_ATOMIC 3	681	#define DRM_CLIENT_CAP_ATOMIC 3
682		682
		683	/**
		684	* DRM_CLIENT_CAP_ASPECT_RATIO
		685	*
		686	* If set to 1, the DRM core will provide aspect ratio information in modes.
		687	*/
		688	#define DRM_CLIENT_CAP_ASPECT_RATIO 4
		689
683	/** DRM_IOCTL_SET_CLIENT_CAP ioctl argument type */	690	/** DRM_IOCTL_SET_CLIENT_CAP ioctl argument type */
684	struct drm_set_client_cap {	691	struct drm_set_client_cap {
685	__u64 capability;	692	__u64 capability;

tools/include/uapi/linux/bpf.h+1−1

@@ -2630,7 +2630,7 @@ struct bpf_fib_lookup { · 2629 unmodified lines
2630	union {	2630	union {
2631	/* inputs to lookup */	2631	/* inputs to lookup */
2632	__u8 tos; /* AF_INET */	2632	__u8 tos; /* AF_INET */
2633	__be32 flowlabel; /* AF_INET6 */	2633	__be32 flowinfo; /* AF_INET6, flow_label + priority */
2634		2634
2635	/* output: metric of fib result (IPv4/IPv6 only) */	2635	/* output: metric of fib result (IPv4/IPv6 only) */
2636	__u32 rt_metric;	2636	__u32 rt_metric;

tools/include/uapi/linux/if_link.h+2−0

 	IFLA_BRPORT_BCAST_FLOOD,
 	IFLA_BRPORT_GROUP_FWD_MASK,
 	IFLA_BRPORT_NEIGH_SUPPRESS,
+	IFLA_BRPORT_ISOLATED,
 	__IFLA_BRPORT_MAX
 };
 #define IFLA_BRPORT_MAX (__IFLA_BRPORT_MAX - 1)
 	IFLA_VXLAN_COLLECT_METADATA,
 	IFLA_VXLAN_LABEL,
 	IFLA_VXLAN_GPE,
+	IFLA_VXLAN_TTL_INHERIT,
 	__IFLA_VXLAN_MAX
 };
 #define IFLA_VXLAN_MAX	(__IFLA_VXLAN_MAX - 1)

tools/include/uapi/linux/kvm.h+1−0

@@ -948,6 +948,7 @@ struct kvm_ppc_resize_hpt { · 947 unmodified lines
948	#define KVM_CAP_S390_BPB 152	948	#define KVM_CAP_S390_BPB 152
949	#define KVM_CAP_GET_MSR_FEATURES 153	949	#define KVM_CAP_GET_MSR_FEATURES 153
950	#define KVM_CAP_HYPERV_EVENTFD 154	950	#define KVM_CAP_HYPERV_EVENTFD 154
		951	#define KVM_CAP_HYPERV_TLBFLUSH 155
951		952
952	#ifdef KVM_CAP_IRQ_ROUTING	953	#ifdef KVM_CAP_IRQ_ROUTING
953		954

tools/perf/arch/powerpc/util/skip-callchain-idx.c+1−1

@@ -243,7 +243,7 @@ int arch_skip_callchain_idx(struct thread thread, struct ip_callchain chain) · 242 unmodified lines
243	u64 ip;	243	u64 ip;
244	u64 skip_slot = -1;	244	u64 skip_slot = -1;
245		245
246	if (chain->nr < 3)	246	if (!chain \|\| chain->nr < 3)
247	return skip_slot;	247	return skip_slot;
248		248
249	ip = chain->ips[2];	249	ip = chain->ips[2];

tools/perf/arch/x86/entry/syscalls/syscall_64.tbl+2−0

@@ -341,6 +341,8 @@ · 340 unmodified lines
341	330 common pkey_alloc __x64_sys_pkey_alloc	341	330 common pkey_alloc __x64_sys_pkey_alloc
342	331 common pkey_free __x64_sys_pkey_free	342	331 common pkey_free __x64_sys_pkey_free
343	332 common statx __x64_sys_statx	343	332 common statx __x64_sys_statx
		344	333 common io_pgetevents __x64_sys_io_pgetevents
		345	334 common rseq __x64_sys_rseq
344		346
345	#	347	#
346	# x32-specific system call numbers start at 512 to avoid cache impact	348	# x32-specific system call numbers start at 512 to avoid cache impact

tools/perf/bench/numa.c+3−2

 	u8 *global_data;
 	u8 *process_data;
 	u8 *thread_data;
-	u64 bytes_done;
+	u64 bytes_done, secs;
 	long work_done;
 	u32 l;
 	struct rusage rusage;
 	timersub(&stop, &start0, &diff);
 	td->runtime_ns = diff.tv_sec * NSEC_PER_SEC;
 	td->runtime_ns += diff.tv_usec * NSEC_PER_USEC;
-	td->speed_gbs = bytes_done / (td->runtime_ns / NSEC_PER_SEC) / 1e9;
+	secs = td->runtime_ns / NSEC_PER_SEC;
+	td->speed_gbs = secs ? bytes_done / secs / 1e9 : 0;
 	getrusage(RUSAGE_THREAD, &rusage);
 	td->system_time_ns = rusage.ru_stime.tv_sec * NSEC_PER_SEC;

tools/perf/builtin-annotate.c+10−1

 	return ret;
 }
+static int process_feature_event(struct perf_tool *tool,
+				 union perf_event *event,
+				 struct perf_session *session)
+{
+	if (event->feat.feat_id < HEADER_LAST_FEATURE)
+		return perf_event__process_feature(tool, event, session);
+	return 0;
+}
 static int hist_entry__tty_annotate(struct hist_entry *he,
 				    struct perf_evsel *evsel,
 				    struct perf_annotate *ann)
 			.attr	= perf_event__process_attr,
 			.build_id = perf_event__process_build_id,
 			.tracing_data   = perf_event__process_tracing_data,
-			.feature	= perf_event__process_feature,
+			.feature	= process_feature_event,
 			.ordered_events = true,
 			.ordering_requires_timestamps = true,
 		},

tools/perf/builtin-report.c+2−1

@@ -217,7 +217,8 @@ static int process_feature_event(struct perf_tool *tool, · 216 unmodified lines
217	}	217	}
218		218
219	/*	219	/*
220	* All features are received, we can force the	220	* (feat_id = HEADER_LAST_FEATURE) is the end marker which
		221	* means all features are received, now we can force the
221	* group if needed.	222	* group if needed.
222	*/	223	*/
223	setup_forced_leader(rep, session->evlist);	224	setup_forced_leader(rep, session->evlist);

tools/perf/builtin-script.c+27−3

 	struct perf_evlist *evlist;
 	struct perf_evsel *evsel, *pos;
 	int err;
+	static struct perf_evsel_script *es;
 	err = perf_event__process_attr(tool, event, pevlist);
 	if (err)
 	evlist = *pevlist;
 	evsel = perf_evlist__last(*pevlist);
+	if (!evsel->priv) {
+		if (scr->per_event_dump) {
+			evsel->priv = perf_evsel_script__new(evsel,
+						scr->session->data);
+		} else {
+			es = zalloc(sizeof(*es));
+			if (!es)
+				return -ENOMEM;
+			es->fp = stdout;
+			evsel->priv = es;
+		}
+	}
 	if (evsel->attr.type >= PERF_TYPE_MAX &&
 	    evsel->attr.type != PERF_TYPE_SYNTH)
 		return 0;
 	return set_maps(script);
 }
+static int process_feature_event(struct perf_tool *tool,
+				 union perf_event *event,
+				 struct perf_session *session)
+{
+	if (event->feat.feat_id < HEADER_LAST_FEATURE)
+		return perf_event__process_feature(tool, event, session);
+	return 0;
+}
 #ifdef HAVE_AUXTRACE_SUPPORT
 static int perf_script__process_auxtrace_info(struct perf_tool *tool,
 					      union perf_event *event,
 			.attr		 = process_attr,
 			.event_update   = perf_event__process_event_update,
 			.tracing_data	 = perf_event__process_tracing_data,
-			.feature	 = perf_event__process_feature,
+			.feature	 = process_feature_event,
 			.build_id	 = perf_event__process_build_id,
 			.id_index	 = perf_event__process_id_index,
 			.auxtrace_info	 = perf_script__process_auxtrace_info,
 		     "+field to add and -field to remove."
 		     "Valid types: hw,sw,trace,raw,synth. "
 		     "Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso,"
-		     "addr,symoff,period,iregs,uregs,brstack,brstacksym,flags,"
+		     "addr,symoff,srcline,period,iregs,uregs,brstack,"
-		     "bpf-output,callindent,insn,insnlen,brstackinsn,synth,phys_addr",
+		     "brstacksym,flags,bpf-output,brstackinsn,brstackoff,"
+		     "callindent,insn,insnlen,synth,phys_addr,metric,misc",
 		     parse_output_fields),
 	OPT_BOOLEAN('a', "all-cpus", &system_wide,
 		    "system-wide collection from all CPUs"),

tools/perf/tests/parse-events.c+20−5

 	return 0;
 }
+static bool test__intel_pt_valid(void)
+{
+	return !!perf_pmu__find("intel_pt");
+}
 static int test__intel_pt(struct perf_evlist *evlist)
 {
 	struct perf_evsel *evsel = perf_evlist__first(evlist);
 	const char *name;
 	__u32 type;
 	const int id;
+	bool (*valid)(void);
 	int (*check)(struct perf_evlist *evlist);
 };
 	},
 	{
 		.name  = "intel_pt//u",
+		.valid = test__intel_pt_valid,
 		.check = test__intel_pt,
 		.id    = 52,
 	},
 static int test_event(struct evlist_test *e)
 {
+	struct parse_events_error err = { .idx = 0, };
 	struct perf_evlist *evlist;
 	int ret;
+	if (e->valid && !e->valid()) {
+		pr_debug("... SKIP");
+		return 0;
+	}
 	evlist = perf_evlist__new();
 	if (evlist == NULL)
 		return -ENOMEM;
-	ret = parse_events(evlist, e->name, NULL);
+	ret = parse_events(evlist, e->name, &err);
 	if (ret) {
-		pr_debug("failed to parse event '%s', err %d\n",
+		pr_debug("failed to parse event '%s', err %d, str '%s'\n",
-			 e->name, ret);
+			 e->name, ret, err.str);
+		parse_events_print_error(&err, e->name);
 	} else {
 		ret = e->check(evlist);
 	}
 	for (i = 0; i < cnt; i++) {
 		struct evlist_test *e = &events[i];
-		pr_debug("running test %d '%s'\n", e->id, e->name);
+		pr_debug("running test %d '%s'", e->id, e->name);
 		ret1 = test_event(e);
 		if (ret1)
 			ret2 = ret1;
+		pr_debug("\n");
 	}
 	return ret2;
 	}
 	while (!ret && (ent = readdir(dir))) {
-		struct evlist_test e;
+		struct evlist_test e = { .id = 0, };
 		char name[2 * NAME_MAX + 1 + 12 + 3];
 		/* Names containing . are special and cannot be used directly */

tools/perf/tests/topology.c+1−0

@@ -45,6 +45,7 @@ static int session_write_header(char *path) · 44 unmodified lines
45		45
46	perf_header__set_feat(&session->header, HEADER_CPU_TOPOLOGY);	46	perf_header__set_feat(&session->header, HEADER_CPU_TOPOLOGY);
47	perf_header__set_feat(&session->header, HEADER_NRCPUS);	47	perf_header__set_feat(&session->header, HEADER_NRCPUS);
		48	perf_header__set_feat(&session->header, HEADER_ARCH);
48		49
49	session->header.data_size += DATA_SIZE;	50	session->header.data_size += DATA_SIZE;
50		51

tools/perf/util/c++/clang.cpp+9−2

 	raw_svector_ostream ostream(*Buffer);
 	legacy::PassManager PM;
-	if (TargetMachine->addPassesToEmitFile(PM, ostream,
+	bool NotAdded;
-					       TargetMachine::CGFT_ObjectFile)) {
+#if CLANG_VERSION_MAJOR < 7
+	NotAdded = TargetMachine->addPassesToEmitFile(PM, ostream,
+						      TargetMachine::CGFT_ObjectFile);
+#else
+	NotAdded = TargetMachine->addPassesToEmitFile(PM, ostream, nullptr,
+						      TargetMachine::CGFT_ObjectFile);
+#endif
+	if (NotAdded) {
 		llvm::errs() << "TargetMachine can't emit a file of this type\n";
 		return std::unique_ptr<llvm::SmallVectorImpl<char>>(nullptr);;
 	}

tools/perf/util/header.c+10−2

 	int cpu_nr = ff->ph->env.nr_cpus_avail;
 	u64 size = 0;
 	struct perf_header *ph = ff->ph;
+	bool do_core_id_test = true;
 	ph->env.cpu = calloc(cpu_nr, sizeof(*ph->env.cpu));
 	if (!ph->env.cpu)
 		return 0;
 	}
+	/* On s390 the socket_id number is not related to the numbers of cpus.
+	 * The socket_id number might be higher than the numbers of cpus.
+	 * This depends on the configuration.
+	 */
+	if (ph->env.arch && !strncmp(ph->env.arch, "s390", 4))
+		do_core_id_test = false;
 	for (i = 0; i < (u32)cpu_nr; i++) {
 		if (do_read_u32(ff, &nr))
 			goto free_cpu;
 		if (do_read_u32(ff, &nr))
 			goto free_cpu;
-		if (nr != (u32)-1 && nr > (u32)cpu_nr) {
+		if (do_core_id_test && nr != (u32)-1 && nr > (u32)cpu_nr) {
 			pr_debug("socket_id number is too big."
 				 "You may need to upgrade the perf tool.\n");
 			goto free_cpu;
 		pr_warning("invalid record type %d in pipe-mode\n", type);
 		return 0;
 	}
-	if (feat == HEADER_RESERVED || feat > HEADER_LAST_FEATURE) {
+	if (feat == HEADER_RESERVED || feat >= HEADER_LAST_FEATURE) {
 		pr_warning("invalid record type %d in pipe-mode\n", type);
 		return -1;
 	}

tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.c+1−1

@@ -366,7 +366,7 @@ static int intel_pt_get_cyc(unsigned int byte, const unsigned char *buf, · 365 unmodified lines
366	if (len < offs)	366	if (len < offs)
367	return INTEL_PT_NEED_MORE_BYTES;	367	return INTEL_PT_NEED_MORE_BYTES;
368	byte = buf[offs++];	368	byte = buf[offs++];
369	payload \|= (byte >> 1) << shift;	369	payload \|= ((uint64_t)byte >> 1) << shift;
370	}	370	}
371		371
372	packet->type = INTEL_PT_CYC;	372	packet->type = INTEL_PT_CYC;

tools/perf/util/pmu.c+97−2

@@ -234,6 +234,74 @@ static int perf_pmu__parse_snapshot(struct perf_pmu_alias *alias, · 233 unmodified lines
234	return 0;	234	return 0;
235	}	235	}
236		236
		237	static void perf_pmu_assign_str(char name, const char field, char **old_str,
		238	char **new_str)
		239	{
		240	if (!*old_str)
		241	goto set_new;
		242
		243	if (new_str) { / Have new string, check with old */
		244	if (strcasecmp(old_str, new_str))
		245	pr_debug("alias %s differs in field '%s'\n",
		246	name, field);
		247	zfree(old_str);
		248	} else /* Nothing new --> keep old string */
		249	return;
		250	set_new:
		251	old_str = new_str;
		252	*new_str = NULL;
		253	}
		254
		255	static void perf_pmu_update_alias(struct perf_pmu_alias *old,
		256	struct perf_pmu_alias *newalias)
		257	{
		258	perf_pmu_assign_str(old->name, "desc", &old->desc, &newalias->desc);
		259	perf_pmu_assign_str(old->name, "long_desc", &old->long_desc,
		260	&newalias->long_desc);
		261	perf_pmu_assign_str(old->name, "topic", &old->topic, &newalias->topic);
		262	perf_pmu_assign_str(old->name, "metric_expr", &old->metric_expr,
		263	&newalias->metric_expr);
		264	perf_pmu_assign_str(old->name, "metric_name", &old->metric_name,
		265	&newalias->metric_name);
		266	perf_pmu_assign_str(old->name, "value", &old->str, &newalias->str);
		267	old->scale = newalias->scale;
		268	old->per_pkg = newalias->per_pkg;
		269	old->snapshot = newalias->snapshot;
		270	memcpy(old->unit, newalias->unit, sizeof(old->unit));
		271	}
		272
		273	/* Delete an alias entry. */
		274	static void perf_pmu_free_alias(struct perf_pmu_alias *newalias)
		275	{
		276	zfree(&newalias->name);
		277	zfree(&newalias->desc);
		278	zfree(&newalias->long_desc);
		279	zfree(&newalias->topic);
		280	zfree(&newalias->str);
		281	zfree(&newalias->metric_expr);
		282	zfree(&newalias->metric_name);
		283	parse_events_terms__purge(&newalias->terms);
		284	free(newalias);
		285	}
		286
		287	/* Merge an alias, search in alias list. If this name is already
		288	* present merge both of them to combine all information.
		289	*/
		290	static bool perf_pmu_merge_alias(struct perf_pmu_alias *newalias,
		291	struct list_head *alist)
		292	{
		293	struct perf_pmu_alias *a;
		294
		295	list_for_each_entry(a, alist, list) {
		296	if (!strcasecmp(newalias->name, a->name)) {
		297	perf_pmu_update_alias(a, newalias);
		298	perf_pmu_free_alias(newalias);
		299	return true;
		300	}
		301	}
		302	return false;
		303	}
		304
237	static int __perf_pmu__new_alias(struct list_head list, char dir, char *name,	305	static int __perf_pmu__new_alias(struct list_head list, char dir, char *name,
238	char desc, char val,	306	char desc, char val,
239	char long_desc, char topic,	307	char long_desc, char topic,
@@ -241,9 +309,11 @@ static int __perf_pmu__new_alias(struct list_head list, char dir, char *name, · 1 unmodified line
241	char *metric_expr,	309	char *metric_expr,
242	char *metric_name)	310	char *metric_name)
243	{	311	{
		312	struct parse_events_term *term;
244	struct perf_pmu_alias *alias;	313	struct perf_pmu_alias *alias;
245	int ret;	314	int ret;
246	int num;	315	int num;
		316	char newval[256];
247		317
248	alias = malloc(sizeof(*alias));	318	alias = malloc(sizeof(*alias));
249	if (!alias)	319	if (!alias)
@@ -262,6 +332,27 @@ static int __perf_pmu__new_alias(struct list_head list, char dir, char *name, · 12 unmodified lines
262	return ret;	332	return ret;
263	}	333	}
264		334
		335	/* Scan event and remove leading zeroes, spaces, newlines, some
		336	* platforms have terms specified as
		337	* event=0x0091 (read from files ../<PMU>/events/<FILE>
		338	* and terms specified as event=0x91 (read from JSON files).
		339	*
		340	* Rebuild string to make alias->str member comparable.
		341	*/
		342	memset(newval, 0, sizeof(newval));
		343	ret = 0;
		344	list_for_each_entry(term, &alias->terms, list) {
		345	if (ret)
		346	ret += scnprintf(newval + ret, sizeof(newval) - ret,
		347	",");
		348	if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM)
		349	ret += scnprintf(newval + ret, sizeof(newval) - ret,
		350	"%s=%#x", term->config, term->val.num);
		351	else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR)
		352	ret += scnprintf(newval + ret, sizeof(newval) - ret,
		353	"%s=%s", term->config, term->val.str);
		354	}
		355
265	alias->name = strdup(name);	356	alias->name = strdup(name);
266	if (dir) {	357	if (dir) {
267	/*	358	/*
@@ -285,9 +376,10 @@ static int __perf_pmu__new_alias(struct list_head list, char dir, char *name, · 17 unmodified lines
285	snprintf(alias->unit, sizeof(alias->unit), "%s", unit);	376	snprintf(alias->unit, sizeof(alias->unit), "%s", unit);
286	}	377	}
287	alias->per_pkg = perpkg && sscanf(perpkg, "%d", &num) == 1 && num == 1;	378	alias->per_pkg = perpkg && sscanf(perpkg, "%d", &num) == 1 && num == 1;
288	alias->str = strdup(val);	379	alias->str = strdup(newval);
289		380
290	list_add_tail(&alias->list, list);	381	if (!perf_pmu_merge_alias(alias, list))
		382	list_add_tail(&alias->list, list);
291		383
292	return 0;	384	return 0;
293	}	385	}
@@ -303,6 +395,9 @@ static int perf_pmu__new_alias(struct list_head list, char dir, char *name, FI · 9 unmodified lines
303		395
304	buf[ret] = 0;	396	buf[ret] = 0;
305		397
		398	/* Remove trailing newline from sysfs file */
		399	rtrim(buf);
		400
306	return __perf_pmu__new_alias(list, dir, name, NULL, buf, NULL, NULL, NULL,	401	return __perf_pmu__new_alias(list, dir, name, NULL, buf, NULL, NULL, NULL,
307	NULL, NULL, NULL);	402	NULL, NULL, NULL);
308	}	403	}

tools/testing/selftests/bpf/config+1−0

@@ -6,6 +6,7 @@ CONFIG_TEST_BPF=m · 5 unmodified lines
6	CONFIG_CGROUP_BPF=y	6	CONFIG_CGROUP_BPF=y
7	CONFIG_NETDEVSIM=m	7	CONFIG_NETDEVSIM=m
8	CONFIG_NET_CLS_ACT=y	8	CONFIG_NET_CLS_ACT=y
		9	CONFIG_NET_SCHED=y
9	CONFIG_NET_SCH_INGRESS=y	10	CONFIG_NET_SCH_INGRESS=y
10	CONFIG_NET_IPIP=y	11	CONFIG_NET_IPIP=y
11	CONFIG_IPV6=y	12	CONFIG_IPV6=y

tools/testing/selftests/bpf/test_kmod.sh+9−0

@@ -1,6 +1,15 @@
1	#!/bin/sh	1	#!/bin/sh
2	# SPDX-License-Identifier: GPL-2.0	2	# SPDX-License-Identifier: GPL-2.0
3		3
		4	# Kselftest framework requirement - SKIP code is 4.
		5	ksft_skip=4
		6
		7	msg="skip all tests:"
		8	if [ "$(id -u)" != "0" ]; then
		9	echo $msg please run this as root >&2
		10	exit $ksft_skip
		11	fi
		12
4	SRC_TREE=../../../../	13	SRC_TREE=../../../../
5		14
6	test_run()	15	test_run()

tools/testing/selftests/bpf/test_lirc_mode2.sh+9−0

@@ -1,6 +1,15 @@
1	#!/bin/bash	1	#!/bin/bash
2	# SPDX-License-Identifier: GPL-2.0	2	# SPDX-License-Identifier: GPL-2.0
3		3
		4	# Kselftest framework requirement - SKIP code is 4.
		5	ksft_skip=4
		6
		7	msg="skip all tests:"
		8	if [ $UID != 0 ]; then
		9	echo $msg please run this as root >&2
		10	exit $ksft_skip
		11	fi
		12
4	GREEN='\033[0;92m'	13	GREEN='\033[0;92m'
5	RED='\033[0;31m'	14	RED='\033[0;31m'
6	NC='\033[0m' # No Color	15	NC='\033[0m' # No Color

tools/testing/selftests/bpf/test_lwt_seg6local.sh+9−0

@@ -21,6 +21,15 @@ · 20 unmodified lines
21	# An UDP datagram is sent from fb00::1 to fb00::6. The test succeeds if this	21	# An UDP datagram is sent from fb00::1 to fb00::6. The test succeeds if this
22	# datagram can be read on NS6 when binding to fb00::6.	22	# datagram can be read on NS6 when binding to fb00::6.
23		23
		24	# Kselftest framework requirement - SKIP code is 4.
		25	ksft_skip=4
		26
		27	msg="skip all tests:"
		28	if [ $UID != 0 ]; then
		29	echo $msg please run this as root >&2
		30	exit $ksft_skip
		31	fi
		32
24	TMP_FILE="/tmp/selftest_lwt_seg6local.txt"	33	TMP_FILE="/tmp/selftest_lwt_seg6local.txt"
25		34
26	cleanup()	35	cleanup()

tools/testing/selftests/bpf/test_sockmap.c+0−6

 int main(int argc, char **argv)
 {
-	struct rlimit r = {10 * 1024 * 1024, RLIM_INFINITY};
 	int iov_count = 1, length = 1024, rate = 1;
 	struct sockmap_options options = {0};
 	int opt, longindex, err, cg_fd = 0;
 	char *bpf_file = BPF_SOCKMAP_FILENAME;
 	int test = PING_PONG;
-	if (setrlimit(RLIMIT_MEMLOCK, &r)) {
-		perror("setrlimit(RLIMIT_MEMLOCK)");
-		return 1;
-	}
 	if (argc < 2)
 		return test_suite();

tools/testing/selftests/net/fib_tests.sh+0−0

File mode changed from 100644 to 100755.

tools/testing/selftests/x86/sigreturn.c+36−23

@@ -610,21 +610,41 @@ static int test_valid_sigreturn(int cs_bits, bool use_16bit_ss, int force_ss) · 609 unmodified lines
610	*/	610	*/
611	for (int i = 0; i < NGREG; i++) {	611	for (int i = 0; i < NGREG; i++) {
612	greg_t req = requested_regs[i], res = resulting_regs[i];	612	greg_t req = requested_regs[i], res = resulting_regs[i];
		613
613	if (i == REG_TRAPNO \|\| i == REG_IP)	614	if (i == REG_TRAPNO \|\| i == REG_IP)
614	continue; /* don't care */	615	continue; /* don't care */
615	if (i == REG_SP) {
616	printf("\tSP: %llx -> %llx\n", (unsigned long long)req,
617	(unsigned long long)res);
618		616
		617	if (i == REG_SP) {
619	/*	618	/*
620	* In many circumstances, the high 32 bits of rsp	619	* If we were using a 16-bit stack segment, then
621	* are zeroed. For example, we could be a real	620	* the kernel is a bit stuck: IRET only restores
622	* 32-bit program, or we could hit any of a number	621	* the low 16 bits of ESP/RSP if SS is 16-bit.
623	* of poorly-documented IRET or segmented ESP	622	* The kernel uses a hack to restore bits 31:16,
624	* oddities. If this happens, it's okay.	623	* but that hack doesn't help with bits 63:32.
		624	* On Intel CPUs, bits 63:32 end up zeroed, and, on
		625	* AMD CPUs, they leak the high bits of the kernel
		626	* espfix64 stack pointer. There's very little that
		627	* the kernel can do about it.
		628	*
		629	* Similarly, if we are returning to a 32-bit context,
		630	* the CPU will often lose the high 32 bits of RSP.
625	*/	631	*/
626	if (res == (req & 0xFFFFFFFF))	632
627	continue; /* OK; not expected to work */	633	if (res == req)
		634	continue;
		635
		636	if (cs_bits != 64 && ((res ^ req) & 0xFFFFFFFF) == 0) {
		637	printf("[NOTE]\tSP: %llx -> %llx\n",
		638	(unsigned long long)req,
		639	(unsigned long long)res);
		640	continue;
		641	}
		642
		643	printf("[FAIL]\tSP mismatch: requested 0x%llx; got 0x%llx\n",
		644	(unsigned long long)requested_regs[i],
		645	(unsigned long long)resulting_regs[i]);
		646	nerrs++;
		647	continue;
628	}	648	}
629		649
630	bool ignore_reg = false;	650	bool ignore_reg = false;
@@ -654,25 +674,18 @@ static int test_valid_sigreturn(int cs_bits, bool use_16bit_ss, int force_ss) · 23 unmodified lines
654	#endif	674	#endif
655		675
656	/* Sanity check on the kernel */	676	/* Sanity check on the kernel */
657	if (i == REG_CX && requested_regs[i] != resulting_regs[i]) {	677	if (i == REG_CX && req != res) {
658	printf("[FAIL]\tCX (saved SP) mismatch: requested 0x%llx; got 0x%llx\n",	678	printf("[FAIL]\tCX (saved SP) mismatch: requested 0x%llx; got 0x%llx\n",
659	(unsigned long long)requested_regs[i],	679	(unsigned long long)req,
660	(unsigned long long)resulting_regs[i]);	680	(unsigned long long)res);
661	nerrs++;	681	nerrs++;
662	continue;	682	continue;
663	}	683	}
664		684
665	if (requested_regs[i] != resulting_regs[i] && !ignore_reg) {	685	if (req != res && !ignore_reg) {
666	/*
667	* SP is particularly interesting here. The
668	* usual cause of failures is that we hit the
669	* nasty IRET case of returning to a 16-bit SS,
670	* in which case bits 16:31 of the kernel
671	* stack pointer persist in ESP.
672	*/
673	printf("[FAIL]\tReg %d mismatch: requested 0x%llx; got 0x%llx\n",	686	printf("[FAIL]\tReg %d mismatch: requested 0x%llx; got 0x%llx\n",
674	i, (unsigned long long)requested_regs[i],	687	i, (unsigned long long)req,
675	(unsigned long long)resulting_regs[i]);	688	(unsigned long long)res);
676	nerrs++;	689	nerrs++;
677	}	690	}
678	}	691	}

tools/virtio/linux/scatterlist.h+0−18

 	 */
 	BUG_ON((unsigned long) page & 0x03);
 #ifdef CONFIG_DEBUG_SG
-	BUG_ON(sg->sg_magic != SG_MAGIC);
 	BUG_ON(sg_is_chain(sg));
 #endif
 	sg->page_link = page_link | (unsigned long) page;
 static inline struct page *sg_page(struct scatterlist *sg)
 {
 #ifdef CONFIG_DEBUG_SG
-	BUG_ON(sg->sg_magic != SG_MAGIC);
 	BUG_ON(sg_is_chain(sg));
 #endif
 	return (struct page *)((sg)->page_link & ~0x3);
  **/
 static inline void sg_mark_end(struct scatterlist *sg)
 {
-#ifdef CONFIG_DEBUG_SG
-	BUG_ON(sg->sg_magic != SG_MAGIC);
-#endif
 	/*
 	 * Set termination bit, clear potential chain bit
 	 */
  **/
 static inline void sg_unmark_end(struct scatterlist *sg)
 {
-#ifdef CONFIG_DEBUG_SG
-	BUG_ON(sg->sg_magic != SG_MAGIC);
-#endif
 	sg->page_link &= ~0x02;
 }
 static inline struct scatterlist *sg_next(struct scatterlist *sg)
 {
-#ifdef CONFIG_DEBUG_SG
-	BUG_ON(sg->sg_magic != SG_MAGIC);
-#endif
 	if (sg_is_last(sg))
 		return NULL;
 static inline void sg_init_table(struct scatterlist *sgl, unsigned int nents)
 {
 	memset(sgl, 0, sizeof(*sgl) * nents);
-#ifdef CONFIG_DEBUG_SG
-	{
-		unsigned int i;
-		for (i = 0; i < nents; i++)
-			sgl[i].sg_magic = SG_MAGIC;
-	}
-#endif
 	sg_mark_end(&sgl[nents - 1]);
 }

Merge ra.kernel.org:/pub/scm/linux/kernel/git/davem/net

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -570,7 +570,7 @@ const struct proto_ops inet6_stream_ops = { · 569 unmodified lines
570	.socketpair = sock_no_socketpair, /* a do nothing */	570	.socketpair = sock_no_socketpair, /* a do nothing */
571	.accept = inet_accept, /* ok */	571	.accept = inet_accept, /* ok */
572	.getname = inet6_getname,	572	.getname = inet6_getname,
573	.poll_mask = tcp_poll_mask, /* ok */	573	.poll = tcp_poll, /* ok */
574	.ioctl = inet6_ioctl, /* must change */	574	.ioctl = inet6_ioctl, /* must change */
575	.listen = inet_listen, /* ok */	575	.listen = inet_listen, /* ok */
576	.shutdown = inet_shutdown, /* ok */	576	.shutdown = inet_shutdown, /* ok */
@@ -603,7 +603,7 @@ const struct proto_ops inet6_dgram_ops = { · 26 unmodified lines
603	.socketpair = sock_no_socketpair, /* a do nothing */	603	.socketpair = sock_no_socketpair, /* a do nothing */
604	.accept = sock_no_accept, /* a do nothing */	604	.accept = sock_no_accept, /* a do nothing */
605	.getname = inet6_getname,	605	.getname = inet6_getname,
606	.poll_mask = udp_poll_mask, /* ok */	606	.poll = udp_poll, /* ok */
607	.ioctl = inet6_ioctl, /* must change */	607	.ioctl = inet6_ioctl, /* must change */
608	.listen = sock_no_listen, /* ok */	608	.listen = sock_no_listen, /* ok */
609	.shutdown = inet_shutdown, /* ok */	609	.shutdown = inet_shutdown, /* ok */