lael-labs/linux

Documentation/accounting/psi.txt+6−6

@@ -56,12 +56,12 @@ situation from a state where some tasks are stalled but the CPU is · 55 unmodified lines
56	still doing productive work. As such, time spent in this subset of the	56	still doing productive work. As such, time spent in this subset of the
57	stall state is tracked separately and exported in the "full" averages.	57	stall state is tracked separately and exported in the "full" averages.
58		58
59	The ratios are tracked as recent trends over ten, sixty, and three	59	The ratios (in %) are tracked as recent trends over ten, sixty, and
60	hundred second windows, which gives insight into short term events as	60	three hundred second windows, which gives insight into short term events
61	well as medium and long term trends. The total absolute stall time is	61	as well as medium and long term trends. The total absolute stall time
62	tracked and exported as well, to allow detection of latency spikes	62	(in us) is tracked and exported as well, to allow detection of latency
63	which wouldn't necessarily make a dent in the time averages, or to	63	spikes which wouldn't necessarily make a dent in the time averages,
64	average trends over custom time frames.	64	or to average trends over custom time frames.
65		65
66	Cgroup2 interface	66	Cgroup2 interface
67	=================	67	=================

Documentation/devicetree/bindings/arm/cpus.yaml+1−1

@@ -228,7 +228,7 @@ patternProperties: · 227 unmodified lines
228	- renesas,r9a06g032-smp	228	- renesas,r9a06g032-smp
229	- rockchip,rk3036-smp	229	- rockchip,rk3036-smp
230	- rockchip,rk3066-smp	230	- rockchip,rk3066-smp
231	- socionext,milbeaut-m10v-smp	231	- socionext,milbeaut-m10v-smp
232	- ste,dbx500-smp	232	- ste,dbx500-smp
233		233
234	cpu-release-addr:	234	cpu-release-addr:

Documentation/lzo.txt+5−3

                 dictionary which is empty, and that it will always be
                 invalid at this place.
-      17      : bitstream version. If the first byte is 17, the next byte
+      17      : bitstream version. If the first byte is 17, and compressed
-                gives the bitstream version (version 1 only). If the first byte
+                stream length is at least 5 bytes (length of shortest possible
-                is not 17, the bitstream version is 0.
+                versioned bitstream), the next byte gives the bitstream version
+                (version 1 only).
+                Otherwise, the bitstream version is 0.
       18..21  : copy 0..3 literals
                 state = (byte - 17) = 0..3  [ copy <state> literals ]

MAINTAINERS+4−3

 ARM/NUVOTON NPCM ARCHITECTURE
 M:	Avi Fishman <avifishman70@gmail.com>
 M:	Tomer Maimon <tmaimon77@gmail.com>
+M:	Tali Perry <tali.perry1@gmail.com>
 R:	Patrick Venture <venture@google.com>
 R:	Nancy Yuen <yuenn@google.com>
-R:	Brendan Higgins <brendanhiggins@google.com>
+R:	Benjamin Fair <benjaminfair@google.com>
 L:	openbmc@lists.ozlabs.org (moderated for non-subscribers)
 S:	Supported
 F:	arch/arm/mach-npcm/
 F:	arch/arm/boot/dts/nuvoton-npcm*
-F:	include/dt-bindings/clock/nuvoton,npcm7xx-clks.h
+F:	include/dt-bindings/clock/nuvoton,npcm7xx-clock.h
 F:	drivers/*/*npcm*
 F:	Documentation/devicetree/bindings/*/*npcm*
 F:	Documentation/devicetree/bindings/*/*/*npcm*
 F:	include/net/af_ieee802154.h
 F:	include/net/cfg802154.h
 F:	include/net/ieee802154_netdev.h
-F:	Documentation/networking/ieee802154.txt
+F:	Documentation/networking/ieee802154.rst
 IFE PROTOCOL
 M:	Yotam Gigi <yotam.gi@gmail.com>

Makefile+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	VERSION = 5	2	VERSION = 5
3	PATCHLEVEL = 1	3	PATCHLEVEL = 1
4	SUBLEVEL = 0	4	SUBLEVEL = 0
5	EXTRAVERSION = -rc3	5	EXTRAVERSION = -rc4
6	NAME = Shy Crocodile	6	NAME = Shy Crocodile
7		7
8	# DOCUMENTATION	8	# DOCUMENTATION

arch/arc/include/asm/syscall.h+3−4

@@ -55,12 +55,11 @@ syscall_set_return_value(struct task_struct task, struct pt_regs regs, · 54 unmodified lines
55	*/	55	*/
56	static inline void	56	static inline void
57	syscall_get_arguments(struct task_struct task, struct pt_regs regs,	57	syscall_get_arguments(struct task_struct task, struct pt_regs regs,
58	unsigned int i, unsigned int n, unsigned long *args)	58	unsigned long *args)
59	{	59	{
60	unsigned long *inside_ptregs = &(regs->r0);	60	unsigned long *inside_ptregs = &(regs->r0);
61	inside_ptregs -= i;	61	unsigned int n = 6;
62		62	unsigned int i = 0;
63	BUG_ON((i + n) > 6);
64		63
65	while (n--) {	64	while (n--) {
66	args[i++] = (*inside_ptregs);	65	args[i++] = (*inside_ptregs);

arch/arm/boot/dts/am335x-evm.dts+22−4

@@ -57,6 +57,24 @@ · 56 unmodified lines
57	enable-active-high;	57	enable-active-high;
58	};	58	};
59		59
		60	/* TPS79501 */
		61	v1_8d_reg: fixedregulator-v1_8d {
		62	compatible = "regulator-fixed";
		63	regulator-name = "v1_8d";
		64	vin-supply = <&vbat>;
		65	regulator-min-microvolt = <1800000>;
		66	regulator-max-microvolt = <1800000>;
		67	};
		68
		69	/* TPS79501 */
		70	v3_3d_reg: fixedregulator-v3_3d {
		71	compatible = "regulator-fixed";
		72	regulator-name = "v3_3d";
		73	vin-supply = <&vbat>;
		74	regulator-min-microvolt = <3300000>;
		75	regulator-max-microvolt = <3300000>;
		76	};
		77
60	matrix_keypad: matrix_keypad0 {	78	matrix_keypad: matrix_keypad0 {
61	compatible = "gpio-matrix-keypad";	79	compatible = "gpio-matrix-keypad";
62	debounce-delay-ms = <5>;	80	debounce-delay-ms = <5>;
@@ -499,10 +517,10 @@ · 436 unmodified lines
499	status = "okay";	517	status = "okay";
500		518
501	/* Regulators */	519	/* Regulators */
502	AVDD-supply = <&vaux2_reg>;	520	AVDD-supply = <&v3_3d_reg>;
503	IOVDD-supply = <&vaux2_reg>;	521	IOVDD-supply = <&v3_3d_reg>;
504	DRVDD-supply = <&vaux2_reg>;	522	DRVDD-supply = <&v3_3d_reg>;
505	DVDD-supply = <&vbat>;	523	DVDD-supply = <&v1_8d_reg>;
506	};	524	};
507	};	525	};
508		526

arch/arm/boot/dts/am335x-evmsk.dts+22−4

@@ -73,6 +73,24 @@ · 72 unmodified lines
73	enable-active-high;	73	enable-active-high;
74	};	74	};
75		75
		76	/* TPS79518 */
		77	v1_8d_reg: fixedregulator-v1_8d {
		78	compatible = "regulator-fixed";
		79	regulator-name = "v1_8d";
		80	vin-supply = <&vbat>;
		81	regulator-min-microvolt = <1800000>;
		82	regulator-max-microvolt = <1800000>;
		83	};
		84
		85	/* TPS78633 */
		86	v3_3d_reg: fixedregulator-v3_3d {
		87	compatible = "regulator-fixed";
		88	regulator-name = "v3_3d";
		89	vin-supply = <&vbat>;
		90	regulator-min-microvolt = <3300000>;
		91	regulator-max-microvolt = <3300000>;
		92	};
		93
76	leds {	94	leds {
77	pinctrl-names = "default";	95	pinctrl-names = "default";
78	pinctrl-0 = <&user_leds_s0>;	96	pinctrl-0 = <&user_leds_s0>;
@@ -501,10 +519,10 @@ · 422 unmodified lines
501	status = "okay";	519	status = "okay";
502		520
503	/* Regulators */	521	/* Regulators */
504	AVDD-supply = <&vaux2_reg>;	522	AVDD-supply = <&v3_3d_reg>;
505	IOVDD-supply = <&vaux2_reg>;	523	IOVDD-supply = <&v3_3d_reg>;
506	DRVDD-supply = <&vaux2_reg>;	524	DRVDD-supply = <&v3_3d_reg>;
507	DVDD-supply = <&vbat>;	525	DVDD-supply = <&v1_8d_reg>;
508	};	526	};
509	};	527	};
510		528

arch/arm/boot/dts/am33xx-l4.dtsi+2−2

@@ -1762,7 +1762,7 @@ · 1761 unmodified lines
1762	reg = <0xcc000 0x4>;	1762	reg = <0xcc000 0x4>;
1763	reg-names = "rev";	1763	reg-names = "rev";
1764	/* Domains (P, C): per_pwrdm, l4ls_clkdm */	1764	/* Domains (P, C): per_pwrdm, l4ls_clkdm */
1765	clocks = <&l4ls_clkctrl AM3_D_CAN0_CLKCTRL 0>;	1765	clocks = <&l4ls_clkctrl AM3_L4LS_D_CAN0_CLKCTRL 0>;
1766	clock-names = "fck";	1766	clock-names = "fck";
1767	#address-cells = <1>;	1767	#address-cells = <1>;
1768	#size-cells = <1>;	1768	#size-cells = <1>;
@@ -1785,7 +1785,7 @@ · 16 unmodified lines
1785	reg = <0xd0000 0x4>;	1785	reg = <0xd0000 0x4>;
1786	reg-names = "rev";	1786	reg-names = "rev";
1787	/* Domains (P, C): per_pwrdm, l4ls_clkdm */	1787	/* Domains (P, C): per_pwrdm, l4ls_clkdm */
1788	clocks = <&l4ls_clkctrl AM3_D_CAN1_CLKCTRL 0>;	1788	clocks = <&l4ls_clkctrl AM3_L4LS_D_CAN1_CLKCTRL 0>;
1789	clock-names = "fck";	1789	clock-names = "fck";
1790	#address-cells = <1>;	1790	#address-cells = <1>;
1791	#size-cells = <1>;	1791	#size-cells = <1>;

arch/arm/boot/dts/rk3288-tinker.dtsi+2−1

 			};
 			vccio_sd: LDO_REG5 {
+				regulator-boot-on;
 				regulator-min-microvolt = <1800000>;
 				regulator-max-microvolt = <3300000>;
 				regulator-name = "vccio_sd";
 	bus-width = <4>;
 	cap-mmc-highspeed;
 	cap-sd-highspeed;
-	card-detect-delay = <200>;
+	broken-cd;
 	disable-wp;			/* wp not hooked up */
 	pinctrl-names = "default";
 	pinctrl-0 = <&sdmmc_clk &sdmmc_cmd &sdmmc_cd &sdmmc_bus4>;

arch/arm/boot/dts/rk3288-veyron.dtsi+0−2

@@ -25,8 +25,6 @@ · 24 unmodified lines
25		25
26	gpio_keys: gpio-keys {	26	gpio_keys: gpio-keys {
27	compatible = "gpio-keys";	27	compatible = "gpio-keys";
28	#address-cells = <1>;
29	#size-cells = <0>;
30		28
31	pinctrl-names = "default";	29	pinctrl-names = "default";
32	pinctrl-0 = <&pwr_key_l>;	30	pinctrl-0 = <&pwr_key_l>;

arch/arm/boot/dts/rk3288.dtsi+9−11

 			compatible = "arm,cortex-a12";
 			reg = <0x501>;
 			resets = <&cru SRST_CORE1>;
-			operating-points = <&cpu_opp_table>;
+			operating-points-v2 = <&cpu_opp_table>;
 			#cooling-cells = <2>; /* min followed by max */
 			clock-latency = <40000>;
 			clocks = <&cru ARMCLK>;
 			compatible = "arm,cortex-a12";
 			reg = <0x502>;
 			resets = <&cru SRST_CORE2>;
-			operating-points = <&cpu_opp_table>;
+			operating-points-v2 = <&cpu_opp_table>;
 			#cooling-cells = <2>; /* min followed by max */
 			clock-latency = <40000>;
 			clocks = <&cru ARMCLK>;
 			compatible = "arm,cortex-a12";
 			reg = <0x503>;
 			resets = <&cru SRST_CORE3>;
-			operating-points = <&cpu_opp_table>;
+			operating-points-v2 = <&cpu_opp_table>;
 			#cooling-cells = <2>; /* min followed by max */
 			clock-latency = <40000>;
 			clocks = <&cru ARMCLK>;
 		clock-names = "ref", "pclk";
 		power-domains = <&power RK3288_PD_VIO>;
 		rockchip,grf = <&grf>;
-		#address-cells = <1>;
-		#size-cells = <0>;
 		status = "disabled";
 		ports {
 	gpu_opp_table: gpu-opp-table {
 		compatible = "operating-points-v2";
-		opp@100000000 {
+		opp-100000000 {
 			opp-hz = /bits/ 64 <100000000>;
 			opp-microvolt = <950000>;
 		};
-		opp@200000000 {
+		opp-200000000 {
 			opp-hz = /bits/ 64 <200000000>;
 			opp-microvolt = <950000>;
 		};
-		opp@300000000 {
+		opp-300000000 {
 			opp-hz = /bits/ 64 <300000000>;
 			opp-microvolt = <1000000>;
 		};
-		opp@400000000 {
+		opp-400000000 {
 			opp-hz = /bits/ 64 <400000000>;
 			opp-microvolt = <1100000>;
 		};
-		opp@500000000 {
+		opp-500000000 {
 			opp-hz = /bits/ 64 <500000000>;
 			opp-microvolt = <1200000>;
 		};
-		opp@600000000 {
+		opp-600000000 {
 			opp-hz = /bits/ 64 <600000000>;
 			opp-microvolt = <1250000>;
 		};

arch/arm/boot/dts/sama5d2-pinfunc.h+1−1

@@ -518,7 +518,7 @@ · 517 unmodified lines
518	#define PIN_PC9__GPIO PINMUX_PIN(PIN_PC9, 0, 0)	518	#define PIN_PC9__GPIO PINMUX_PIN(PIN_PC9, 0, 0)
519	#define PIN_PC9__FIQ PINMUX_PIN(PIN_PC9, 1, 3)	519	#define PIN_PC9__FIQ PINMUX_PIN(PIN_PC9, 1, 3)
520	#define PIN_PC9__GTSUCOMP PINMUX_PIN(PIN_PC9, 2, 1)	520	#define PIN_PC9__GTSUCOMP PINMUX_PIN(PIN_PC9, 2, 1)
521	#define PIN_PC9__ISC_D0 PINMUX_PIN(PIN_PC9, 2, 1)	521	#define PIN_PC9__ISC_D0 PINMUX_PIN(PIN_PC9, 3, 1)
522	#define PIN_PC9__TIOA4 PINMUX_PIN(PIN_PC9, 4, 2)	522	#define PIN_PC9__TIOA4 PINMUX_PIN(PIN_PC9, 4, 2)
523	#define PIN_PC10 74	523	#define PIN_PC10 74
524	#define PIN_PC10__GPIO PINMUX_PIN(PIN_PC10, 0, 0)	524	#define PIN_PC10__GPIO PINMUX_PIN(PIN_PC10, 0, 0)

arch/arm/boot/dts/ste-nomadik-nhk15.dts+4−5

 		gpio-sck = <&gpio0 5 GPIO_ACTIVE_HIGH>;
 		gpio-mosi = <&gpio0 4 GPIO_ACTIVE_HIGH>;
 		/*
-		 * This chipselect is active high. Just setting the flags
+		 * It's not actually active high, but the frameworks assume
-		 * to GPIO_ACTIVE_HIGH is not enough for the SPI DT bindings,
+		 * the polarity of the passed-in GPIO is "normal" (active
-		 * it will be ignored, only the special "spi-cs-high" flag
+		 * high) then actively drives the line low to select the
-		 * really counts.
+		 * chip.
 		 */
 		cs-gpios = <&gpio0 6 GPIO_ACTIVE_HIGH>;
-		spi-cs-high;
 		num-chipselects = <1>;
 		/*

arch/arm/include/asm/syscall.h+8−39

@@ -55,53 +55,22 @@ static inline void syscall_set_return_value(struct task_struct *task, · 54 unmodified lines
55		55
56	static inline void syscall_get_arguments(struct task_struct *task,	56	static inline void syscall_get_arguments(struct task_struct *task,
57	struct pt_regs *regs,	57	struct pt_regs *regs,
58	unsigned int i, unsigned int n,
59	unsigned long *args)	58	unsigned long *args)
60	{	59	{
61	if (n == 0)	60	args[0] = regs->ARM_ORIG_r0;
62	return;	61	args++;
63		62
64	if (i + n > SYSCALL_MAX_ARGS) {	63	memcpy(args, &regs->ARM_r0 + 1, 5 * sizeof(args[0]));
65	unsigned long *args_bad = args + SYSCALL_MAX_ARGS - i;
66	unsigned int n_bad = n + i - SYSCALL_MAX_ARGS;
67	pr_warn("%s called with max args %d, handling only %d\n",
68	__func__, i + n, SYSCALL_MAX_ARGS);
69	memset(args_bad, 0, n_bad * sizeof(args[0]));
70	n = SYSCALL_MAX_ARGS - i;
71	}
72
73	if (i == 0) {
74	args[0] = regs->ARM_ORIG_r0;
75	args++;
76	i++;
77	n--;
78	}
79
80	memcpy(args, &regs->ARM_r0 + i, n * sizeof(args[0]));
81	}	64	}
82		65
83	static inline void syscall_set_arguments(struct task_struct *task,	66	static inline void syscall_set_arguments(struct task_struct *task,
84	struct pt_regs *regs,	67	struct pt_regs *regs,
85	unsigned int i, unsigned int n,
86	const unsigned long *args)	68	const unsigned long *args)
87	{	69	{
88	if (n == 0)	70	regs->ARM_ORIG_r0 = args[0];
89	return;	71	args++;
90		72
91	if (i + n > SYSCALL_MAX_ARGS) {	73	memcpy(&regs->ARM_r0 + 1, args, 5 * sizeof(args[0]));
92	pr_warn("%s called with max args %d, handling only %d\n",
93	__func__, i + n, SYSCALL_MAX_ARGS);
94	n = SYSCALL_MAX_ARGS - i;
95	}
96
97	if (i == 0) {
98	regs->ARM_ORIG_r0 = args[0];
99	args++;
100	i++;
101	n--;
102	}
103
104	memcpy(&regs->ARM_r0 + i, args, n * sizeof(args[0]));
105	}	74	}
106		75
107	static inline int syscall_get_arch(void)	76	static inline int syscall_get_arch(void)

arch/arm/mach-at91/pm.c+4−2

 	np = of_find_compatible_node(NULL, NULL, "atmel,sama5d2-securam");
 	if (!np)
-		goto securam_fail;
+		goto securam_fail_no_ref_dev;
 	pdev = of_find_device_by_node(np);
 	of_node_put(np);
 	if (!pdev) {
 		pr_warn("%s: failed to find securam device!\n", __func__);
-		goto securam_fail;
+		goto securam_fail_no_ref_dev;
 	}
 	sram_pool = gen_pool_get(&pdev->dev, NULL);
 	return 0;
 securam_fail:
+	put_device(&pdev->dev);
+securam_fail_no_ref_dev:
 	iounmap(pm_data.sfrbu);
 	pm_data.sfrbu = NULL;
 	return ret;

arch/arm/mach-iop13xx/setup.c+4−4

@@ -300,7 +300,7 @@ static struct resource iop13xx_adma_2_resources[] = { · 299 unmodified lines
300	}	300	}
301	};	301	};
302		302
303	static u64 iop13xx_adma_dmamask = DMA_BIT_MASK(64);	303	static u64 iop13xx_adma_dmamask = DMA_BIT_MASK(32);
304	static struct iop_adma_platform_data iop13xx_adma_0_data = {	304	static struct iop_adma_platform_data iop13xx_adma_0_data = {
305	.hw_id = 0,	305	.hw_id = 0,
306	.pool_size = PAGE_SIZE,	306	.pool_size = PAGE_SIZE,
@@ -324,7 +324,7 @@ static struct platform_device iop13xx_adma_0_channel = { · 17 unmodified lines
324	.resource = iop13xx_adma_0_resources,	324	.resource = iop13xx_adma_0_resources,
325	.dev = {	325	.dev = {
326	.dma_mask = &iop13xx_adma_dmamask,	326	.dma_mask = &iop13xx_adma_dmamask,
327	.coherent_dma_mask = DMA_BIT_MASK(64),	327	.coherent_dma_mask = DMA_BIT_MASK(32),
328	.platform_data = (void *) &iop13xx_adma_0_data,	328	.platform_data = (void *) &iop13xx_adma_0_data,
329	},	329	},
330	};	330	};
@@ -336,7 +336,7 @@ static struct platform_device iop13xx_adma_1_channel = { · 5 unmodified lines
336	.resource = iop13xx_adma_1_resources,	336	.resource = iop13xx_adma_1_resources,
337	.dev = {	337	.dev = {
338	.dma_mask = &iop13xx_adma_dmamask,	338	.dma_mask = &iop13xx_adma_dmamask,
339	.coherent_dma_mask = DMA_BIT_MASK(64),	339	.coherent_dma_mask = DMA_BIT_MASK(32),
340	.platform_data = (void *) &iop13xx_adma_1_data,	340	.platform_data = (void *) &iop13xx_adma_1_data,
341	},	341	},
342	};	342	};
@@ -348,7 +348,7 @@ static struct platform_device iop13xx_adma_2_channel = { · 5 unmodified lines
348	.resource = iop13xx_adma_2_resources,	348	.resource = iop13xx_adma_2_resources,
349	.dev = {	349	.dev = {
350	.dma_mask = &iop13xx_adma_dmamask,	350	.dma_mask = &iop13xx_adma_dmamask,
351	.coherent_dma_mask = DMA_BIT_MASK(64),	351	.coherent_dma_mask = DMA_BIT_MASK(32),
352	.platform_data = (void *) &iop13xx_adma_2_data,	352	.platform_data = (void *) &iop13xx_adma_2_data,
353	},	353	},
354	};	354	};

arch/arm/mach-iop13xx/tpmi.c+5−5

@@ -152,7 +152,7 @@ static struct resource iop13xx_tpmi_3_resources[] = { · 151 unmodified lines
152	}	152	}
153	};	153	};
154		154
155	u64 iop13xx_tpmi_mask = DMA_BIT_MASK(64);	155	u64 iop13xx_tpmi_mask = DMA_BIT_MASK(32);
156	static struct platform_device iop13xx_tpmi_0_device = {	156	static struct platform_device iop13xx_tpmi_0_device = {
157	.name = "iop-tpmi",	157	.name = "iop-tpmi",
158	.id = 0,	158	.id = 0,
@@ -160,7 +160,7 @@ static struct platform_device iop13xx_tpmi_0_device = { · 1 unmodified line
160	.resource = iop13xx_tpmi_0_resources,	160	.resource = iop13xx_tpmi_0_resources,
161	.dev = {	161	.dev = {
162	.dma_mask = &iop13xx_tpmi_mask,	162	.dma_mask = &iop13xx_tpmi_mask,
163	.coherent_dma_mask = DMA_BIT_MASK(64),	163	.coherent_dma_mask = DMA_BIT_MASK(32),
164	},	164	},
165	};	165	};
166		166
@@ -171,7 +171,7 @@ static struct platform_device iop13xx_tpmi_1_device = { · 4 unmodified lines
171	.resource = iop13xx_tpmi_1_resources,	171	.resource = iop13xx_tpmi_1_resources,
172	.dev = {	172	.dev = {
173	.dma_mask = &iop13xx_tpmi_mask,	173	.dma_mask = &iop13xx_tpmi_mask,
174	.coherent_dma_mask = DMA_BIT_MASK(64),	174	.coherent_dma_mask = DMA_BIT_MASK(32),
175	},	175	},
176	};	176	};
177		177
@@ -182,7 +182,7 @@ static struct platform_device iop13xx_tpmi_2_device = { · 4 unmodified lines
182	.resource = iop13xx_tpmi_2_resources,	182	.resource = iop13xx_tpmi_2_resources,
183	.dev = {	183	.dev = {
184	.dma_mask = &iop13xx_tpmi_mask,	184	.dma_mask = &iop13xx_tpmi_mask,
185	.coherent_dma_mask = DMA_BIT_MASK(64),	185	.coherent_dma_mask = DMA_BIT_MASK(32),
186	},	186	},
187	};	187	};
188		188
@@ -193,7 +193,7 @@ static struct platform_device iop13xx_tpmi_3_device = { · 4 unmodified lines
193	.resource = iop13xx_tpmi_3_resources,	193	.resource = iop13xx_tpmi_3_resources,
194	.dev = {	194	.dev = {
195	.dma_mask = &iop13xx_tpmi_mask,	195	.dma_mask = &iop13xx_tpmi_mask,
196	.coherent_dma_mask = DMA_BIT_MASK(64),	196	.coherent_dma_mask = DMA_BIT_MASK(32),
197	},	197	},
198	};	198	};
199		199

arch/arm/mach-milbeaut/platsmp.c+4−0

 		writel(KERNEL_UNBOOT_FLAG, m10v_smp_base + cpu * 4);
 }
+#ifdef CONFIG_HOTPLUG_CPU
 static void m10v_cpu_die(unsigned int l_cpu)
 {
 	gic_cpu_if_down(0);
 	return 1;
 }
+#endif
 static struct smp_operations m10v_smp_ops __initdata = {
 	.smp_prepare_cpus	= m10v_smp_init,
 	.smp_boot_secondary	= m10v_boot_secondary,
+#ifdef CONFIG_HOTPLUG_CPU
 	.cpu_die		= m10v_cpu_die,
 	.cpu_kill		= m10v_cpu_kill,
+#endif
 };
 CPU_METHOD_OF_DECLARE(m10v_smp, "socionext,milbeaut-m10v-smp", &m10v_smp_ops);

arch/arm/mach-omap1/board-ams-delta.c+2−0

 static struct bgpio_pdata latch1_pdata = {
 	.label	= LATCH1_LABEL,
+	.base	= -1,
 	.ngpio	= LATCH1_NGPIO,
 };
 static struct bgpio_pdata latch2_pdata = {
 	.label	= LATCH2_LABEL,
+	.base	= -1,
 	.ngpio	= LATCH2_NGPIO,
 };

arch/arm/mach-omap2/display.c+3−1

@@ -250,8 +250,10 @@ static int __init omapdss_init_of(void) · 249 unmodified lines
250	if (!node)	250	if (!node)
251	return 0;	251	return 0;
252		252
253	if (!of_device_is_available(node))	253	if (!of_device_is_available(node)) {
		254	of_node_put(node);
254	return 0;	255	return 0;
		256	}
255		257
256	pdev = of_find_device_by_node(node);	258	pdev = of_find_device_by_node(node);
257		259

arch/arm/plat-iop/adma.c+3−3

@@ -143,7 +143,7 @@ struct platform_device iop3xx_dma_0_channel = { · 142 unmodified lines
143	.resource = iop3xx_dma_0_resources,	143	.resource = iop3xx_dma_0_resources,
144	.dev = {	144	.dev = {
145	.dma_mask = &iop3xx_adma_dmamask,	145	.dma_mask = &iop3xx_adma_dmamask,
146	.coherent_dma_mask = DMA_BIT_MASK(64),	146	.coherent_dma_mask = DMA_BIT_MASK(32),
147	.platform_data = (void *) &iop3xx_dma_0_data,	147	.platform_data = (void *) &iop3xx_dma_0_data,
148	},	148	},
149	};	149	};
@@ -155,7 +155,7 @@ struct platform_device iop3xx_dma_1_channel = { · 5 unmodified lines
155	.resource = iop3xx_dma_1_resources,	155	.resource = iop3xx_dma_1_resources,
156	.dev = {	156	.dev = {
157	.dma_mask = &iop3xx_adma_dmamask,	157	.dma_mask = &iop3xx_adma_dmamask,
158	.coherent_dma_mask = DMA_BIT_MASK(64),	158	.coherent_dma_mask = DMA_BIT_MASK(32),
159	.platform_data = (void *) &iop3xx_dma_1_data,	159	.platform_data = (void *) &iop3xx_dma_1_data,
160	},	160	},
161	};	161	};
@@ -167,7 +167,7 @@ struct platform_device iop3xx_aau_channel = { · 5 unmodified lines
167	.resource = iop3xx_aau_resources,	167	.resource = iop3xx_aau_resources,
168	.dev = {	168	.dev = {
169	.dma_mask = &iop3xx_adma_dmamask,	169	.dma_mask = &iop3xx_adma_dmamask,
170	.coherent_dma_mask = DMA_BIT_MASK(64),	170	.coherent_dma_mask = DMA_BIT_MASK(32),
171	.platform_data = (void *) &iop3xx_aau_data,	171	.platform_data = (void *) &iop3xx_aau_data,
172	},	172	},
173	};	173	};

arch/arm/plat-orion/common.c+2−2

@@ -622,7 +622,7 @@ static struct platform_device orion_xor0_shared = { · 621 unmodified lines
622	.resource = orion_xor0_shared_resources,	622	.resource = orion_xor0_shared_resources,
623	.dev = {	623	.dev = {
624	.dma_mask = &orion_xor_dmamask,	624	.dma_mask = &orion_xor_dmamask,
625	.coherent_dma_mask = DMA_BIT_MASK(64),	625	.coherent_dma_mask = DMA_BIT_MASK(32),
626	.platform_data = &orion_xor0_pdata,	626	.platform_data = &orion_xor0_pdata,
627	},	627	},
628	};	628	};
@@ -683,7 +683,7 @@ static struct platform_device orion_xor1_shared = { · 54 unmodified lines
683	.resource = orion_xor1_shared_resources,	683	.resource = orion_xor1_shared_resources,
684	.dev = {	684	.dev = {
685	.dma_mask = &orion_xor_dmamask,	685	.dma_mask = &orion_xor_dmamask,
686	.coherent_dma_mask = DMA_BIT_MASK(64),	686	.coherent_dma_mask = DMA_BIT_MASK(32),
687	.platform_data = &orion_xor1_pdata,	687	.platform_data = &orion_xor1_pdata,
688	},	688	},
689	};	689	};

arch/arm64/boot/dts/altera/socfpga_stratix10.dtsi+3−0

 			rx-fifo-depth = <16384>;
 			snps,multicast-filter-bins = <256>;
 			iommus = <&smmu 1>;
+			altr,sysmgr-syscon = <&sysmgr 0x44 0>;
 			status = "disabled";
 		};
 			rx-fifo-depth = <16384>;
 			snps,multicast-filter-bins = <256>;
 			iommus = <&smmu 2>;
+			altr,sysmgr-syscon = <&sysmgr 0x48 0>;
 			status = "disabled";
 		};
 			rx-fifo-depth = <16384>;
 			snps,multicast-filter-bins = <256>;
 			iommus = <&smmu 3>;
+			altr,sysmgr-syscon = <&sysmgr 0x4c 0>;
 			status = "disabled";
 		};

arch/arm64/boot/dts/rockchip/rk3328-roc-cc.dts+2−2

@@ -108,8 +108,8 @@ · 107 unmodified lines
108	snps,reset-gpio = <&gpio1 RK_PC2 GPIO_ACTIVE_LOW>;	108	snps,reset-gpio = <&gpio1 RK_PC2 GPIO_ACTIVE_LOW>;
109	snps,reset-active-low;	109	snps,reset-active-low;
110	snps,reset-delays-us = <0 10000 50000>;	110	snps,reset-delays-us = <0 10000 50000>;
111	tx_delay = <0x25>;	111	tx_delay = <0x24>;
112	rx_delay = <0x11>;	112	rx_delay = <0x18>;
113	status = "okay";	113	status = "okay";
114	};	114	};
115		115

arch/arm64/boot/dts/rockchip/rk3328-rock64.dts+1−2

@@ -46,8 +46,7 @@ · 45 unmodified lines
46		46
47	vcc_host1_5v: vcc_otg_5v: vcc-host1-5v-regulator {	47	vcc_host1_5v: vcc_otg_5v: vcc-host1-5v-regulator {
48	compatible = "regulator-fixed";	48	compatible = "regulator-fixed";
49	enable-active-high;	49	gpio = <&gpio0 RK_PA2 GPIO_ACTIVE_LOW>;
50	gpio = <&gpio0 RK_PA2 GPIO_ACTIVE_HIGH>;
51	pinctrl-names = "default";	50	pinctrl-names = "default";
52	pinctrl-0 = <&usb20_host_drv>;	51	pinctrl-0 = <&usb20_host_drv>;
53	regulator-name = "vcc_host1_5v";	52	regulator-name = "vcc_host1_5v";

arch/arm64/boot/dts/rockchip/rk3328.dtsi+29−29

@@ -1445,11 +1445,11 @@ · 1444 unmodified lines
1445		1445
1446	sdmmc0 {	1446	sdmmc0 {
1447	sdmmc0_clk: sdmmc0-clk {	1447	sdmmc0_clk: sdmmc0-clk {
1448	rockchip,pins = <1 RK_PA6 1 &pcfg_pull_none_4ma>;	1448	rockchip,pins = <1 RK_PA6 1 &pcfg_pull_none_8ma>;
1449	};	1449	};
1450		1450
1451	sdmmc0_cmd: sdmmc0-cmd {	1451	sdmmc0_cmd: sdmmc0-cmd {
1452	rockchip,pins = <1 RK_PA4 1 &pcfg_pull_up_4ma>;	1452	rockchip,pins = <1 RK_PA4 1 &pcfg_pull_up_8ma>;
1453	};	1453	};
1454		1454
1455	sdmmc0_dectn: sdmmc0-dectn {	1455	sdmmc0_dectn: sdmmc0-dectn {
@@ -1461,14 +1461,14 @@ · 5 unmodified lines
1461	};	1461	};
1462		1462
1463	sdmmc0_bus1: sdmmc0-bus1 {	1463	sdmmc0_bus1: sdmmc0-bus1 {
1464	rockchip,pins = <1 RK_PA0 1 &pcfg_pull_up_4ma>;	1464	rockchip,pins = <1 RK_PA0 1 &pcfg_pull_up_8ma>;
1465	};	1465	};
1466		1466
1467	sdmmc0_bus4: sdmmc0-bus4 {	1467	sdmmc0_bus4: sdmmc0-bus4 {
1468	rockchip,pins = <1 RK_PA0 1 &pcfg_pull_up_4ma>,	1468	rockchip,pins = <1 RK_PA0 1 &pcfg_pull_up_8ma>,
1469	<1 RK_PA1 1 &pcfg_pull_up_4ma>,	1469	<1 RK_PA1 1 &pcfg_pull_up_8ma>,
1470	<1 RK_PA2 1 &pcfg_pull_up_4ma>,	1470	<1 RK_PA2 1 &pcfg_pull_up_8ma>,
1471	<1 RK_PA3 1 &pcfg_pull_up_4ma>;	1471	<1 RK_PA3 1 &pcfg_pull_up_8ma>;
1472	};	1472	};
1473		1473
1474	sdmmc0_gpio: sdmmc0-gpio {	1474	sdmmc0_gpio: sdmmc0-gpio {
@@ -1642,50 +1642,50 @@ · 167 unmodified lines
1642	rgmiim1_pins: rgmiim1-pins {	1642	rgmiim1_pins: rgmiim1-pins {
1643	rockchip,pins =	1643	rockchip,pins =
1644	/* mac_txclk */	1644	/* mac_txclk */
1645	<1 RK_PB4 2 &pcfg_pull_none_12ma>,	1645	<1 RK_PB4 2 &pcfg_pull_none_8ma>,
1646	/* mac_rxclk */	1646	/* mac_rxclk */
1647	<1 RK_PB5 2 &pcfg_pull_none_2ma>,	1647	<1 RK_PB5 2 &pcfg_pull_none_4ma>,
1648	/* mac_mdio */	1648	/* mac_mdio */
1649	<1 RK_PC3 2 &pcfg_pull_none_2ma>,	1649	<1 RK_PC3 2 &pcfg_pull_none_4ma>,
1650	/* mac_txen */	1650	/* mac_txen */
1651	<1 RK_PD1 2 &pcfg_pull_none_12ma>,	1651	<1 RK_PD1 2 &pcfg_pull_none_8ma>,
1652	/* mac_clk */	1652	/* mac_clk */
1653	<1 RK_PC5 2 &pcfg_pull_none_2ma>,	1653	<1 RK_PC5 2 &pcfg_pull_none_4ma>,
1654	/* mac_rxdv */	1654	/* mac_rxdv */
1655	<1 RK_PC6 2 &pcfg_pull_none_2ma>,	1655	<1 RK_PC6 2 &pcfg_pull_none_4ma>,
1656	/* mac_mdc */	1656	/* mac_mdc */
1657	<1 RK_PC7 2 &pcfg_pull_none_2ma>,	1657	<1 RK_PC7 2 &pcfg_pull_none_4ma>,
1658	/* mac_rxd1 */	1658	/* mac_rxd1 */
1659	<1 RK_PB2 2 &pcfg_pull_none_2ma>,	1659	<1 RK_PB2 2 &pcfg_pull_none_4ma>,
1660	/* mac_rxd0 */	1660	/* mac_rxd0 */
1661	<1 RK_PB3 2 &pcfg_pull_none_2ma>,	1661	<1 RK_PB3 2 &pcfg_pull_none_4ma>,
1662	/* mac_txd1 */	1662	/* mac_txd1 */
1663	<1 RK_PB0 2 &pcfg_pull_none_12ma>,	1663	<1 RK_PB0 2 &pcfg_pull_none_8ma>,
1664	/* mac_txd0 */	1664	/* mac_txd0 */
1665	<1 RK_PB1 2 &pcfg_pull_none_12ma>,	1665	<1 RK_PB1 2 &pcfg_pull_none_8ma>,
1666	/* mac_rxd3 */	1666	/* mac_rxd3 */
1667	<1 RK_PB6 2 &pcfg_pull_none_2ma>,	1667	<1 RK_PB6 2 &pcfg_pull_none_4ma>,
1668	/* mac_rxd2 */	1668	/* mac_rxd2 */
1669	<1 RK_PB7 2 &pcfg_pull_none_2ma>,	1669	<1 RK_PB7 2 &pcfg_pull_none_4ma>,
1670	/* mac_txd3 */	1670	/* mac_txd3 */
1671	<1 RK_PC0 2 &pcfg_pull_none_12ma>,	1671	<1 RK_PC0 2 &pcfg_pull_none_8ma>,
1672	/* mac_txd2 */	1672	/* mac_txd2 */
1673	<1 RK_PC1 2 &pcfg_pull_none_12ma>,	1673	<1 RK_PC1 2 &pcfg_pull_none_8ma>,
1674		1674
1675	/* mac_txclk */	1675	/* mac_txclk */
1676	<0 RK_PB0 1 &pcfg_pull_none>,	1676	<0 RK_PB0 1 &pcfg_pull_none_8ma>,
1677	/* mac_txen */	1677	/* mac_txen */
1678	<0 RK_PB4 1 &pcfg_pull_none>,	1678	<0 RK_PB4 1 &pcfg_pull_none_8ma>,
1679	/* mac_clk */	1679	/* mac_clk */
1680	<0 RK_PD0 1 &pcfg_pull_none>,	1680	<0 RK_PD0 1 &pcfg_pull_none_4ma>,
1681	/* mac_txd1 */	1681	/* mac_txd1 */
1682	<0 RK_PC0 1 &pcfg_pull_none>,	1682	<0 RK_PC0 1 &pcfg_pull_none_8ma>,
1683	/* mac_txd0 */	1683	/* mac_txd0 */
1684	<0 RK_PC1 1 &pcfg_pull_none>,	1684	<0 RK_PC1 1 &pcfg_pull_none_8ma>,
1685	/* mac_txd3 */	1685	/* mac_txd3 */
1686	<0 RK_PC7 1 &pcfg_pull_none>,	1686	<0 RK_PC7 1 &pcfg_pull_none_8ma>,
1687	/* mac_txd2 */	1687	/* mac_txd2 */
1688	<0 RK_PC6 1 &pcfg_pull_none>;	1688	<0 RK_PC6 1 &pcfg_pull_none_8ma>;
1689	};	1689	};
1690		1690
1691	rmiim1_pins: rmiim1-pins {	1691	rmiim1_pins: rmiim1-pins {

arch/arm64/boot/dts/rockchip/rk3399-rock-pi-4.dts+1−0

@@ -158,6 +158,7 @@ · 157 unmodified lines
158	};	158	};
159		159
160	&hdmi {	160	&hdmi {
		161	ddc-i2c-bus = <&i2c3>;
161	pinctrl-names = "default";	162	pinctrl-names = "default";
162	pinctrl-0 = <&hdmi_cec>;	163	pinctrl-0 = <&hdmi_cec>;
163	status = "okay";	164	status = "okay";

arch/arm64/include/asm/syscall.h+8−38

@@ -65,52 +65,22 @@ static inline void syscall_set_return_value(struct task_struct *task, · 64 unmodified lines
65		65
66	static inline void syscall_get_arguments(struct task_struct *task,	66	static inline void syscall_get_arguments(struct task_struct *task,
67	struct pt_regs *regs,	67	struct pt_regs *regs,
68	unsigned int i, unsigned int n,
69	unsigned long *args)	68	unsigned long *args)
70	{	69	{
71	if (n == 0)	70	args[0] = regs->orig_x0;
72	return;	71	args++;
73		72
74	if (i + n > SYSCALL_MAX_ARGS) {	73	memcpy(args, &regs->regs[1], 5 * sizeof(args[0]));
75	unsigned long *args_bad = args + SYSCALL_MAX_ARGS - i;
76	unsigned int n_bad = n + i - SYSCALL_MAX_ARGS;
77	pr_warning("%s called with max args %d, handling only %d\n",
78	__func__, i + n, SYSCALL_MAX_ARGS);
79	memset(args_bad, 0, n_bad * sizeof(args[0]));
80	}
81
82	if (i == 0) {
83	args[0] = regs->orig_x0;
84	args++;
85	i++;
86	n--;
87	}
88
89	memcpy(args, &regs->regs[i], n * sizeof(args[0]));
90	}	74	}
91		75
92	static inline void syscall_set_arguments(struct task_struct *task,	76	static inline void syscall_set_arguments(struct task_struct *task,
93	struct pt_regs *regs,	77	struct pt_regs *regs,
94	unsigned int i, unsigned int n,
95	const unsigned long *args)	78	const unsigned long *args)
96	{	79	{
97	if (n == 0)	80	regs->orig_x0 = args[0];
98	return;	81	args++;
99		82
100	if (i + n > SYSCALL_MAX_ARGS) {	83	memcpy(&regs->regs[1], args, 5 * sizeof(args[0]));
101	pr_warning("%s called with max args %d, handling only %d\n",
102	__func__, i + n, SYSCALL_MAX_ARGS);
103	n = SYSCALL_MAX_ARGS - i;
104	}
105
106	if (i == 0) {
107	regs->orig_x0 = args[0];
108	args++;
109	i++;
110	n--;
111	}
112
113	memcpy(&regs->regs[i], args, n * sizeof(args[0]));
114	}	84	}
115		85
116	/*	86	/*

arch/arm64/kernel/sdei.c+6−0

 	unsigned long low = (unsigned long)raw_cpu_read(sdei_stack_normal_ptr);
 	unsigned long high = low + SDEI_STACK_SIZE;
+	if (!low)
+		return false;
 	if (sp < low || sp >= high)
 		return false;
 	unsigned long low = (unsigned long)raw_cpu_read(sdei_stack_critical_ptr);
 	unsigned long high = low + SDEI_STACK_SIZE;
+	if (!low)
+		return false;
 	if (sp < low || sp >= high)
 		return false;

arch/c6x/include/asm/syscall.h+14−65

@@ -46,78 +46,27 @@ static inline void syscall_set_return_value(struct task_struct *task, · 45 unmodified lines
46	}	46	}
47		47
48	static inline void syscall_get_arguments(struct task_struct *task,	48	static inline void syscall_get_arguments(struct task_struct *task,
49	struct pt_regs *regs, unsigned int i,	49	struct pt_regs *regs,
50	unsigned int n, unsigned long *args)	50	unsigned long *args)
51	{	51	{
52	switch (i) {	52	*args++ = regs->a4;
53	case 0:	53	*args++ = regs->b4;
54	if (!n--)	54	*args++ = regs->a6;
55	break;	55	*args++ = regs->b6;
56	*args++ = regs->a4;	56	*args++ = regs->a8;
57	case 1:	57	*args = regs->b8;
58	if (!n--)
59	break;
60	*args++ = regs->b4;
61	case 2:
62	if (!n--)
63	break;
64	*args++ = regs->a6;
65	case 3:
66	if (!n--)
67	break;
68	*args++ = regs->b6;
69	case 4:
70	if (!n--)
71	break;
72	*args++ = regs->a8;
73	case 5:
74	if (!n--)
75	break;
76	*args++ = regs->b8;
77	case 6:
78	if (!n--)
79	break;
80	default:
81	BUG();
82	}
83	}	58	}
84		59
85	static inline void syscall_set_arguments(struct task_struct *task,	60	static inline void syscall_set_arguments(struct task_struct *task,
86	struct pt_regs *regs,	61	struct pt_regs *regs,
87	unsigned int i, unsigned int n,
88	const unsigned long *args)	62	const unsigned long *args)
89	{	63	{
90	switch (i) {	64	regs->a4 = *args++;
91	case 0:	65	regs->b4 = *args++;
92	if (!n--)	66	regs->a6 = *args++;
93	break;	67	regs->b6 = *args++;
94	regs->a4 = *args++;	68	regs->a8 = *args++;
95	case 1:	69	regs->a9 = *args;
96	if (!n--)
97	break;
98	regs->b4 = *args++;
99	case 2:
100	if (!n--)
101	break;
102	regs->a6 = *args++;
103	case 3:
104	if (!n--)
105	break;
106	regs->b6 = *args++;
107	case 4:
108	if (!n--)
109	break;
110	regs->a8 = *args++;
111	case 5:
112	if (!n--)
113	break;
114	regs->a9 = *args++;
115	case 6:
116	if (!n)
117	break;
118	default:
119	BUG();
120	}
121	}	70	}
122		71
123	#endif /* __ASM_C6X_SYSCALLS_H */	72	#endif /* __ASM_C6X_SYSCALLS_H */

arch/csky/include/asm/syscall.h+8−18

 static inline void
 syscall_get_arguments(struct task_struct *task, struct pt_regs *regs,
-		      unsigned int i, unsigned int n, unsigned long *args)
+		      unsigned long *args)
 {
-	BUG_ON(i + n > 6);
+	args[0] = regs->orig_a0;
-	if (i == 0) {
+	args++;
-		args[0] = regs->orig_a0;
+	memcpy(args, &regs->a1, 5 * sizeof(args[0]));
-		args++;
-		i++;
-		n--;
-	}
-	memcpy(args, &regs->a1 + i * sizeof(regs->a1), n * sizeof(args[0]));
 }
 static inline void
 syscall_set_arguments(struct task_struct *task, struct pt_regs *regs,
-		      unsigned int i, unsigned int n, const unsigned long *args)
+		      const unsigned long *args)
 {
-	BUG_ON(i + n > 6);
+	regs->orig_a0 = args[0];
-	if (i == 0) {
+	args++;
-		regs->orig_a0 = args[0];
+	memcpy(&regs->a1, args, 5 * sizeof(regs->a1));
-		args++;
-		i++;
-		n--;
-	}
-	memcpy(&regs->a1 + i * sizeof(regs->a1), args, n * sizeof(regs->a0));
 }
 static inline int

arch/h8300/include/asm/syscall.h+7−27

@@ -17,34 +17,14 @@ syscall_get_nr(struct task_struct task, struct pt_regs regs) · 16 unmodified lines
17		17
18	static inline void	18	static inline void
19	syscall_get_arguments(struct task_struct task, struct pt_regs regs,	19	syscall_get_arguments(struct task_struct task, struct pt_regs regs,
20	unsigned int i, unsigned int n, unsigned long *args)	20	unsigned long *args)
21	{	21	{
22	BUG_ON(i + n > 6);	22	*args++ = regs->er1;
23		23	*args++ = regs->er2;
24	while (n > 0) {	24	*args++ = regs->er3;
25	switch (i) {	25	*args++ = regs->er4;
26	case 0:	26	*args++ = regs->er5;
27	*args++ = regs->er1;	27	*args = regs->er6;
28	break;
29	case 1:
30	*args++ = regs->er2;
31	break;
32	case 2:
33	*args++ = regs->er3;
34	break;
35	case 3:
36	*args++ = regs->er4;
37	break;
38	case 4:
39	*args++ = regs->er5;
40	break;
41	case 5:
42	*args++ = regs->er6;
43	break;
44	}
45	i++;
46	n--;
47	}
48	}	28	}
49		29
50		30

arch/hexagon/include/asm/syscall.h+1−3

 static inline void syscall_get_arguments(struct task_struct *task,
 					 struct pt_regs *regs,
-					 unsigned int i, unsigned int n,
 					 unsigned long *args)
 {
-	BUG_ON(i + n > 6);
+	memcpy(args, &(&regs->r00)[0], 6 * sizeof(args[0]));
-	memcpy(args, &(&regs->r00)[i], n * sizeof(args[0]));
 }
 #endif

arch/ia64/include/asm/syscall.h+3−10

 }
 extern void ia64_syscall_get_set_arguments(struct task_struct *task,
-	struct pt_regs *regs, unsigned int i, unsigned int n,
+	struct pt_regs *regs, unsigned long *args, int rw);
-	unsigned long *args, int rw);
 static inline void syscall_get_arguments(struct task_struct *task,
 					 struct pt_regs *regs,
-					 unsigned int i, unsigned int n,
 					 unsigned long *args)
 {
-	BUG_ON(i + n > 6);
+	ia64_syscall_get_set_arguments(task, regs, args, 0);
-	ia64_syscall_get_set_arguments(task, regs, i, n, args, 0);
 }
 static inline void syscall_set_arguments(struct task_struct *task,
 					 struct pt_regs *regs,
-					 unsigned int i, unsigned int n,
 					 unsigned long *args)
 {
-	BUG_ON(i + n > 6);
+	ia64_syscall_get_set_arguments(task, regs, args, 1);
-	ia64_syscall_get_set_arguments(task, regs, i, n, args, 1);
 }
 static inline int syscall_get_arch(void)

arch/ia64/kernel/ptrace.c+3−4

 }
 void ia64_syscall_get_set_arguments(struct task_struct *task,
-	struct pt_regs *regs, unsigned int i, unsigned int n,
+	struct pt_regs *regs, unsigned long *args, int rw)
-	unsigned long *args, int rw)
 {
 	struct syscall_get_set_args data = {
-		.i = i,
+		.i = 0,
-		.n = n,
+		.n = 6,
 		.args = args,
 		.regs = regs,
 		.rw = rw,

arch/microblaze/include/asm/syscall.h+6−2

 static inline void syscall_get_arguments(struct task_struct *task,
 					 struct pt_regs *regs,
-					 unsigned int i, unsigned int n,
 					 unsigned long *args)
 {
+	unsigned int i = 0;
+	unsigned int n = 6;
 	while (n--)
 		*args++ = microblaze_get_syscall_arg(regs, i++);
 }
 static inline void syscall_set_arguments(struct task_struct *task,
 					 struct pt_regs *regs,
-					 unsigned int i, unsigned int n,
 					 const unsigned long *args)
 {
+	unsigned int i = 0;
+	unsigned int n = 6;
 	while (n--)
 		microblaze_set_syscall_arg(regs, i++, *args++);
 }

arch/mips/include/asm/syscall.h+2−1

 static inline void syscall_get_arguments(struct task_struct *task,
 					 struct pt_regs *regs,
-					 unsigned int i, unsigned int n,
 					 unsigned long *args)
 {
+	unsigned int i = 0;
+	unsigned int n = 6;
 	int ret;
 	/* O32 ABI syscall() */

arch/mips/kernel/ptrace.c+1−1

@@ -1419,7 +1419,7 @@ asmlinkage long syscall_trace_enter(struct pt_regs *regs, long syscall) · 1418 unmodified lines
1419		1419
1420	sd.nr = syscall;	1420	sd.nr = syscall;
1421	sd.arch = syscall_get_arch();	1421	sd.arch = syscall_get_arch();
1422	syscall_get_arguments(current, regs, 0, 6, args);	1422	syscall_get_arguments(current, regs, args);
1423	for (i = 0; i < 6; i++)	1423	for (i = 0; i < 6; i++)
1424	sd.args[i] = args[i];	1424	sd.args[i] = args[i];
1425	sd.instruction_pointer = KSTK_EIP(current);	1425	sd.instruction_pointer = KSTK_EIP(current);

arch/nds32/include/asm/syscall.h+11−51

  * syscall_get_arguments - extract system call parameter values
  * @task:	task of interest, must be blocked
  * @regs:	task_pt_regs() of @task
- * @i:		argument index [0,5]
- * @n:		number of arguments; n+i must be [1,6].
  * @args:	array filled with argument values
  *
- * Fetches @n arguments to the system call starting with the @i'th argument
+ * Fetches 6 arguments to the system call (from 0 through 5). The first
- * (from 0 through 5).  Argument @i is stored in @args[0], and so on.
+ * argument is stored in @args[0], and so on.
- * An arch inline version is probably optimal when @i and @n are constants.
  *
  * It's only valid to call this when @task is stopped for tracing on
  * entry to a system call, due to %TIF_SYSCALL_TRACE or %TIF_SYSCALL_AUDIT.
- * It's invalid to call this with @i + @n > 6; we only support system calls
- * taking up to 6 arguments.
  */
 #define SYSCALL_MAX_ARGS 6
 void syscall_get_arguments(struct task_struct *task, struct pt_regs *regs,
-			   unsigned int i, unsigned int n, unsigned long *args)
+			   unsigned long *args)
 {
-	if (n == 0)
+	args[0] = regs->orig_r0;
-		return;
+	args++;
-	if (i + n > SYSCALL_MAX_ARGS) {
+	memcpy(args, &regs->uregs[0] + 1, 5 * sizeof(args[0]));
-		unsigned long *args_bad = args + SYSCALL_MAX_ARGS - i;
-		unsigned int n_bad = n + i - SYSCALL_MAX_ARGS;
-		pr_warning("%s called with max args %d, handling only %d\n",
-			   __func__, i + n, SYSCALL_MAX_ARGS);
-		memset(args_bad, 0, n_bad * sizeof(args[0]));
-		memset(args_bad, 0, n_bad * sizeof(args[0]));
-	}
-	if (i == 0) {
-		args[0] = regs->orig_r0;
-		args++;
-		i++;
-		n--;
-	}
-	memcpy(args, &regs->uregs[0] + i, n * sizeof(args[0]));
 }
 /**
  * syscall_set_arguments - change system call parameter value
  * @task:	task of interest, must be in system call entry tracing
  * @regs:	task_pt_regs() of @task
- * @i:		argument index [0,5]
- * @n:		number of arguments; n+i must be [1,6].
  * @args:	array of argument values to store
  *
- * Changes @n arguments to the system call starting with the @i'th argument.
+ * Changes 6 arguments to the system call. The first argument gets value
- * Argument @i gets value @args[0], and so on.
+ * @args[0], and so on.
- * An arch inline version is probably optimal when @i and @n are constants.
  *
  * It's only valid to call this when @task is stopped for tracing on
  * entry to a system call, due to %TIF_SYSCALL_TRACE or %TIF_SYSCALL_AUDIT.
- * It's invalid to call this with @i + @n > 6; we only support system calls
- * taking up to 6 arguments.
  */
 void syscall_set_arguments(struct task_struct *task, struct pt_regs *regs,
-			   unsigned int i, unsigned int n,
 			   const unsigned long *args)
 {
-	if (n == 0)
+	regs->orig_r0 = args[0];
-		return;
+	args++;
-	if (i + n > SYSCALL_MAX_ARGS) {
-		pr_warn("%s called with max args %d, handling only %d\n",
-			__func__, i + n, SYSCALL_MAX_ARGS);
-		n = SYSCALL_MAX_ARGS - i;
-	}
-	if (i == 0) {
-		regs->orig_r0 = args[0];
-		args++;
-		i++;
-		n--;
-	}
-	memcpy(&regs->uregs[0] + i, args, n * sizeof(args[0]));
+	memcpy(&regs->uregs[0] + 1, args, 5 * sizeof(args[0]));
 }
 #endif /* _ASM_NDS32_SYSCALL_H */

arch/nios2/include/asm/syscall.h+14−70

@@ -58,81 +58,25 @@ static inline void syscall_set_return_value(struct task_struct *task, · 57 unmodified lines
58	}	58	}
59		59
60	static inline void syscall_get_arguments(struct task_struct *task,	60	static inline void syscall_get_arguments(struct task_struct *task,
61	struct pt_regs *regs, unsigned int i, unsigned int n,	61	struct pt_regs regs, unsigned long args)
62	unsigned long *args)
63	{	62	{
64	BUG_ON(i + n > 6);	63	*args++ = regs->r4;
65		64	*args++ = regs->r5;
66	switch (i) {	65	*args++ = regs->r6;
67	case 0:	66	*args++ = regs->r7;
68	if (!n--)	67	*args++ = regs->r8;
69	break;	68	*args = regs->r9;
70	*args++ = regs->r4;
71	case 1:
72	if (!n--)
73	break;
74	*args++ = regs->r5;
75	case 2:
76	if (!n--)
77	break;
78	*args++ = regs->r6;
79	case 3:
80	if (!n--)
81	break;
82	*args++ = regs->r7;
83	case 4:
84	if (!n--)
85	break;
86	*args++ = regs->r8;
87	case 5:
88	if (!n--)
89	break;
90	*args++ = regs->r9;
91	case 6:
92	if (!n--)
93	break;
94	default:
95	BUG();
96	}
97	}	69	}
98		70
99	static inline void syscall_set_arguments(struct task_struct *task,	71	static inline void syscall_set_arguments(struct task_struct *task,
100	struct pt_regs *regs, unsigned int i, unsigned int n,	72	struct pt_regs regs, const unsigned long args)
101	const unsigned long *args)
102	{	73	{
103	BUG_ON(i + n > 6);	74	regs->r4 = *args++;
104		75	regs->r5 = *args++;
105	switch (i) {	76	regs->r6 = *args++;
106	case 0:	77	regs->r7 = *args++;
107	if (!n--)	78	regs->r8 = *args++;
108	break;	79	regs->r9 = *args;
109	regs->r4 = *args++;
110	case 1:
111	if (!n--)
112	break;
113	regs->r5 = *args++;
114	case 2:
115	if (!n--)
116	break;
117	regs->r6 = *args++;
118	case 3:
119	if (!n--)
120	break;
121	regs->r7 = *args++;
122	case 4:
123	if (!n--)
124	break;
125	regs->r8 = *args++;
126	case 5:
127	if (!n--)
128	break;
129	regs->r9 = *args++;
130	case 6:
131	if (!n)
132	break;
133	default:
134	BUG();
135	}
136	}	80	}
137		81
138	#endif	82	#endif

arch/openrisc/include/asm/syscall.h+4−8

 static inline void
 syscall_get_arguments(struct task_struct *task, struct pt_regs *regs,
-		      unsigned int i, unsigned int n, unsigned long *args)
+		      unsigned long *args)
 {
-	BUG_ON(i + n > 6);
+	memcpy(args, &regs->gpr[3], 6 * sizeof(args[0]));
-	memcpy(args, &regs->gpr[3 + i], n * sizeof(args[0]));
 }
 static inline void
 syscall_set_arguments(struct task_struct *task, struct pt_regs *regs,
-		      unsigned int i, unsigned int n, const unsigned long *args)
+		      const unsigned long *args)
 {
-	BUG_ON(i + n > 6);
+	memcpy(&regs->gpr[3], args, 6 * sizeof(args[0]));
-	memcpy(&regs->gpr[3 + i], args, n * sizeof(args[0]));
 }
 static inline int syscall_get_arch(void)

arch/parisc/include/asm/ptrace.h+3−2

 static inline unsigned long regs_return_value(struct pt_regs *regs)
 {
-	return regs->gr[20];
+	return regs->gr[28];
 }
 static inline void instruction_pointer_set(struct pt_regs *regs,
 						unsigned long val)
 {
-        regs->iaoq[0] = val;
+	regs->iaoq[0] = val;
+	regs->iaoq[1] = val + 4;
 }
 /* Query offset/name of register from its name/offset */

arch/parisc/include/asm/syscall.h+8−22

@@ -18,29 +18,15 @@ static inline long syscall_get_nr(struct task_struct *tsk, · 17 unmodified lines
18	}	18	}
19		19
20	static inline void syscall_get_arguments(struct task_struct *tsk,	20	static inline void syscall_get_arguments(struct task_struct *tsk,
21	struct pt_regs *regs, unsigned int i,	21	struct pt_regs *regs,
22	unsigned int n, unsigned long *args)	22	unsigned long *args)
23	{	23	{
24	BUG_ON(i);	24	args[5] = regs->gr[21];
25		25	args[4] = regs->gr[22];
26	switch (n) {	26	args[3] = regs->gr[23];
27	case 6:	27	args[2] = regs->gr[24];
28	args[5] = regs->gr[21];	28	args[1] = regs->gr[25];
29	case 5:	29	args[0] = regs->gr[26];
30	args[4] = regs->gr[22];
31	case 4:
32	args[3] = regs->gr[23];
33	case 3:
34	args[2] = regs->gr[24];
35	case 2:
36	args[1] = regs->gr[25];
37	case 1:
38	args[0] = regs->gr[26];
39	case 0:
40	break;
41	default:
42	BUG();
43	}
44	}	30	}
45		31
46	static inline long syscall_get_return_value(struct task_struct *task,	32	static inline long syscall_get_return_value(struct task_struct *task,

arch/parisc/kernel/process.c+0−6

 static int __init parisc_idle_init(void)
 {
-	const char *marker;
-	/* check QEMU/SeaBIOS marker in PAGE0 */
-	marker = (char *) &PAGE0->pad0;
-	running_on_qemu = (memcmp(marker, "SeaBIOS", 8) == 0);
 	if (!running_on_qemu)
 		cpu_idle_poll_ctrl(1);

arch/parisc/kernel/setup.c+3−0

@@ -397,6 +397,9 @@ void __init start_parisc(void) · 396 unmodified lines
397	int ret, cpunum;	397	int ret, cpunum;
398	struct pdc_coproc_cfg coproc_cfg;	398	struct pdc_coproc_cfg coproc_cfg;
399		399
		400	/* check QEMU/SeaBIOS marker in PAGE0 */
		401	running_on_qemu = (memcmp(&PAGE0->pad0, "SeaBIOS", 8) == 0);
		402
400	cpunum = smp_processor_id();	403	cpunum = smp_processor_id();
401		404
402	init_cpu_topology();	405	init_cpu_topology();

arch/powerpc/include/asm/syscall.h+5−10

@@ -65,22 +65,20 @@ static inline void syscall_set_return_value(struct task_struct *task, · 64 unmodified lines
65		65
66	static inline void syscall_get_arguments(struct task_struct *task,	66	static inline void syscall_get_arguments(struct task_struct *task,
67	struct pt_regs *regs,	67	struct pt_regs *regs,
68	unsigned int i, unsigned int n,
69	unsigned long *args)	68	unsigned long *args)
70	{	69	{
71	unsigned long val, mask = -1UL;	70	unsigned long val, mask = -1UL;
72		71	unsigned int n = 6;
73	BUG_ON(i + n > 6);
74		72
75	#ifdef CONFIG_COMPAT	73	#ifdef CONFIG_COMPAT
76	if (test_tsk_thread_flag(task, TIF_32BIT))	74	if (test_tsk_thread_flag(task, TIF_32BIT))
77	mask = 0xffffffff;	75	mask = 0xffffffff;
78	#endif	76	#endif
79	while (n--) {	77	while (n--) {
80	if (n == 0 && i == 0)	78	if (n == 0)
81	val = regs->orig_gpr3;	79	val = regs->orig_gpr3;
82	else	80	else
83	val = regs->gpr[3 + i + n];	81	val = regs->gpr[3 + n];
84		82
85	args[n] = val & mask;	83	args[n] = val & mask;
86	}	84	}
@@ -88,15 +86,12 @@ static inline void syscall_get_arguments(struct task_struct *task, · 1 unmodified line
88		86
89	static inline void syscall_set_arguments(struct task_struct *task,	87	static inline void syscall_set_arguments(struct task_struct *task,
90	struct pt_regs *regs,	88	struct pt_regs *regs,
91	unsigned int i, unsigned int n,
92	const unsigned long *args)	89	const unsigned long *args)
93	{	90	{
94	BUG_ON(i + n > 6);	91	memcpy(&regs->gpr[3], args, 6 * sizeof(args[0]));
95	memcpy(&regs->gpr[3 + i], args, n * sizeof(args[0]));
96		92
97	/* Also copy the first argument into orig_gpr3 */	93	/* Also copy the first argument into orig_gpr3 */
98	if (i == 0 && n > 0)	94	regs->orig_gpr3 = args[0];
99	regs->orig_gpr3 = args[0];
100	}	95	}
101		96
102	static inline int syscall_get_arch(void)	97	static inline int syscall_get_arch(void)

arch/powerpc/kernel/kvm.c+7−0

 #include <linux/kvm_host.h>
 #include <linux/init.h>
 #include <linux/export.h>
+#include <linux/kmemleak.h>
 #include <linux/kvm_para.h>
 #include <linux/slab.h>
 #include <linux/of.h>
 static __init void kvm_free_tmp(void)
 {
+	/*
+	 * Inform kmemleak about the hole in the .bss section since the
+	 * corresponding pages will be unmapped with DEBUG_PAGEALLOC=y.
+	 */
+	kmemleak_free_part(&kvm_tmp[kvm_tmp_index],
+			   ARRAY_SIZE(kvm_tmp) - kvm_tmp_index);
 	free_reserved_area(&kvm_tmp[kvm_tmp_index],
 			   &kvm_tmp[ARRAY_SIZE(kvm_tmp)], -1, NULL);
 }

arch/riscv/include/asm/syscall.h+6−18

 static inline void syscall_get_arguments(struct task_struct *task,
 					 struct pt_regs *regs,
-					 unsigned int i, unsigned int n,
 					 unsigned long *args)
 {
-	BUG_ON(i + n > 6);
+	args[0] = regs->orig_a0;
-	if (i == 0) {
+	args++;
-		args[0] = regs->orig_a0;
+	memcpy(args, &regs->a1, 5 * sizeof(args[0]));
-		args++;
-		i++;
-		n--;
-	}
-	memcpy(args, &regs->a1 + i * sizeof(regs->a1), n * sizeof(args[0]));
 }
 static inline void syscall_set_arguments(struct task_struct *task,
 					 struct pt_regs *regs,
-					 unsigned int i, unsigned int n,
 					 const unsigned long *args)
 {
-	BUG_ON(i + n > 6);
+	regs->orig_a0 = args[0];
-        if (i == 0) {
+	args++;
-                regs->orig_a0 = args[0];
+	memcpy(&regs->a1, args, 5 * sizeof(regs->a1));
-                args++;
-                i++;
-                n--;
-        }
-	memcpy(&regs->a1 + i * sizeof(regs->a1), args, n * sizeof(regs->a0));
 }
 static inline int syscall_get_arch(void)

arch/s390/include/asm/syscall.h+10−18

@@ -56,40 +56,32 @@ static inline void syscall_set_return_value(struct task_struct *task, · 55 unmodified lines
56		56
57	static inline void syscall_get_arguments(struct task_struct *task,	57	static inline void syscall_get_arguments(struct task_struct *task,
58	struct pt_regs *regs,	58	struct pt_regs *regs,
59	unsigned int i, unsigned int n,
60	unsigned long *args)	59	unsigned long *args)
61	{	60	{
62	unsigned long mask = -1UL;	61	unsigned long mask = -1UL;
		62	unsigned int n = 6;
63		63
64	/*
65	* No arguments for this syscall, there's nothing to do.
66	*/
67	if (!n)
68	return;
69
70	BUG_ON(i + n > 6);
71	#ifdef CONFIG_COMPAT	64	#ifdef CONFIG_COMPAT
72	if (test_tsk_thread_flag(task, TIF_31BIT))	65	if (test_tsk_thread_flag(task, TIF_31BIT))
73	mask = 0xffffffff;	66	mask = 0xffffffff;
74	#endif	67	#endif
75	while (n-- > 0)	68	while (n-- > 0)
76	if (i + n > 0)	69	if (n > 0)
77	args[n] = regs->gprs[2 + i + n] & mask;	70	args[n] = regs->gprs[2 + n] & mask;
78	if (i == 0)	71
79	args[0] = regs->orig_gpr2 & mask;	72	args[0] = regs->orig_gpr2 & mask;
80	}	73	}
81		74
82	static inline void syscall_set_arguments(struct task_struct *task,	75	static inline void syscall_set_arguments(struct task_struct *task,
83	struct pt_regs *regs,	76	struct pt_regs *regs,
84	unsigned int i, unsigned int n,
85	const unsigned long *args)	77	const unsigned long *args)
86	{	78	{
87	BUG_ON(i + n > 6);	79	unsigned int n = 6;
		80
88	while (n-- > 0)	81	while (n-- > 0)
89	if (i + n > 0)	82	if (n > 0)
90	regs->gprs[2 + i + n] = args[n];	83	regs->gprs[2 + n] = args[n];
91	if (i == 0)	84	regs->orig_gpr2 = args[0];
92	regs->orig_gpr2 = args[0];
93	}	85	}
94		86
95	static inline int syscall_get_arch(void)	87	static inline int syscall_get_arch(void)

arch/sh/boards/of-generic.c+2−2

@@ -164,10 +164,10 @@ static struct sh_machine_vector __initmv sh_of_generic_mv = { · 163 unmodified lines
164		164
165	struct sh_clk_ops;	165	struct sh_clk_ops;
166		166
167	void __init arch_init_clk_ops(struct sh_clk_ops **ops, int idx)	167	void __init __weak arch_init_clk_ops(struct sh_clk_ops **ops, int idx)
168	{	168	{
169	}	169	}
170		170
171	void __init plat_irq_setup(void)	171	void __init __weak plat_irq_setup(void)
172	{	172	{
173	}	173	}

arch/sh/include/asm/syscall_32.h+12−35

@@ -48,51 +48,28 @@ static inline void syscall_set_return_value(struct task_struct *task, · 47 unmodified lines
48		48
49	static inline void syscall_get_arguments(struct task_struct *task,	49	static inline void syscall_get_arguments(struct task_struct *task,
50	struct pt_regs *regs,	50	struct pt_regs *regs,
51	unsigned int i, unsigned int n,
52	unsigned long *args)	51	unsigned long *args)
53	{	52	{
54	/*
55	* Do this simply for now. If we need to start supporting
56	* fetching arguments from arbitrary indices, this will need some
57	* extra logic. Presently there are no in-tree users that depend
58	* on this behaviour.
59	*/
60	BUG_ON(i);
61		53
62	/* Argument pattern is: R4, R5, R6, R7, R0, R1 */	54	/* Argument pattern is: R4, R5, R6, R7, R0, R1 */
63	switch (n) {	55	args[5] = regs->regs[1];
64	case 6: args[5] = regs->regs[1];	56	args[4] = regs->regs[0];
65	case 5: args[4] = regs->regs[0];	57	args[3] = regs->regs[7];
66	case 4: args[3] = regs->regs[7];	58	args[2] = regs->regs[6];
67	case 3: args[2] = regs->regs[6];	59	args[1] = regs->regs[5];
68	case 2: args[1] = regs->regs[5];	60	args[0] = regs->regs[4];
69	case 1: args[0] = regs->regs[4];
70	case 0:
71	break;
72	default:
73	BUG();
74	}
75	}	61	}
76		62
77	static inline void syscall_set_arguments(struct task_struct *task,	63	static inline void syscall_set_arguments(struct task_struct *task,
78	struct pt_regs *regs,	64	struct pt_regs *regs,
79	unsigned int i, unsigned int n,
80	const unsigned long *args)	65	const unsigned long *args)
81	{	66	{
82	/* Same note as above applies */	67	regs->regs[1] = args[5];
83	BUG_ON(i);	68	regs->regs[0] = args[4];
84		69	regs->regs[7] = args[3];
85	switch (n) {	70	regs->regs[6] = args[2];
86	case 6: regs->regs[1] = args[5];	71	regs->regs[5] = args[1];
87	case 5: regs->regs[0] = args[4];	72	regs->regs[4] = args[0];
88	case 4: regs->regs[7] = args[3];
89	case 3: regs->regs[6] = args[2];
90	case 2: regs->regs[5] = args[1];
91	case 1: regs->regs[4] = args[0];
92	break;
93	default:
94	BUG();
95	}
96	}	73	}
97		74
98	static inline int syscall_get_arch(void)	75	static inline int syscall_get_arch(void)

arch/sh/include/asm/syscall_64.h+2−6

 static inline void syscall_get_arguments(struct task_struct *task,
 					 struct pt_regs *regs,
-					 unsigned int i, unsigned int n,
 					 unsigned long *args)
 {
-	BUG_ON(i + n > 6);
+	memcpy(args, &regs->regs[2], 6 * sizeof(args[0]));
-	memcpy(args, &regs->regs[2 + i], n * sizeof(args[0]));
 }
 static inline void syscall_set_arguments(struct task_struct *task,
 					 struct pt_regs *regs,
-					 unsigned int i, unsigned int n,
 					 const unsigned long *args)
 {
-	BUG_ON(i + n > 6);
+	memcpy(&regs->regs[2], args, 6 * sizeof(args[0]));
-	memcpy(&regs->regs[2 + i], args, n * sizeof(args[0]));
 }
 static inline int syscall_get_arch(void)

arch/sparc/include/asm/syscall.h+5−6

 static inline void syscall_get_arguments(struct task_struct *task,
 					 struct pt_regs *regs,
-					 unsigned int i, unsigned int n,
 					 unsigned long *args)
 {
 	int zero_extend = 0;
 	unsigned int j;
+	unsigned int n = 6;
 #ifdef CONFIG_SPARC64
 	if (test_tsk_thread_flag(task, TIF_32BIT))
 #endif
 	for (j = 0; j < n; j++) {
-		unsigned long val = regs->u_regs[UREG_I0 + i + j];
+		unsigned long val = regs->u_regs[UREG_I0 + j];
 		if (zero_extend)
 			args[j] = (u32) val;
 static inline void syscall_set_arguments(struct task_struct *task,
 					 struct pt_regs *regs,
-					 unsigned int i, unsigned int n,
 					 const unsigned long *args)
 {
-	unsigned int j;
+	unsigned int i;
-	for (j = 0; j < n; j++)
+	for (i = 0; i < 6; i++)
-		regs->u_regs[UREG_I0 + i + j] = args[j];
+		regs->u_regs[UREG_I0 + i] = args[i];
 }
 static inline int syscall_get_arch(void)

arch/um/include/asm/syscall-generic.h+12−66

@@ -53,84 +53,30 @@ static inline void syscall_set_return_value(struct task_struct *task, · 52 unmodified lines
53		53
54	static inline void syscall_get_arguments(struct task_struct *task,	54	static inline void syscall_get_arguments(struct task_struct *task,
55	struct pt_regs *regs,	55	struct pt_regs *regs,
56	unsigned int i, unsigned int n,
57	unsigned long *args)	56	unsigned long *args)
58	{	57	{
59	const struct uml_pt_regs *r = &regs->regs;	58	const struct uml_pt_regs *r = &regs->regs;
60		59
61	switch (i) {	60	*args++ = UPT_SYSCALL_ARG1(r);
62	case 0:	61	*args++ = UPT_SYSCALL_ARG2(r);
63	if (!n--)	62	*args++ = UPT_SYSCALL_ARG3(r);
64	break;	63	*args++ = UPT_SYSCALL_ARG4(r);
65	*args++ = UPT_SYSCALL_ARG1(r);	64	*args++ = UPT_SYSCALL_ARG5(r);
66	case 1:	65	*args = UPT_SYSCALL_ARG6(r);
67	if (!n--)
68	break;
69	*args++ = UPT_SYSCALL_ARG2(r);
70	case 2:
71	if (!n--)
72	break;
73	*args++ = UPT_SYSCALL_ARG3(r);
74	case 3:
75	if (!n--)
76	break;
77	*args++ = UPT_SYSCALL_ARG4(r);
78	case 4:
79	if (!n--)
80	break;
81	*args++ = UPT_SYSCALL_ARG5(r);
82	case 5:
83	if (!n--)
84	break;
85	*args++ = UPT_SYSCALL_ARG6(r);
86	case 6:
87	if (!n--)
88	break;
89	default:
90	BUG();
91	break;
92	}
93	}	66	}
94		67
95	static inline void syscall_set_arguments(struct task_struct *task,	68	static inline void syscall_set_arguments(struct task_struct *task,
96	struct pt_regs *regs,	69	struct pt_regs *regs,
97	unsigned int i, unsigned int n,
98	const unsigned long *args)	70	const unsigned long *args)
99	{	71	{
100	struct uml_pt_regs *r = &regs->regs;	72	struct uml_pt_regs *r = &regs->regs;
101		73
102	switch (i) {	74	UPT_SYSCALL_ARG1(r) = *args++;
103	case 0:	75	UPT_SYSCALL_ARG2(r) = *args++;
104	if (!n--)	76	UPT_SYSCALL_ARG3(r) = *args++;
105	break;	77	UPT_SYSCALL_ARG4(r) = *args++;
106	UPT_SYSCALL_ARG1(r) = *args++;	78	UPT_SYSCALL_ARG5(r) = *args++;
107	case 1:	79	UPT_SYSCALL_ARG6(r) = *args;
108	if (!n--)
109	break;
110	UPT_SYSCALL_ARG2(r) = *args++;
111	case 2:
112	if (!n--)
113	break;
114	UPT_SYSCALL_ARG3(r) = *args++;
115	case 3:
116	if (!n--)
117	break;
118	UPT_SYSCALL_ARG4(r) = *args++;
119	case 4:
120	if (!n--)
121	break;
122	UPT_SYSCALL_ARG5(r) = *args++;
123	case 5:
124	if (!n--)
125	break;
126	UPT_SYSCALL_ARG6(r) = *args++;
127	case 6:
128	if (!n--)
129	break;
130	default:
131	BUG();
132	break;
133	}
134	}	80	}
135		81
136	/* See arch/x86/um/asm/syscall.h for syscall_get_arch() definition. */	82	/* See arch/x86/um/asm/syscall.h for syscall_get_arch() definition. */

arch/x86/include/asm/syscall.h+33−109

@@ -91,11 +91,9 @@ static inline void syscall_set_return_value(struct task_struct *task, · 90 unmodified lines
91		91
92	static inline void syscall_get_arguments(struct task_struct *task,	92	static inline void syscall_get_arguments(struct task_struct *task,
93	struct pt_regs *regs,	93	struct pt_regs *regs,
94	unsigned int i, unsigned int n,
95	unsigned long *args)	94	unsigned long *args)
96	{	95	{
97	BUG_ON(i + n > 6);	96	memcpy(args, &regs->bx, 6 * sizeof(args[0]));
98	memcpy(args, &regs->bx + i, n * sizeof(args[0]));
99	}	97	}
100		98
101	static inline void syscall_set_arguments(struct task_struct *task,	99	static inline void syscall_set_arguments(struct task_struct *task,
@@ -116,124 +114,50 @@ static inline int syscall_get_arch(void) · 14 unmodified lines
116		114
117	static inline void syscall_get_arguments(struct task_struct *task,	115	static inline void syscall_get_arguments(struct task_struct *task,
118	struct pt_regs *regs,	116	struct pt_regs *regs,
119	unsigned int i, unsigned int n,
120	unsigned long *args)	117	unsigned long *args)
121	{	118	{
122	# ifdef CONFIG_IA32_EMULATION	119	# ifdef CONFIG_IA32_EMULATION
123	if (task->thread_info.status & TS_COMPAT)	120	if (task->thread_info.status & TS_COMPAT) {
124	switch (i) {	121	*args++ = regs->bx;
125	case 0:	122	*args++ = regs->cx;
126	if (!n--) break;	123	*args++ = regs->dx;
127	*args++ = regs->bx;	124	*args++ = regs->si;
128	case 1:	125	*args++ = regs->di;
129	if (!n--) break;	126	*args = regs->bp;
130	*args++ = regs->cx;	127	} else
131	case 2:
132	if (!n--) break;
133	*args++ = regs->dx;
134	case 3:
135	if (!n--) break;
136	*args++ = regs->si;
137	case 4:
138	if (!n--) break;
139	*args++ = regs->di;
140	case 5:
141	if (!n--) break;
142	*args++ = regs->bp;
143	case 6:
144	if (!n--) break;
145	default:
146	BUG();
147	break;
148	}
149	else
150	# endif	128	# endif
151	switch (i) {	129	{
152	case 0:	130	*args++ = regs->di;
153	if (!n--) break;	131	*args++ = regs->si;
154	*args++ = regs->di;	132	*args++ = regs->dx;
155	case 1:	133	*args++ = regs->r10;
156	if (!n--) break;	134	*args++ = regs->r8;
157	*args++ = regs->si;	135	*args = regs->r9;
158	case 2:	136	}
159	if (!n--) break;
160	*args++ = regs->dx;
161	case 3:
162	if (!n--) break;
163	*args++ = regs->r10;
164	case 4:
165	if (!n--) break;
166	*args++ = regs->r8;
167	case 5:
168	if (!n--) break;
169	*args++ = regs->r9;
170	case 6:
171	if (!n--) break;
172	default:
173	BUG();
174	break;
175	}
176	}	137	}
177		138
178	static inline void syscall_set_arguments(struct task_struct *task,	139	static inline void syscall_set_arguments(struct task_struct *task,
179	struct pt_regs *regs,	140	struct pt_regs *regs,
180	unsigned int i, unsigned int n,
181	const unsigned long *args)	141	const unsigned long *args)
182	{	142	{
183	# ifdef CONFIG_IA32_EMULATION	143	# ifdef CONFIG_IA32_EMULATION
184	if (task->thread_info.status & TS_COMPAT)	144	if (task->thread_info.status & TS_COMPAT) {
185	switch (i) {	145	regs->bx = *args++;
186	case 0:	146	regs->cx = *args++;
187	if (!n--) break;	147	regs->dx = *args++;
188	regs->bx = *args++;	148	regs->si = *args++;
189	case 1:	149	regs->di = *args++;
190	if (!n--) break;	150	regs->bp = *args;
191	regs->cx = *args++;	151	} else
192	case 2:
193	if (!n--) break;
194	regs->dx = *args++;
195	case 3:
196	if (!n--) break;
197	regs->si = *args++;
198	case 4:
199	if (!n--) break;
200	regs->di = *args++;
201	case 5:
202	if (!n--) break;
203	regs->bp = *args++;
204	case 6:
205	if (!n--) break;
206	default:
207	BUG();
208	break;
209	}
210	else
211	# endif	152	# endif
212	switch (i) {	153	{
213	case 0:	154	regs->di = *args++;
214	if (!n--) break;	155	regs->si = *args++;
215	regs->di = *args++;	156	regs->dx = *args++;
216	case 1:	157	regs->r10 = *args++;
217	if (!n--) break;	158	regs->r8 = *args++;
218	regs->si = *args++;	159	regs->r9 = *args;
219	case 2:	160	}
220	if (!n--) break;
221	regs->dx = *args++;
222	case 3:
223	if (!n--) break;
224	regs->r10 = *args++;
225	case 4:
226	if (!n--) break;
227	regs->r8 = *args++;
228	case 5:
229	if (!n--) break;
230	regs->r9 = *args++;
231	case 6:
232	if (!n--) break;
233	default:
234	BUG();
235	break;
236	}
237	}	161	}
238		162
239	static inline int syscall_get_arch(void)	163	static inline int syscall_get_arch(void)

arch/x86/include/asm/xen/hypercall.h+3−0

@@ -206,6 +206,9 @@ xen_single_call(unsigned int call, · 205 unmodified lines
206	__HYPERCALL_DECLS;	206	__HYPERCALL_DECLS;
207	__HYPERCALL_5ARG(a1, a2, a3, a4, a5);	207	__HYPERCALL_5ARG(a1, a2, a3, a4, a5);
208		208
		209	if (call >= PAGE_SIZE / sizeof(hypercall_page[0]))
		210	return -EINVAL;
		211
209	asm volatile(CALL_NOSPEC	212	asm volatile(CALL_NOSPEC
210	: __HYPERCALL_5PARAM	213	: __HYPERCALL_5PARAM
211	: [thunk_target] "a" (&hypercall_page[call])	214	: [thunk_target] "a" (&hypercall_page[call])

arch/x86/kvm/svm.c+14−8

 	return ret;
 }
-static int get_num_contig_pages(int idx, struct page **inpages,
+static unsigned long get_num_contig_pages(unsigned long idx,
-				unsigned long npages)
+				struct page **inpages, unsigned long npages)
 {
 	unsigned long paddr, next_paddr;
-	int i = idx + 1, pages = 1;
+	unsigned long i = idx + 1, pages = 1;
 	/* find the number of contiguous pages starting from idx */
 	paddr = __sme_page_pa(inpages[idx]);
 static int sev_launch_update_data(struct kvm *kvm, struct kvm_sev_cmd *argp)
 {
-	unsigned long vaddr, vaddr_end, next_vaddr, npages, size;
+	unsigned long vaddr, vaddr_end, next_vaddr, npages, pages, size, i;
 	struct kvm_sev_info *sev = &to_kvm_svm(kvm)->sev_info;
 	struct kvm_sev_launch_update_data params;
 	struct sev_data_launch_update_data *data;
 	struct page **inpages;
-	int i, ret, pages;
+	int ret;
 	if (!sev_guest(kvm))
 		return -ENOTTY;
 	struct page **src_p, **dst_p;
 	struct kvm_sev_dbg debug;
 	unsigned long n;
-	int ret, size;
+	unsigned int size;
+	int ret;
 	if (!sev_guest(kvm))
 		return -ENOTTY;
 	if (copy_from_user(&debug, (void __user *)(uintptr_t)argp->data, sizeof(debug)))
 		return -EFAULT;
+	if (!debug.len || debug.src_uaddr + debug.len < debug.src_uaddr)
+		return -EINVAL;
+	if (!debug.dst_uaddr)
+		return -EINVAL;
 	vaddr = debug.src_uaddr;
 	size = debug.len;
 	vaddr_end = vaddr + size;
 						     dst_vaddr,
 						     len, &argp->error);
-		sev_unpin_memory(kvm, src_p, 1);
+		sev_unpin_memory(kvm, src_p, n);
-		sev_unpin_memory(kvm, dst_p, 1);
+		sev_unpin_memory(kvm, dst_p, n);
 		if (ret)
 			goto err;

arch/x86/kvm/vmx/nested.c+45−29

 	}
 }
+static inline void enable_x2apic_msr_intercepts(unsigned long *msr_bitmap) {
+	int msr;
+	for (msr = 0x800; msr <= 0x8ff; msr += BITS_PER_LONG) {
+		unsigned word = msr / BITS_PER_LONG;
+		msr_bitmap[word] = ~0;
+		msr_bitmap[word + (0x800 / sizeof(long))] = ~0;
+	}
+}
 /*
  * Merge L0's and L1's MSR bitmap, return false to indicate that
  * we do not use the hardware.
 		return false;
 	msr_bitmap_l1 = (unsigned long *)kmap(page);
-	if (nested_cpu_has_apic_reg_virt(vmcs12)) {
-		/*
-		 * L0 need not intercept reads for MSRs between 0x800 and 0x8ff, it
-		 * just lets the processor take the value from the virtual-APIC page;
-		 * take those 256 bits directly from the L1 bitmap.
-		 */
-		for (msr = 0x800; msr <= 0x8ff; msr += BITS_PER_LONG) {
-			unsigned word = msr / BITS_PER_LONG;
-			msr_bitmap_l0[word] = msr_bitmap_l1[word];
-			msr_bitmap_l0[word + (0x800 / sizeof(long))] = ~0;
-		}
-	} else {
-		for (msr = 0x800; msr <= 0x8ff; msr += BITS_PER_LONG) {
-			unsigned word = msr / BITS_PER_LONG;
-			msr_bitmap_l0[word] = ~0;
-			msr_bitmap_l0[word + (0x800 / sizeof(long))] = ~0;
-		}
-	}
-	nested_vmx_disable_intercept_for_msr(
+	/*
-		msr_bitmap_l1, msr_bitmap_l0,
+	 * To keep the control flow simple, pay eight 8-byte writes (sixteen
-		X2APIC_MSR(APIC_TASKPRI),
+	 * 4-byte writes on 32-bit systems) up front to enable intercepts for
-		MSR_TYPE_W);
+	 * the x2APIC MSR range and selectively disable them below.
+	 */
+	enable_x2apic_msr_intercepts(msr_bitmap_l0);
+	if (nested_cpu_has_virt_x2apic_mode(vmcs12)) {
+		if (nested_cpu_has_apic_reg_virt(vmcs12)) {
+			/*
+			 * L0 need not intercept reads for MSRs between 0x800
+			 * and 0x8ff, it just lets the processor take the value
+			 * from the virtual-APIC page; take those 256 bits
+			 * directly from the L1 bitmap.
+			 */
+			for (msr = 0x800; msr <= 0x8ff; msr += BITS_PER_LONG) {
+				unsigned word = msr / BITS_PER_LONG;
+				msr_bitmap_l0[word] = msr_bitmap_l1[word];
+			}
+		}
-	if (nested_cpu_has_vid(vmcs12)) {
-		nested_vmx_disable_intercept_for_msr(
-			msr_bitmap_l1, msr_bitmap_l0,
-			X2APIC_MSR(APIC_EOI),
-			MSR_TYPE_W);
 		nested_vmx_disable_intercept_for_msr(
 			msr_bitmap_l1, msr_bitmap_l0,
-			X2APIC_MSR(APIC_SELF_IPI),
+			X2APIC_MSR(APIC_TASKPRI),
-			MSR_TYPE_W);
+			MSR_TYPE_R | MSR_TYPE_W);
+		if (nested_cpu_has_vid(vmcs12)) {
+			nested_vmx_disable_intercept_for_msr(
+				msr_bitmap_l1, msr_bitmap_l0,
+				X2APIC_MSR(APIC_EOI),
+				MSR_TYPE_W);
+			nested_vmx_disable_intercept_for_msr(
+				msr_bitmap_l1, msr_bitmap_l0,
+				X2APIC_MSR(APIC_SELF_IPI),
+				MSR_TYPE_W);
+		}
 	}
 	if (spec_ctrl)

arch/xtensa/include/asm/processor.h+12−9

@@ -187,15 +187,18 @@ struct thread_struct { · 186 unmodified lines
187		187
188	/* Clearing a0 terminates the backtrace. */	188	/* Clearing a0 terminates the backtrace. */
189	#define start_thread(regs, new_pc, new_sp) \	189	#define start_thread(regs, new_pc, new_sp) \
190	memset(regs, 0, sizeof(*regs)); \	190	do { \
191	regs->pc = new_pc; \	191	memset((regs), 0, sizeof(*(regs))); \
192	regs->ps = USER_PS_VALUE; \	192	(regs)->pc = (new_pc); \
193	regs->areg[1] = new_sp; \	193	(regs)->ps = USER_PS_VALUE; \
194	regs->areg[0] = 0; \	194	(regs)->areg[1] = (new_sp); \
195	regs->wmask = 1; \	195	(regs)->areg[0] = 0; \
196	regs->depc = 0; \	196	(regs)->wmask = 1; \
197	regs->windowbase = 0; \	197	(regs)->depc = 0; \
198	regs->windowstart = 1;	198	(regs)->windowbase = 0; \
		199	(regs)->windowstart = 1; \
		200	(regs)->syscall = NO_SYSCALL; \
		201	} while (0)
199		202
200	/* Forward declaration */	203	/* Forward declaration */
201	struct task_struct;	204	struct task_struct;

arch/xtensa/include/asm/syscall.h+6−27

 static inline void syscall_get_arguments(struct task_struct *task,
 					 struct pt_regs *regs,
-					 unsigned int i, unsigned int n,
 					 unsigned long *args)
 {
 	static const unsigned int reg[] = XTENSA_SYSCALL_ARGUMENT_REGS;
-	unsigned int j;
+	unsigned int i;
-	if (n == 0)
+	for (i = 0; i < 6; ++i)
-		return;
+		args[i] = regs->areg[reg[i]];
-	WARN_ON_ONCE(i + n > SYSCALL_MAX_ARGS);
-	for (j = 0; j < n; ++j) {
-		if (i + j < SYSCALL_MAX_ARGS)
-			args[j] = regs->areg[reg[i + j]];
-		else
-			args[j] = 0;
-	}
 }
 static inline void syscall_set_arguments(struct task_struct *task,
 					 struct pt_regs *regs,
-					 unsigned int i, unsigned int n,
 					 const unsigned long *args)
 {
 	static const unsigned int reg[] = XTENSA_SYSCALL_ARGUMENT_REGS;
-	unsigned int j;
+	unsigned int i;
-	if (n == 0)
-		return;
-	if (WARN_ON_ONCE(i + n > SYSCALL_MAX_ARGS)) {
-		if (i < SYSCALL_MAX_ARGS)
-			n = SYSCALL_MAX_ARGS - i;
-		else
-			return;
-	}
-	for (j = 0; j < n; ++j)
+	for (i = 0; i < 6; ++i)
-		regs->areg[reg[i + j]] = args[j];
+		regs->areg[reg[i]] = args[i];
 }
 asmlinkage long xtensa_rt_sigreturn(struct pt_regs*);

arch/xtensa/kernel/entry.S+6−0

 	l32i	a7, a2, PT_SYSCALL
 1:
+	s32i	a7, a1, 4
 	/* syscall = sys_call_table[syscall_nr] */
 	movi	a4, sys_call_table
 	retw
 1:
+	l32i	a4, a1, 4
+	l32i	a3, a2, PT_SYSCALL
+	s32i	a4, a2, PT_SYSCALL
 	mov	a6, a2
 	call4	do_syscall_trace_leave
+	s32i	a3, a2, PT_SYSCALL
 	retw
 ENDPROC(system_call)

arch/xtensa/kernel/stacktrace.c+5−1

 	return 1;
 }
+/*
+ * level == 0 is for the return address from the caller of this function,
+ * not from this function itself.
+ */
 unsigned long return_address(unsigned level)
 {
 	struct return_addr_data r = {
-		.skip = level + 1,
+		.skip = level,
 	};
 	walk_stackframe(stack_pointer(NULL), return_address_cb, &r);
 	return r.addr;

arch/xtensa/mm/mmu.c+1−1

@@ -33,7 +33,7 @@ static void * __init init_pmd(unsigned long vaddr, unsigned long n_pages) · 32 unmodified lines
33		33
34	pte = memblock_alloc_low(n_pages * sizeof(pte_t), PAGE_SIZE);	34	pte = memblock_alloc_low(n_pages * sizeof(pte_t), PAGE_SIZE);
35	if (!pte)	35	if (!pte)
36	panic("%s: Failed to allocate %zu bytes align=%lx\n",	36	panic("%s: Failed to allocate %lu bytes align=%lx\n",
37	__func__, n_pages * sizeof(pte_t), PAGE_SIZE);	37	__func__, n_pages * sizeof(pte_t), PAGE_SIZE);
38		38
39	for (i = 0; i < n_pages; ++i)	39	for (i = 0; i < n_pages; ++i)

block/bfq-iosched.c+1−1

@@ -674,7 +674,7 @@ static bool bfq_symmetric_scenario(struct bfq_data *bfqd) · 673 unmodified lines
674	* at least two nodes.	674	* at least two nodes.
675	*/	675	*/
676	return !(varied_queue_weights \|\| multiple_classes_busy	676	return !(varied_queue_weights \|\| multiple_classes_busy
677	#ifdef BFQ_GROUP_IOSCHED_ENABLED	677	#ifdef CONFIG_BFQ_GROUP_IOSCHED
678	\|\| bfqd->num_groups_with_pending_reqs > 0	678	\|\| bfqd->num_groups_with_pending_reqs > 0
679	#endif	679	#endif
680	);	680	);

block/bfq-wf2q.c+1−1

@@ -1012,7 +1012,7 @@ static void __bfq_activate_entity(struct bfq_entity *entity, · 1011 unmodified lines
1012	entity->on_st = true;	1012	entity->on_st = true;
1013	}	1013	}
1014		1014
1015	#ifdef BFQ_GROUP_IOSCHED_ENABLED	1015	#ifdef CONFIG_BFQ_GROUP_IOSCHED
1016	if (!bfq_entity_to_bfqq(entity)) { /* bfq_group */	1016	if (!bfq_entity_to_bfqq(entity)) { /* bfq_group */
1017	struct bfq_group *bfqg =	1017	struct bfq_group *bfqg =
1018	container_of(entity, struct bfq_group, entity);	1018	container_of(entity, struct bfq_group, entity);

block/blk-core.c+1−3

  */
 blk_status_t blk_insert_cloned_request(struct request_queue *q, struct request *rq)
 {
-	blk_qc_t unused;
 	if (blk_cloned_rq_check_limits(q, rq))
 		return BLK_STS_IOERR;
 	 * bypass a potential scheduler on the bottom device for
 	 * insert.
 	 */
-	return blk_mq_try_issue_directly(rq->mq_hctx, rq, &unused, true, true);
+	return blk_mq_request_issue_directly(rq, true);
 }
 EXPORT_SYMBOL_GPL(blk_insert_cloned_request);

block/blk-mq-sched.c+5−3

 		 * busy in case of 'none' scheduler, and this way may save
 		 * us one extra enqueue & dequeue to sw queue.
 		 */
-		if (!hctx->dispatch_busy && !e && !run_queue_async)
+		if (!hctx->dispatch_busy && !e && !run_queue_async) {
 			blk_mq_try_issue_list_directly(hctx, list);
-		else
+			if (list_empty(list))
-			blk_mq_insert_requests(hctx, ctx, list);
+				return;
+		}
+		blk_mq_insert_requests(hctx, ctx, list);
 	}
 	blk_mq_run_hw_queue(hctx, run_queue_async);

block/blk-mq.c+68−61

@@ -1711,11 +1711,12 @@ void blk_mq_flush_plug_list(struct blk_plug *plug, bool from_schedule) · 1710 unmodified lines
1711	unsigned int depth;	1711	unsigned int depth;
1712		1712
1713	list_splice_init(&plug->mq_list, &list);	1713	list_splice_init(&plug->mq_list, &list);
1714	plug->rq_count = 0;
1715		1714
1716	if (plug->rq_count > 2 && plug->multiple_queues)	1715	if (plug->rq_count > 2 && plug->multiple_queues)
1717	list_sort(NULL, &list, plug_rq_cmp);	1716	list_sort(NULL, &list, plug_rq_cmp);
1718		1717
		1718	plug->rq_count = 0;
		1719
1719	this_q = NULL;	1720	this_q = NULL;
1720	this_hctx = NULL;	1721	this_hctx = NULL;
1721	this_ctx = NULL;	1722	this_ctx = NULL;
@@ -1800,74 +1801,76 @@ static blk_status_t __blk_mq_issue_directly(struct blk_mq_hw_ctx *hctx, · 78 unmodified lines
1800	return ret;	1801	return ret;
1801	}	1802	}
1802		1803
1803	blk_status_t blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx,	1804	static blk_status_t __blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx,
1804	struct request *rq,	1805	struct request *rq,
1805	blk_qc_t *cookie,	1806	blk_qc_t *cookie,
1806	bool bypass, bool last)	1807	bool bypass_insert, bool last)
1807	{	1808	{
1808	struct request_queue *q = rq->q;	1809	struct request_queue *q = rq->q;
1809	bool run_queue = true;	1810	bool run_queue = true;
1810	blk_status_t ret = BLK_STS_RESOURCE;
1811	int srcu_idx;
1812	bool force = false;
1813		1811
1814	hctx_lock(hctx, &srcu_idx);
1815	/*	1812	/*
1816	* hctx_lock is needed before checking quiesced flag.	1813	* RCU or SRCU read lock is needed before checking quiesced flag.
1817	*	1814	*
1818	* When queue is stopped or quiesced, ignore 'bypass', insert	1815	* When queue is stopped or quiesced, ignore 'bypass_insert' from
1819	* and return BLK_STS_OK to caller, and avoid driver to try to	1816	* blk_mq_request_issue_directly(), and return BLK_STS_OK to caller,
1820	* dispatch again.	1817	* and avoid driver to try to dispatch again.
1821	*/	1818	*/
1822	if (unlikely(blk_mq_hctx_stopped(hctx) \|\| blk_queue_quiesced(q))) {	1819	if (blk_mq_hctx_stopped(hctx) \|\| blk_queue_quiesced(q)) {
1823	run_queue = false;	1820	run_queue = false;
1824	bypass = false;	1821	bypass_insert = false;
1825	goto out_unlock;	1822	goto insert;
1826	}	1823	}
1827		1824
1828	if (unlikely(q->elevator && !bypass))	1825	if (q->elevator && !bypass_insert)
1829	goto out_unlock;	1826	goto insert;
1830		1827
1831	if (!blk_mq_get_dispatch_budget(hctx))	1828	if (!blk_mq_get_dispatch_budget(hctx))
1832	goto out_unlock;	1829	goto insert;
1833		1830
1834	if (!blk_mq_get_driver_tag(rq)) {	1831	if (!blk_mq_get_driver_tag(rq)) {
1835	blk_mq_put_dispatch_budget(hctx);	1832	blk_mq_put_dispatch_budget(hctx);
1836	goto out_unlock;	1833	goto insert;
1837	}	1834	}
1838		1835
1839	/*	1836	return __blk_mq_issue_directly(hctx, rq, cookie, last);
1840	* Always add a request that has been through	1837	insert:
1841	*.queue_rq() to the hardware dispatch list.	1838	if (bypass_insert)
1842	*/	1839	return BLK_STS_RESOURCE;
1843	force = true;	1840
1844	ret = __blk_mq_issue_directly(hctx, rq, cookie, last);	1841	blk_mq_request_bypass_insert(rq, run_queue);
1845	out_unlock:	1842	return BLK_STS_OK;
		1843	}
		1844
		1845	static void blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx,
		1846	struct request rq, blk_qc_t cookie)
		1847	{
		1848	blk_status_t ret;
		1849	int srcu_idx;
		1850
		1851	might_sleep_if(hctx->flags & BLK_MQ_F_BLOCKING);
		1852
		1853	hctx_lock(hctx, &srcu_idx);
		1854
		1855	ret = __blk_mq_try_issue_directly(hctx, rq, cookie, false, true);
		1856	if (ret == BLK_STS_RESOURCE \|\| ret == BLK_STS_DEV_RESOURCE)
		1857	blk_mq_request_bypass_insert(rq, true);
		1858	else if (ret != BLK_STS_OK)
		1859	blk_mq_end_request(rq, ret);
		1860
		1861	hctx_unlock(hctx, srcu_idx);
		1862	}
		1863
		1864	blk_status_t blk_mq_request_issue_directly(struct request *rq, bool last)
		1865	{
		1866	blk_status_t ret;
		1867	int srcu_idx;
		1868	blk_qc_t unused_cookie;
		1869	struct blk_mq_hw_ctx *hctx = rq->mq_hctx;
		1870
		1871	hctx_lock(hctx, &srcu_idx);
		1872	ret = __blk_mq_try_issue_directly(hctx, rq, &unused_cookie, true, last);
1846	hctx_unlock(hctx, srcu_idx);	1873	hctx_unlock(hctx, srcu_idx);
1847	switch (ret) {
1848	case BLK_STS_OK:
1849	break;
1850	case BLK_STS_DEV_RESOURCE:
1851	case BLK_STS_RESOURCE:
1852	if (force) {
1853	blk_mq_request_bypass_insert(rq, run_queue);
1854	/*
1855	* We have to return BLK_STS_OK for the DM
1856	* to avoid livelock. Otherwise, we return
1857	* the real result to indicate whether the
1858	* request is direct-issued successfully.
1859	*/
1860	ret = bypass ? BLK_STS_OK : ret;
1861	} else if (!bypass) {
1862	blk_mq_sched_insert_request(rq, false,
1863	run_queue, false);
1864	}
1865	break;
1866	default:
1867	if (!bypass)
1868	blk_mq_end_request(rq, ret);
1869	break;
1870	}
1871		1874
1872	return ret;	1875	return ret;
1873	}	1876	}
@@ -1875,20 +1878,22 @@ out_unlock: · 1 unmodified line
1875	void blk_mq_try_issue_list_directly(struct blk_mq_hw_ctx *hctx,	1878	void blk_mq_try_issue_list_directly(struct blk_mq_hw_ctx *hctx,
1876	struct list_head *list)	1879	struct list_head *list)
1877	{	1880	{
1878	blk_qc_t unused;
1879	blk_status_t ret = BLK_STS_OK;
1880
1881	while (!list_empty(list)) {	1881	while (!list_empty(list)) {
		1882	blk_status_t ret;
1882	struct request *rq = list_first_entry(list, struct request,	1883	struct request *rq = list_first_entry(list, struct request,
1883	queuelist);	1884	queuelist);
1884		1885
1885	list_del_init(&rq->queuelist);	1886	list_del_init(&rq->queuelist);
1886	if (ret == BLK_STS_OK)	1887	ret = blk_mq_request_issue_directly(rq, list_empty(list));
1887	ret = blk_mq_try_issue_directly(hctx, rq, &unused,	1888	if (ret != BLK_STS_OK) {
1888	false,	1889	if (ret == BLK_STS_RESOURCE \|\|
		1890	ret == BLK_STS_DEV_RESOURCE) {
		1891	blk_mq_request_bypass_insert(rq,
1889	list_empty(list));	1892	list_empty(list));
1890	else	1893	break;
1891	blk_mq_sched_insert_request(rq, false, true, false);	1894	}
		1895	blk_mq_end_request(rq, ret);
		1896	}
1892	}	1897	}
1893		1898
1894	/*	1899	/*
@@ -1896,7 +1901,7 @@ void blk_mq_try_issue_list_directly(struct blk_mq_hw_ctx *hctx, · 1 unmodified line
1896	* the driver there was more coming, but that turned out to	1901	* the driver there was more coming, but that turned out to
1897	* be a lie.	1902	* be a lie.
1898	*/	1903	*/
1899	if (ret != BLK_STS_OK && hctx->queue->mq_ops->commit_rqs)	1904	if (!list_empty(list) && hctx->queue->mq_ops->commit_rqs)
1900	hctx->queue->mq_ops->commit_rqs(hctx);	1905	hctx->queue->mq_ops->commit_rqs(hctx);
1901	}	1906	}
1902		1907
@@ -2003,19 +2008,21 @@ static blk_qc_t blk_mq_make_request(struct request_queue q, struct bio bio) · 100 unmodified lines
2003	plug->rq_count--;	2008	plug->rq_count--;
2004	}	2009	}
2005	blk_add_rq_to_plug(plug, rq);	2010	blk_add_rq_to_plug(plug, rq);
		2011	trace_block_plug(q);
2006		2012
2007	blk_mq_put_ctx(data.ctx);	2013	blk_mq_put_ctx(data.ctx);
2008		2014
2009	if (same_queue_rq) {	2015	if (same_queue_rq) {
2010	data.hctx = same_queue_rq->mq_hctx;	2016	data.hctx = same_queue_rq->mq_hctx;
		2017	trace_block_unplug(q, 1, true);
2011	blk_mq_try_issue_directly(data.hctx, same_queue_rq,	2018	blk_mq_try_issue_directly(data.hctx, same_queue_rq,
2012	&cookie, false, true);	2019	&cookie);
2013	}	2020	}
2014	} else if ((q->nr_hw_queues > 1 && is_sync) \|\| (!q->elevator &&	2021	} else if ((q->nr_hw_queues > 1 && is_sync) \|\| (!q->elevator &&
2015	!data.hctx->dispatch_busy)) {	2022	!data.hctx->dispatch_busy)) {
2016	blk_mq_put_ctx(data.ctx);	2023	blk_mq_put_ctx(data.ctx);
2017	blk_mq_bio_to_request(rq, bio);	2024	blk_mq_bio_to_request(rq, bio);
2018	blk_mq_try_issue_directly(data.hctx, rq, &cookie, false, true);	2025	blk_mq_try_issue_directly(data.hctx, rq, &cookie);
2019	} else {	2026	} else {
2020	blk_mq_put_ctx(data.ctx);	2027	blk_mq_put_ctx(data.ctx);
2021	blk_mq_bio_to_request(rq, bio);	2028	blk_mq_bio_to_request(rq, bio);
@@ -2332,7 +2339,7 @@ static int blk_mq_init_hctx(struct request_queue *q, · 310 unmodified lines
2332	return 0;	2339	return 0;
2333		2340
2334	free_fq:	2341	free_fq:
2335	kfree(hctx->fq);	2342	blk_free_flush_queue(hctx->fq);
2336	exit_hctx:	2343	exit_hctx:
2337	if (set->ops->exit_hctx)	2344	if (set->ops->exit_hctx)
2338	set->ops->exit_hctx(hctx, hctx_idx);	2345	set->ops->exit_hctx(hctx, hctx_idx);

block/blk-mq.h+2−4

 void blk_mq_insert_requests(struct blk_mq_hw_ctx *hctx, struct blk_mq_ctx *ctx,
 				struct list_head *list);
-blk_status_t blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx,
+/* Used by blk_insert_cloned_request() to issue request directly */
-						struct request *rq,
+blk_status_t blk_mq_request_issue_directly(struct request *rq, bool last);
-						blk_qc_t *cookie,
-						bool bypass, bool last);
 void blk_mq_try_issue_list_directly(struct blk_mq_hw_ctx *hctx,
 				    struct list_head *list);

drivers/block/null_blk_main.c+5−0

 		return -EINVAL;
 	}
+	if (g_home_node != NUMA_NO_NODE && g_home_node >= nr_online_nodes) {
+		pr_err("null_blk: invalid home_node value\n");
+		g_home_node = NUMA_NO_NODE;
+	}
 	if (g_queue_mode == NULL_Q_RQ) {
 		pr_err("null_blk: legacy IO path no longer available\n");
 		return -EINVAL;

drivers/block/paride/pcd.c+13−1

 		disk->queue = blk_mq_init_sq_queue(&cd->tag_set, &pcd_mq_ops,
 						   1, BLK_MQ_F_SHOULD_MERGE);
 		if (IS_ERR(disk->queue)) {
+			put_disk(disk);
 			disk->queue = NULL;
 			continue;
 		}
 	printk("%s: No CD-ROM drive found\n", name);
 	for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
+		if (!cd->disk)
+			continue;
 		blk_cleanup_queue(cd->disk->queue);
 		cd->disk->queue = NULL;
 		blk_mq_free_tag_set(&cd->tag_set);
 	pcd_probe_capabilities();
 	if (register_blkdev(major, name)) {
-		for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++)
+		for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
+			if (!cd->disk)
+				continue;
+			blk_cleanup_queue(cd->disk->queue);
+			blk_mq_free_tag_set(&cd->tag_set);
 			put_disk(cd->disk);
+		}
 		return -EBUSY;
 	}
 	int unit;
 	for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) {
+		if (!cd->disk)
+			continue;
 		if (cd->present) {
 			del_gendisk(cd->disk);
 			pi_release(cd->pi);

drivers/block/paride/pf.c+11−1

 	printk("%s: No ATAPI disk detected\n", name);
 	for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
+		if (!pf->disk)
+			continue;
 		blk_cleanup_queue(pf->disk->queue);
 		pf->disk->queue = NULL;
 		blk_mq_free_tag_set(&pf->tag_set);
 	pf_busy = 0;
 	if (register_blkdev(major, name)) {
-		for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
+		for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
+			if (!pf->disk)
+				continue;
+			blk_cleanup_queue(pf->disk->queue);
+			blk_mq_free_tag_set(&pf->tag_set);
 			put_disk(pf->disk);
+		}
 		return -EBUSY;
 	}
 	int unit;
 	unregister_blkdev(major, name);
 	for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
+		if (!pf->disk)
+			continue;
 		if (pf->present)
 			del_gendisk(pf->disk);

drivers/block/xsysace.c+2−0

@@ -1090,6 +1090,8 @@ static int ace_setup(struct ace_device *ace) · 1089 unmodified lines
1090	return 0;	1090	return 0;
1091		1091
1092	err_read:	1092	err_read:
		1093	/* prevent double queue cleanup */
		1094	ace->gd->queue = NULL;
1093	put_disk(ace->gd);	1095	put_disk(ace->gd);
1094	err_alloc_disk:	1096	err_alloc_disk:
1095	blk_cleanup_queue(ace->queue);	1097	blk_cleanup_queue(ace->queue);

drivers/char/tpm/eventlog/tpm2.c+2−2

@@ -37,8 +37,8 @@ · 36 unmodified lines
37	*	37	*
38	* Returns size of the event. If it is an invalid event, returns 0.	38	* Returns size of the event. If it is an invalid event, returns 0.
39	*/	39	*/
40	static int calc_tpm2_event_size(struct tcg_pcr_event2_head *event,	40	static size_t calc_tpm2_event_size(struct tcg_pcr_event2_head *event,
41	struct tcg_pcr_event *event_header)	41	struct tcg_pcr_event *event_header)
42	{	42	{
43	struct tcg_efi_specid_event_head *efispecid;	43	struct tcg_efi_specid_event_head *efispecid;
44	struct tcg_event_field *event_field;	44	struct tcg_event_field *event_field;

drivers/char/tpm/tpm-dev-common.c+8−1

 	__poll_t mask = 0;
 	poll_wait(file, &priv->async_wait, wait);
+	mutex_lock(&priv->buffer_mutex);
-	if (!priv->response_read || priv->response_length)
+	/*
+	 * The response_length indicates if there is still response
+	 * (or part of it) to be consumed. Partial reads decrease it
+	 * by the number of bytes read, and write resets it the zero.
+	 */
+	if (priv->response_length)
 		mask = EPOLLIN | EPOLLRDNORM;
 	else
 		mask = EPOLLOUT | EPOLLWRNORM;
+	mutex_unlock(&priv->buffer_mutex);
 	return mask;
 }

drivers/char/tpm/tpm-interface.c+6−8

@@ -402,15 +402,13 @@ int tpm_pm_suspend(struct device *dev) · 401 unmodified lines
402	if (chip->flags & TPM_CHIP_FLAG_ALWAYS_POWERED)	402	if (chip->flags & TPM_CHIP_FLAG_ALWAYS_POWERED)
403	return 0;	403	return 0;
404		404
405	if (chip->flags & TPM_CHIP_FLAG_TPM2) {	405	if (!tpm_chip_start(chip)) {
406	mutex_lock(&chip->tpm_mutex);	406	if (chip->flags & TPM_CHIP_FLAG_TPM2)
407	if (!tpm_chip_start(chip)) {
408	tpm2_shutdown(chip, TPM2_SU_STATE);	407	tpm2_shutdown(chip, TPM2_SU_STATE);
409	tpm_chip_stop(chip);	408	else
410	}	409	rc = tpm1_pm_suspend(chip, tpm_suspend_pcr);
411	mutex_unlock(&chip->tpm_mutex);	410
412	} else {	411	tpm_chip_stop(chip);
413	rc = tpm1_pm_suspend(chip, tpm_suspend_pcr);
414	}	412	}
415		413
416	return rc;	414	return rc;

drivers/crypto/caam/caamhash.c+6−7

 		if (ret)
 			goto unmap_ctx;
-		if (mapped_nents) {
+		if (mapped_nents)
 			sg_to_sec4_sg_last(req->src, mapped_nents,
 					   edesc->sec4_sg + sec4_sg_src_index,
 					   0);
-			if (*next_buflen)
+		else
-				scatterwalk_map_and_copy(next_buf, req->src,
-							 to_hash - *buflen,
-							 *next_buflen, 0);
-		} else {
 			sg_to_sec4_set_last(edesc->sec4_sg + sec4_sg_src_index -
 					    1);
-		}
+		if (*next_buflen)
+			scatterwalk_map_and_copy(next_buf, req->src,
+						 to_hash - *buflen,
+						 *next_buflen, 0);
 		desc = edesc->hw_desc;
 		edesc->sec4_sg_dma = dma_map_single(jrdev, edesc->sec4_sg,

drivers/i2c/busses/i2c-imx.c+3−1

 	/* Init DMA config if supported */
 	ret = i2c_imx_dma_request(i2c_imx, phy_addr);
 	if (ret < 0)
-		goto clk_notifier_unregister;
+		goto del_adapter;
 	dev_info(&i2c_imx->adapter.dev, "IMX I2C adapter registered\n");
 	return 0;   /* Return OK */
+del_adapter:
+	i2c_del_adapter(&i2c_imx->adapter);
 clk_notifier_unregister:
 	clk_notifier_unregister(i2c_imx->clk, &i2c_imx->clk_change_nb);
 rpm_disable:

drivers/md/dm-core.h+1−0

@@ -115,6 +115,7 @@ struct mapped_device { · 114 unmodified lines
115	struct srcu_struct io_barrier;	115	struct srcu_struct io_barrier;
116	};	116	};
117		117
		118	void disable_discard(struct mapped_device *md);
118	void disable_write_same(struct mapped_device *md);	119	void disable_write_same(struct mapped_device *md);
119	void disable_write_zeroes(struct mapped_device *md);	120	void disable_write_zeroes(struct mapped_device *md);
120		121

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

@@ -36,7 +36,7 @@ struct dm_device { · 35 unmodified lines
36	struct list_head list;	36	struct list_head list;
37	};	37	};
38		38
39	const char *dm_allowed_targets[] __initconst = {	39	const char * const dm_allowed_targets[] __initconst = {
40	"crypt",	40	"crypt",
41	"delay",	41	"delay",
42	"linear",	42	"linear",

drivers/md/dm-integrity.c+7−9

 static bool ranges_overlap(struct dm_integrity_range *range1, struct dm_integrity_range *range2)
 {
 	return range1->logical_sector < range2->logical_sector + range2->n_sectors &&
-	       range2->logical_sector + range2->n_sectors > range2->logical_sector;
+	       range1->logical_sector + range1->n_sectors > range2->logical_sector;
 }
 static bool add_new_range(struct dm_integrity_c *ic, struct dm_integrity_range *new_range, bool check_waiting)
 		struct dm_integrity_range *last_range =
 			list_first_entry(&ic->wait_list, struct dm_integrity_range, wait_entry);
 		struct task_struct *last_range_task;
-		if (!ranges_overlap(range, last_range))
-			break;
 		last_range_task = last_range->task;
 		list_del(&last_range->wait_entry);
 		if (!add_new_range(ic, last_range, false)) {
 			journal_watermark = val;
 		else if (sscanf(opt_string, "commit_time:%u%c", &val, &dummy) == 1)
 			sync_msec = val;
-		else if (!memcmp(opt_string, "meta_device:", strlen("meta_device:"))) {
+		else if (!strncmp(opt_string, "meta_device:", strlen("meta_device:"))) {
 			if (ic->meta_dev) {
 				dm_put_device(ti, ic->meta_dev);
 				ic->meta_dev = NULL;
 				goto bad;
 			}
 			ic->sectors_per_block = val >> SECTOR_SHIFT;
-		} else if (!memcmp(opt_string, "internal_hash:", strlen("internal_hash:"))) {
+		} else if (!strncmp(opt_string, "internal_hash:", strlen("internal_hash:"))) {
 			r = get_alg_and_key(opt_string, &ic->internal_hash_alg, &ti->error,
 					    "Invalid internal_hash argument");
 			if (r)
 				goto bad;
-		} else if (!memcmp(opt_string, "journal_crypt:", strlen("journal_crypt:"))) {
+		} else if (!strncmp(opt_string, "journal_crypt:", strlen("journal_crypt:"))) {
 			r = get_alg_and_key(opt_string, &ic->journal_crypt_alg, &ti->error,
 					    "Invalid journal_crypt argument");
 			if (r)
 				goto bad;
-		} else if (!memcmp(opt_string, "journal_mac:", strlen("journal_mac:"))) {
+		} else if (!strncmp(opt_string, "journal_mac:", strlen("journal_mac:"))) {
 			r = get_alg_and_key(opt_string, &ic->journal_mac_alg,  &ti->error,
 					    "Invalid journal_mac argument");
 			if (r)
 	.io_hints		= dm_integrity_io_hints,
 };
-int __init dm_integrity_init(void)
+static int __init dm_integrity_init(void)
 {
 	int r;
 	return r;
 }
-void dm_integrity_exit(void)
+static void __exit dm_integrity_exit(void)
 {
 	dm_unregister_target(&integrity_target);
 	kmem_cache_destroy(journal_io_cache);

drivers/md/dm-rq.c+7−4

 	}
 	if (unlikely(error == BLK_STS_TARGET)) {
-		if (req_op(clone) == REQ_OP_WRITE_SAME &&
+		if (req_op(clone) == REQ_OP_DISCARD &&
-		    !clone->q->limits.max_write_same_sectors)
+		    !clone->q->limits.max_discard_sectors)
+			disable_discard(tio->md);
+		else if (req_op(clone) == REQ_OP_WRITE_SAME &&
+			 !clone->q->limits.max_write_same_sectors)
 			disable_write_same(tio->md);
-		if (req_op(clone) == REQ_OP_WRITE_ZEROES &&
+		else if (req_op(clone) == REQ_OP_WRITE_ZEROES &&
-		    !clone->q->limits.max_write_zeroes_sectors)
+			 !clone->q->limits.max_write_zeroes_sectors)
 			disable_write_zeroes(tio->md);
 	}

drivers/md/dm-table.c+39−0

@@ -1844,6 +1844,36 @@ static bool dm_table_supports_secure_erase(struct dm_table *t) · 1843 unmodified lines
1844	return true;	1844	return true;
1845	}	1845	}
1846		1846
		1847	static int device_requires_stable_pages(struct dm_target *ti,
		1848	struct dm_dev *dev, sector_t start,
		1849	sector_t len, void *data)
		1850	{
		1851	struct request_queue *q = bdev_get_queue(dev->bdev);
		1852
		1853	return q && bdi_cap_stable_pages_required(q->backing_dev_info);
		1854	}
		1855
		1856	/*
		1857	* If any underlying device requires stable pages, a table must require
		1858	* them as well. Only targets that support iterate_devices are considered:
		1859	* don't want error, zero, etc to require stable pages.
		1860	*/
		1861	static bool dm_table_requires_stable_pages(struct dm_table *t)
		1862	{
		1863	struct dm_target *ti;
		1864	unsigned i;
		1865
		1866	for (i = 0; i < dm_table_get_num_targets(t); i++) {
		1867	ti = dm_table_get_target(t, i);
		1868
		1869	if (ti->type->iterate_devices &&
		1870	ti->type->iterate_devices(ti, device_requires_stable_pages, NULL))
		1871	return true;
		1872	}
		1873
		1874	return false;
		1875	}
		1876
1847	void dm_table_set_restrictions(struct dm_table t, struct request_queue q,	1877	void dm_table_set_restrictions(struct dm_table t, struct request_queue q,
1848	struct queue_limits *limits)	1878	struct queue_limits *limits)
1849	{	1879	{
@@ -1896,6 +1926,15 @@ void dm_table_set_restrictions(struct dm_table t, struct request_queue q, · 46 unmodified lines
1896		1926
1897	dm_table_verify_integrity(t);	1927	dm_table_verify_integrity(t);
1898		1928
		1929	/*
		1930	* Some devices don't use blk_integrity but still want stable pages
		1931	* because they do their own checksumming.
		1932	*/
		1933	if (dm_table_requires_stable_pages(t))
		1934	q->backing_dev_info->capabilities \|= BDI_CAP_STABLE_WRITES;
		1935	else
		1936	q->backing_dev_info->capabilities &= ~BDI_CAP_STABLE_WRITES;
		1937
1899	/*	1938	/*
1900	* Determine whether or not this queue's I/O timings contribute	1939	* Determine whether or not this queue's I/O timings contribute
1901	* to the entropy pool, Only request-based targets use this.	1940	* to the entropy pool, Only request-based targets use this.

drivers/md/dm.c+17−13

 	}
 }
+void disable_discard(struct mapped_device *md)
+{
+	struct queue_limits *limits = dm_get_queue_limits(md);
+	/* device doesn't really support DISCARD, disable it */
+	limits->max_discard_sectors = 0;
+	blk_queue_flag_clear(QUEUE_FLAG_DISCARD, md->queue);
+}
 void disable_write_same(struct mapped_device *md)
 {
 	struct queue_limits *limits = dm_get_queue_limits(md);
 	dm_endio_fn endio = tio->ti->type->end_io;
 	if (unlikely(error == BLK_STS_TARGET) && md->type != DM_TYPE_NVME_BIO_BASED) {
-		if (bio_op(bio) == REQ_OP_WRITE_SAME &&
+		if (bio_op(bio) == REQ_OP_DISCARD &&
-		    !bio->bi_disk->queue->limits.max_write_same_sectors)
+		    !bio->bi_disk->queue->limits.max_discard_sectors)
+			disable_discard(md);
+		else if (bio_op(bio) == REQ_OP_WRITE_SAME &&
+			 !bio->bi_disk->queue->limits.max_write_same_sectors)
 			disable_write_same(md);
-		if (bio_op(bio) == REQ_OP_WRITE_ZEROES &&
+		else if (bio_op(bio) == REQ_OP_WRITE_ZEROES &&
-		    !bio->bi_disk->queue->limits.max_write_zeroes_sectors)
+			 !bio->bi_disk->queue->limits.max_write_zeroes_sectors)
 			disable_write_zeroes(md);
 	}
 		return -EINVAL;
 	}
-	/*
+	ti->max_io_len = (uint32_t) len;
-	 * BIO based queue uses its own splitting. When multipage bvecs
-	 * is switched on, size of the incoming bio may be too big to
-	 * be handled in some targets, such as crypt.
-	 *
-	 * When these targets are ready for the big bio, we can remove
-	 * the limit.
-	 */
-	ti->max_io_len = min_t(uint32_t, len, BIO_MAX_PAGES * PAGE_SIZE);
 	return 0;
 }

drivers/mtd/chips/cfi_cmdset_0002.c+5−1

 			continue;
 		}
-		if (time_after(jiffies, timeo) && !chip_ready(map, adr))
+		/*
+		 * We check "time_after" and "!chip_good" before checking "chip_good" to avoid
+		 * the failure due to scheduling.
+		 */
+		if (time_after(jiffies, timeo) && !chip_good(map, adr, datum))
 			break;
 		if (chip_good(map, adr, datum)) {

drivers/net/ethernet/broadcom/bnxt/bnxt.c+13−3

 	tpa_info = &rxr->rx_tpa[agg_id];
 	if (unlikely(cons != rxr->rx_next_cons)) {
+		netdev_warn(bp->dev, "TPA cons %x != expected cons %x\n",
+			    cons, rxr->rx_next_cons);
 		bnxt_sched_reset(bp, rxr);
 		return;
 	}
 	}
 	cons = rxcmp->rx_cmp_opaque;
-	rx_buf = &rxr->rx_buf_ring[cons];
-	data = rx_buf->data;
-	data_ptr = rx_buf->data_ptr;
 	if (unlikely(cons != rxr->rx_next_cons)) {
 		int rc1 = bnxt_discard_rx(bp, cpr, raw_cons, rxcmp);
+		netdev_warn(bp->dev, "RX cons %x != expected cons %x\n",
+			    cons, rxr->rx_next_cons);
 		bnxt_sched_reset(bp, rxr);
 		return rc1;
 	}
+	rx_buf = &rxr->rx_buf_ring[cons];
+	data = rx_buf->data;
+	data_ptr = rx_buf->data_ptr;
 	prefetch(data_ptr);
 	misc = le32_to_cpu(rxcmp->rx_cmp_misc_v1);
 	rx_buf->data = NULL;
 	if (rxcmp1->rx_cmp_cfa_code_errors_v2 & RX_CMP_L2_ERRORS) {
+		u32 rx_err = le32_to_cpu(rxcmp1->rx_cmp_cfa_code_errors_v2);
 		bnxt_reuse_rx_data(rxr, cons, data);
 		if (agg_bufs)
 			bnxt_reuse_rx_agg_bufs(cpr, cp_cons, agg_bufs);
 		rc = -EIO;
+		if (rx_err & RX_CMPL_ERRORS_BUFFER_ERROR_MASK) {
+			netdev_warn(bp->dev, "RX buffer error %x\n", rx_err);
+			bnxt_sched_reset(bp, rxr);
+		}
 		goto next_rx;
 	}

drivers/net/ethernet/broadcom/tg3.c+4−4

@@ -4283,7 +4283,7 @@ static void tg3_power_down(struct tg3 *tp) · 4282 unmodified lines
4283	pci_set_power_state(tp->pdev, PCI_D3hot);	4283	pci_set_power_state(tp->pdev, PCI_D3hot);
4284	}	4284	}
4285		4285
4286	static void tg3_aux_stat_to_speed_duplex(struct tg3 tp, u32 val, u16 speed, u8 *duplex)	4286	static void tg3_aux_stat_to_speed_duplex(struct tg3 tp, u32 val, u32 speed, u8 *duplex)
4287	{	4287	{
4288	switch (val & MII_TG3_AUX_STAT_SPDMASK) {	4288	switch (val & MII_TG3_AUX_STAT_SPDMASK) {
4289	case MII_TG3_AUX_STAT_10HALF:	4289	case MII_TG3_AUX_STAT_10HALF:
@@ -4787,7 +4787,7 @@ static int tg3_setup_copper_phy(struct tg3 *tp, bool force_reset) · 497 unmodified lines
4787	bool current_link_up;	4787	bool current_link_up;
4788	u32 bmsr, val;	4788	u32 bmsr, val;
4789	u32 lcl_adv, rmt_adv;	4789	u32 lcl_adv, rmt_adv;
4790	u16 current_speed;	4790	u32 current_speed;
4791	u8 current_duplex;	4791	u8 current_duplex;
4792	int i, err;	4792	int i, err;
4793		4793
@@ -5719,7 +5719,7 @@ out: · 925 unmodified lines
5719	static int tg3_setup_fiber_phy(struct tg3 *tp, bool force_reset)	5719	static int tg3_setup_fiber_phy(struct tg3 *tp, bool force_reset)
5720	{	5720	{
5721	u32 orig_pause_cfg;	5721	u32 orig_pause_cfg;
5722	u16 orig_active_speed;	5722	u32 orig_active_speed;
5723	u8 orig_active_duplex;	5723	u8 orig_active_duplex;
5724	u32 mac_status;	5724	u32 mac_status;
5725	bool current_link_up;	5725	bool current_link_up;
@@ -5823,7 +5823,7 @@ static int tg3_setup_fiber_mii_phy(struct tg3 *tp, bool force_reset) · 97 unmodified lines
5823	{	5823	{
5824	int err = 0;	5824	int err = 0;
5825	u32 bmsr, bmcr;	5825	u32 bmsr, bmcr;
5826	u16 current_speed = SPEED_UNKNOWN;	5826	u32 current_speed = SPEED_UNKNOWN;
5827	u8 current_duplex = DUPLEX_UNKNOWN;	5827	u8 current_duplex = DUPLEX_UNKNOWN;
5828	bool current_link_up = false;	5828	bool current_link_up = false;
5829	u32 local_adv, remote_adv, sgsr;	5829	u32 local_adv, remote_adv, sgsr;

drivers/net/ethernet/broadcom/tg3.h+2−2

@@ -2873,7 +2873,7 @@ struct tg3_tx_ring_info { · 2872 unmodified lines
2873	struct tg3_link_config {	2873	struct tg3_link_config {
2874	/* Describes what we're trying to get. */	2874	/* Describes what we're trying to get. */
2875	u32 advertising;	2875	u32 advertising;
2876	u16 speed;	2876	u32 speed;
2877	u8 duplex;	2877	u8 duplex;
2878	u8 autoneg;	2878	u8 autoneg;
2879	u8 flowctrl;	2879	u8 flowctrl;
@@ -2882,7 +2882,7 @@ struct tg3_link_config { · 2 unmodified lines
2882	u8 active_flowctrl;	2882	u8 active_flowctrl;
2883		2883
2884	u8 active_duplex;	2884	u8 active_duplex;
2885	u16 active_speed;	2885	u32 active_speed;
2886	u32 rmt_adv;	2886	u32 rmt_adv;
2887	};	2887	};
2888		2888

drivers/net/ethernet/cadence/macb_main.c+3−1

 			/* First, update TX stats if needed */
 			if (skb) {
-				if (gem_ptp_do_txstamp(queue, skb, desc) == 0) {
+				if (unlikely(skb_shinfo(skb)->tx_flags &
+					     SKBTX_HW_TSTAMP) &&
+				    gem_ptp_do_txstamp(queue, skb, desc) == 0) {
 					/* skb now belongs to timestamp buffer
 					 * and will be removed later
 					 */

drivers/net/ethernet/qlogic/qlcnic/qlcnic.h+1−1

@@ -497,7 +497,7 @@ struct qlcnic_hardware_context { · 496 unmodified lines
497	u16 board_type;	497	u16 board_type;
498	u16 supported_type;	498	u16 supported_type;
499		499
500	u16 link_speed;	500	u32 link_speed;
501	u16 link_duplex;	501	u16 link_duplex;
502	u16 link_autoneg;	502	u16 link_autoneg;
503	u16 module_type;	503	u16 module_type;

drivers/net/ethernet/realtek/r8169.c+6−0

 #include <linux/pm_runtime.h>
 #include <linux/firmware.h>
 #include <linux/prefetch.h>
+#include <linux/pci-aspm.h>
 #include <linux/ipv6.h>
 #include <net/ip6_checksum.h>
 	if (rc)
 		return rc;
+	/* Disable ASPM completely as that cause random device stop working
+	 * problems as well as full system hangs for some PCIe devices users.
+	 */
+	pci_disable_link_state(pdev, PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1);
 	/* enable device (incl. PCI PM wakeup and hotplug setup) */
 	rc = pcim_enable_device(pdev);
 	if (rc < 0) {

drivers/net/vrf.c+6−2

 	dev->priv_flags |= IFF_NO_QUEUE;
 	dev->priv_flags |= IFF_NO_RX_HANDLER;
-	dev->min_mtu = 0;
+	/* VRF devices do not care about MTU, but if the MTU is set
-	dev->max_mtu = 0;
+	 * too low then the ipv4 and ipv6 protocols are disabled
+	 * which breaks networking.
+	 */
+	dev->min_mtu = IPV6_MIN_MTU;
+	dev->max_mtu = ETH_MAX_MTU;
 }
 static int vrf_validate(struct nlattr *tb[], struct nlattr *data[],

drivers/parisc/iosapic.c+5−1

 #define DBG_IRT(x...)
 #endif
+#ifdef CONFIG_64BIT
+#define COMPARE_IRTE_ADDR(irte, hpa)	((irte)->dest_iosapic_addr == (hpa))
+#else
 #define COMPARE_IRTE_ADDR(irte, hpa)	\
-		((irte)->dest_iosapic_addr == F_EXTEND(hpa))
+		((irte)->dest_iosapic_addr == ((hpa) | 0xffffffff00000000ULL))
+#endif
 #define IOSAPIC_REG_SELECT              0x00
 #define IOSAPIC_REG_WINDOW              0x10

drivers/reset/reset-meson-audio-arb.c+1−0

@@ -130,6 +130,7 @@ static int meson_audio_arb_probe(struct platform_device *pdev) · 129 unmodified lines
130	arb->rstc.nr_resets = ARRAY_SIZE(axg_audio_arb_reset_bits);	130	arb->rstc.nr_resets = ARRAY_SIZE(axg_audio_arb_reset_bits);
131	arb->rstc.ops = &meson_audio_arb_rstc_ops;	131	arb->rstc.ops = &meson_audio_arb_rstc_ops;
132	arb->rstc.of_node = dev->of_node;	132	arb->rstc.of_node = dev->of_node;
		133	arb->rstc.owner = THIS_MODULE;
133		134
134	/*	135	/*
135	* Enable general :	136	* Enable general :

drivers/rtc/Kconfig+2−2

@@ -667,9 +667,9 @@ config RTC_DRV_S5M · 666 unmodified lines
667	will be called rtc-s5m.	667	will be called rtc-s5m.
668		668
669	config RTC_DRV_SD3078	669	config RTC_DRV_SD3078
670	tristate "ZXW Crystal SD3078"	670	tristate "ZXW Shenzhen whwave SD3078"
671	help	671	help
672	If you say yes here you get support for the ZXW Crystal	672	If you say yes here you get support for the ZXW Shenzhen whwave
673	SD3078 RTC chips.	673	SD3078 RTC chips.
674		674
675	This driver can also be built as a module. If so, the module	675	This driver can also be built as a module. If so, the module

drivers/rtc/rtc-cros-ec.c+2−2

@@ -298,7 +298,7 @@ static int cros_ec_rtc_suspend(struct device *dev) · 297 unmodified lines
298	struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(&pdev->dev);	298	struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(&pdev->dev);
299		299
300	if (device_may_wakeup(dev))	300	if (device_may_wakeup(dev))
301	enable_irq_wake(cros_ec_rtc->cros_ec->irq);	301	return enable_irq_wake(cros_ec_rtc->cros_ec->irq);
302		302
303	return 0;	303	return 0;
304	}	304	}
@@ -309,7 +309,7 @@ static int cros_ec_rtc_resume(struct device *dev) · 4 unmodified lines
309	struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(&pdev->dev);	309	struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(&pdev->dev);
310		310
311	if (device_may_wakeup(dev))	311	if (device_may_wakeup(dev))
312	disable_irq_wake(cros_ec_rtc->cros_ec->irq);	312	return disable_irq_wake(cros_ec_rtc->cros_ec->irq);
313		313
314	return 0;	314	return 0;
315	}	315	}

drivers/rtc/rtc-da9063.c+7−0

@@ -480,6 +480,13 @@ static int da9063_rtc_probe(struct platform_device *pdev) · 479 unmodified lines
480	da9063_data_to_tm(data, &rtc->alarm_time, rtc);	480	da9063_data_to_tm(data, &rtc->alarm_time, rtc);
481	rtc->rtc_sync = false;	481	rtc->rtc_sync = false;
482		482
		483	/*
		484	* TODO: some models have alarms on a minute boundary but still support
		485	* real hardware interrupts. Add this once the core supports it.
		486	*/
		487	if (config->rtc_data_start != RTC_SEC)
		488	rtc->rtc_dev->uie_unsupported = 1;
		489
483	irq_alarm = platform_get_irq_byname(pdev, "ALARM");	490	irq_alarm = platform_get_irq_byname(pdev, "ALARM");
484	ret = devm_request_threaded_irq(&pdev->dev, irq_alarm, NULL,	491	ret = devm_request_threaded_irq(&pdev->dev, irq_alarm, NULL,
485	da9063_alarm_event,	492	da9063_alarm_event,

drivers/rtc/rtc-sh.c+1−1

@@ -374,7 +374,7 @@ static int sh_rtc_set_time(struct device dev, struct rtc_time tm) · 373 unmodified lines
374	static inline int sh_rtc_read_alarm_value(struct sh_rtc *rtc, int reg_off)	374	static inline int sh_rtc_read_alarm_value(struct sh_rtc *rtc, int reg_off)
375	{	375	{
376	unsigned int byte;	376	unsigned int byte;
377	int value = 0xff; /* return 0xff for ignored values */	377	int value = -1; /* return -1 for ignored values */
378		378
379	byte = readb(rtc->regbase + reg_off);	379	byte = readb(rtc->regbase + reg_off);
380	if (byte & AR_ENB) {	380	if (byte & AR_ENB) {

drivers/scsi/lpfc/lpfc_scsi.c+3−4

 	 * wake up the thread.
 	 */
 	spin_lock(&lpfc_cmd->buf_lock);
-	if (unlikely(lpfc_cmd->cur_iocbq.iocb_flag & LPFC_DRIVER_ABORTED)) {
+	lpfc_cmd->cur_iocbq.iocb_flag &= ~LPFC_DRIVER_ABORTED;
-		lpfc_cmd->cur_iocbq.iocb_flag &= ~LPFC_DRIVER_ABORTED;
+	if (lpfc_cmd->waitq) {
-		if (lpfc_cmd->waitq)
+		wake_up(lpfc_cmd->waitq);
-			wake_up(lpfc_cmd->waitq);
 		lpfc_cmd->waitq = NULL;
 	}
 	spin_unlock(&lpfc_cmd->buf_lock);

drivers/scsi/qedi/qedi_main.c+2−5

 static int qedi_alloc_nvm_iscsi_cfg(struct qedi_ctx *qedi)
 {
-	struct qedi_nvm_iscsi_image nvm_image;
 	qedi->iscsi_image = dma_alloc_coherent(&qedi->pdev->dev,
-					       sizeof(nvm_image),
+					       sizeof(struct qedi_nvm_iscsi_image),
 					       &qedi->nvm_buf_dma, GFP_KERNEL);
 	if (!qedi->iscsi_image) {
 		QEDI_ERR(&qedi->dbg_ctx, "Could not allocate NVM BUF.\n");
 static int qedi_get_boot_info(struct qedi_ctx *qedi)
 {
 	int ret = 1;
-	struct qedi_nvm_iscsi_image nvm_image;
 	QEDI_INFO(&qedi->dbg_ctx, QEDI_LOG_INFO,
 		  "Get NVM iSCSI CFG image\n");
 	ret = qedi_ops->common->nvm_get_image(qedi->cdev,
 					      QED_NVM_IMAGE_ISCSI_CFG,
 					      (char *)qedi->iscsi_image,
-					      sizeof(nvm_image));
+					      sizeof(struct qedi_nvm_iscsi_image));
 	if (ret)
 		QEDI_ERR(&qedi->dbg_ctx,
 			 "Could not get NVM image. ret = %d\n", ret);

drivers/scsi/scsi_devinfo.c+1−0

@@ -238,6 +238,7 @@ static struct { · 237 unmodified lines
238	{"NETAPP", "Universal Xport", "*", BLIST_NO_ULD_ATTACH},	238	{"NETAPP", "Universal Xport", "*", BLIST_NO_ULD_ATTACH},
239	{"LSI", "Universal Xport", "*", BLIST_NO_ULD_ATTACH},	239	{"LSI", "Universal Xport", "*", BLIST_NO_ULD_ATTACH},
240	{"ENGENIO", "Universal Xport", "*", BLIST_NO_ULD_ATTACH},	240	{"ENGENIO", "Universal Xport", "*", BLIST_NO_ULD_ATTACH},
		241	{"LENOVO", "Universal Xport", "*", BLIST_NO_ULD_ATTACH},
241	{"SMSC", "USB 2 HS-CF", NULL, BLIST_SPARSELUN \| BLIST_INQUIRY_36},	242	{"SMSC", "USB 2 HS-CF", NULL, BLIST_SPARSELUN \| BLIST_INQUIRY_36},
242	{"SONY", "CD-ROM CDU-8001", NULL, BLIST_BORKEN},	243	{"SONY", "CD-ROM CDU-8001", NULL, BLIST_BORKEN},
243	{"SONY", "TSL", NULL, BLIST_FORCELUN}, /* DDS3 & DDS4 autoloaders */	244	{"SONY", "TSL", NULL, BLIST_FORCELUN}, /* DDS3 & DDS4 autoloaders */

drivers/scsi/scsi_dh.c+1−0

@@ -75,6 +75,7 @@ static const struct scsi_dh_blist scsi_dh_blist[] = { · 74 unmodified lines
75	{"NETAPP", "INF-01-00", "rdac", },	75	{"NETAPP", "INF-01-00", "rdac", },
76	{"LSI", "INF-01-00", "rdac", },	76	{"LSI", "INF-01-00", "rdac", },
77	{"ENGENIO", "INF-01-00", "rdac", },	77	{"ENGENIO", "INF-01-00", "rdac", },
		78	{"LENOVO", "DE_Series", "rdac", },
78	{NULL, NULL, NULL },	79	{NULL, NULL, NULL },
79	};	80	};
80		81

drivers/scsi/storvsc_drv.c+12−3

  * This is the end of Protocol specific defines.
  */
-static int storvsc_ringbuffer_size = (256 * PAGE_SIZE);
+static int storvsc_ringbuffer_size = (128 * 1024);
 static u32 max_outstanding_req_per_channel;
 static int storvsc_vcpus_per_sub_channel = 4;
 {
 	struct device *dev = &device->device;
 	struct storvsc_device *stor_device;
-	int num_cpus = num_online_cpus();
 	int num_sc;
 	struct storvsc_cmd_request *request;
 	struct vstor_packet *vstor_packet;
 	int ret, t;
-	num_sc = ((max_chns > num_cpus) ? num_cpus : max_chns);
+	/*
+	 * If the number of CPUs is artificially restricted, such as
+	 * with maxcpus=1 on the kernel boot line, Hyper-V could offer
+	 * sub-channels >= the number of CPUs. These sub-channels
+	 * should not be created. The primary channel is already created
+	 * and assigned to one CPU, so check against # CPUs - 1.
+	 */
+	num_sc = min((int)(num_online_cpus() - 1), max_chns);
+	if (!num_sc)
+		return;
 	stor_device = get_out_stor_device(device);
 	if (!stor_device)
 		return;

drivers/vfio/pci/vfio_pci.c+2−2

@@ -1661,11 +1661,11 @@ static void __init vfio_pci_fill_ids(void) · 1660 unmodified lines
1661	rc = pci_add_dynid(&vfio_pci_driver, vendor, device,	1661	rc = pci_add_dynid(&vfio_pci_driver, vendor, device,
1662	subvendor, subdevice, class, class_mask, 0);	1662	subvendor, subdevice, class, class_mask, 0);
1663	if (rc)	1663	if (rc)
1664	pr_warn("failed to add dynamic id [%04hx:%04hx[%04hx:%04hx]] class %#08x/%08x (%d)\n",	1664	pr_warn("failed to add dynamic id [%04x:%04x[%04x:%04x]] class %#08x/%08x (%d)\n",
1665	vendor, device, subvendor, subdevice,	1665	vendor, device, subvendor, subdevice,
1666	class, class_mask, rc);	1666	class, class_mask, rc);
1667	else	1667	else
1668	pr_info("add [%04hx:%04hx[%04hx:%04hx]] class %#08x/%08x\n",	1668	pr_info("add [%04x:%04x[%04x:%04x]] class %#08x/%08x\n",
1669	vendor, device, subvendor, subdevice,	1669	vendor, device, subvendor, subdevice,
1670	class, class_mask);	1670	class, class_mask);
1671	}	1671	}

drivers/vfio/vfio_iommu_spapr_tce.c+1−1

@@ -1398,7 +1398,7 @@ unlock_exit: · 1397 unmodified lines
1398	mutex_unlock(&container->lock);	1398	mutex_unlock(&container->lock);
1399	}	1399	}
1400		1400
1401	const struct vfio_iommu_driver_ops tce_iommu_driver_ops = {	1401	static const struct vfio_iommu_driver_ops tce_iommu_driver_ops = {
1402	.name = "iommu-vfio-powerpc",	1402	.name = "iommu-vfio-powerpc",
1403	.owner = THIS_MODULE,	1403	.owner = THIS_MODULE,
1404	.open = tce_iommu_open,	1404	.open = tce_iommu_open,

drivers/vfio/vfio_iommu_type1.c+14−0

 MODULE_PARM_DESC(disable_hugepages,
 		 "Disable VFIO IOMMU support for IOMMU hugepages.");
+static unsigned int dma_entry_limit __read_mostly = U16_MAX;
+module_param_named(dma_entry_limit, dma_entry_limit, uint, 0644);
+MODULE_PARM_DESC(dma_entry_limit,
+		 "Maximum number of user DMA mappings per container (65535).");
 struct vfio_iommu {
 	struct list_head	domain_list;
 	struct vfio_domain	*external_domain; /* domain for external user */
 	struct mutex		lock;
 	struct rb_root		dma_list;
 	struct blocking_notifier_head notifier;
+	unsigned int		dma_avail;
 	bool			v2;
 	bool			nesting;
 };
 	vfio_unlink_dma(iommu, dma);
 	put_task_struct(dma->task);
 	kfree(dma);
+	iommu->dma_avail++;
 }
 static unsigned long vfio_pgsize_bitmap(struct vfio_iommu *iommu)
 		goto out_unlock;
 	}
+	if (!iommu->dma_avail) {
+		ret = -ENOSPC;
+		goto out_unlock;
+	}
 	dma = kzalloc(sizeof(*dma), GFP_KERNEL);
 	if (!dma) {
 		ret = -ENOMEM;
 		goto out_unlock;
 	}
+	iommu->dma_avail--;
 	dma->iova = iova;
 	dma->vaddr = vaddr;
 	dma->prot = prot;
 	INIT_LIST_HEAD(&iommu->domain_list);
 	iommu->dma_list = RB_ROOT;
+	iommu->dma_avail = dma_entry_limit;
 	mutex_init(&iommu->lock);
 	BLOCKING_INIT_NOTIFIER_HEAD(&iommu->notifier);

drivers/xen/privcmd-buf.c+1−2

@@ -140,8 +140,7 @@ static int privcmd_buf_mmap(struct file file, struct vm_area_struct vma) · 139 unmodified lines
140	if (!(vma->vm_flags & VM_SHARED))	140	if (!(vma->vm_flags & VM_SHARED))
141	return -EINVAL;	141	return -EINVAL;
142		142
143	vma_priv = kzalloc(sizeof(vma_priv) + count sizeof(void *),	143	vma_priv = kzalloc(struct_size(vma_priv, pages, count), GFP_KERNEL);
144	GFP_KERNEL);
145	if (!vma_priv)	144	if (!vma_priv)
146	return -ENOMEM;	145	return -ENOMEM;
147		146

drivers/xen/xenbus/xenbus_dev_frontend.c+1−3

@@ -622,9 +622,7 @@ static int xenbus_file_open(struct inode inode, struct file filp) · 621 unmodified lines
622	if (xen_store_evtchn == 0)	622	if (xen_store_evtchn == 0)
623	return -ENOENT;	623	return -ENOENT;
624		624
625	nonseekable_open(inode, filp);	625	stream_open(inode, filp);
626
627	filp->f_mode &= ~FMODE_ATOMIC_POS; /* cdev-style semantics */
628		626
629	u = kzalloc(sizeof(*u), GFP_KERNEL);	627	u = kzalloc(sizeof(*u), GFP_KERNEL);
630	if (u == NULL)	628	if (u == NULL)

fs/hugetlbfs/inode.c+14−6

 					umode_t mode, dev_t dev)
 {
 	struct inode *inode;
-	struct resv_map *resv_map;
+	struct resv_map *resv_map = NULL;
-	resv_map = resv_map_alloc();
+	/*
-	if (!resv_map)
+	 * Reserve maps are only needed for inodes that can have associated
-		return NULL;
+	 * page allocations.
+	 */
+	if (S_ISREG(mode) || S_ISLNK(mode)) {
+		resv_map = resv_map_alloc();
+		if (!resv_map)
+			return NULL;
+	}
 	inode = new_inode(sb);
 	if (inode) {
 			break;
 		}
 		lockdep_annotate_inode_mutex_key(inode);
-	} else
+	} else {
-		kref_put(&resv_map->refs, resv_map_release);
+		if (resv_map)
+			kref_put(&resv_map->refs, resv_map_release);
+	}
 	return inode;
 }

fs/io_uring.c+1−0

@@ -2215,6 +2215,7 @@ static int io_sqe_files_register(struct io_ring_ctx ctx, void __user arg, · 2214 unmodified lines
2215	fput(ctx->user_files[i]);	2215	fput(ctx->user_files[i]);
2216		2216
2217	kfree(ctx->user_files);	2217	kfree(ctx->user_files);
		2218	ctx->user_files = NULL;
2218	ctx->nr_user_files = 0;	2219	ctx->nr_user_files = 0;
2219	return ret;	2220	return ret;
2220	}	2221	}

fs/open.c+18−0

@@ -1215,3 +1215,21 @@ int nonseekable_open(struct inode inode, struct file filp) · 1214 unmodified lines
1215	}	1215	}
1216		1216
1217	EXPORT_SYMBOL(nonseekable_open);	1217	EXPORT_SYMBOL(nonseekable_open);
		1218
		1219	/*
		1220	* stream_open is used by subsystems that want stream-like file descriptors.
		1221	* Such file descriptors are not seekable and don't have notion of position
		1222	* (file.f_pos is always 0). Contrary to file descriptors of other regular
		1223	* files, .read() and .write() can run simultaneously.
		1224	*
		1225	* stream_open never fails and is marked to return int so that it could be
		1226	* directly used as file_operations.open .
		1227	*/
		1228	int stream_open(struct inode inode, struct file filp)
		1229	{
		1230	filp->f_mode &= ~(FMODE_LSEEK \| FMODE_PREAD \| FMODE_PWRITE \| FMODE_ATOMIC_POS);
		1231	filp->f_mode \|= FMODE_STREAM;
		1232	return 0;
		1233	}
		1234
		1235	EXPORT_SYMBOL(stream_open);

fs/proc/base.c+9−8

 static int proc_pid_syscall(struct seq_file *m, struct pid_namespace *ns,
 			    struct pid *pid, struct task_struct *task)
 {
-	long nr;
+	struct syscall_info info;
-	unsigned long args[6], sp, pc;
+	u64 *args = &info.data.args[0];
 	int res;
 	res = lock_trace(task);
 	if (res)
 		return res;
-	if (task_current_syscall(task, &nr, args, 6, &sp, &pc))
+	if (task_current_syscall(task, &info))
 		seq_puts(m, "running\n");
-	else if (nr < 0)
+	else if (info.data.nr < 0)
-		seq_printf(m, "%ld 0x%lx 0x%lx\n", nr, sp, pc);
+		seq_printf(m, "%d 0x%llx 0x%llx\n",
+			   info.data.nr, info.sp, info.data.instruction_pointer);
 	else
 		seq_printf(m,
-		       "%ld 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n",
+		       "%d 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx\n",
-		       nr,
+		       info.data.nr,
 		       args[0], args[1], args[2], args[3], args[4], args[5],
-		       sp, pc);
+		       info.sp, info.data.instruction_pointer);
 	unlock_trace(task);
 	return 0;

fs/read_write.c+3−2

 static inline loff_t file_pos_read(struct file *file)
 {
-	return file->f_pos;
+	return file->f_mode & FMODE_STREAM ? 0 : file->f_pos;
 }
 static inline void file_pos_write(struct file *file, loff_t pos)
 {
-	file->f_pos = pos;
+	if ((file->f_mode & FMODE_STREAM) == 0)
+		file->f_pos = pos;
 }
 ssize_t ksys_read(unsigned int fd, char __user *buf, size_t count)

include/asm-generic/syscall.h+5−16

  * syscall_get_arguments - extract system call parameter values
  * @task:	task of interest, must be blocked
  * @regs:	task_pt_regs() of @task
- * @i:		argument index [0,5]
- * @n:		number of arguments; n+i must be [1,6].
  * @args:	array filled with argument values
  *
- * Fetches @n arguments to the system call starting with the @i'th argument
+ * Fetches 6 arguments to the system call.  First argument is stored in
- * (from 0 through 5).  Argument @i is stored in @args[0], and so on.
+*  @args[0], and so on.
- * An arch inline version is probably optimal when @i and @n are constants.
  *
  * It's only valid to call this when @task is stopped for tracing on
  * entry to a system call, due to %TIF_SYSCALL_TRACE or %TIF_SYSCALL_AUDIT.
- * It's invalid to call this with @i + @n > 6; we only support system calls
- * taking up to 6 arguments.
  */
 void syscall_get_arguments(struct task_struct *task, struct pt_regs *regs,
-			   unsigned int i, unsigned int n, unsigned long *args);
+			   unsigned long *args);
 /**
  * syscall_set_arguments - change system call parameter value
  * @task:	task of interest, must be in system call entry tracing
  * @regs:	task_pt_regs() of @task
- * @i:		argument index [0,5]
- * @n:		number of arguments; n+i must be [1,6].
  * @args:	array of argument values to store
  *
- * Changes @n arguments to the system call starting with the @i'th argument.
+ * Changes 6 arguments to the system call.
- * Argument @i gets value @args[0], and so on.
+ * The first argument gets value @args[0], and so on.
- * An arch inline version is probably optimal when @i and @n are constants.
  *
  * It's only valid to call this when @task is stopped for tracing on
  * entry to a system call, due to %TIF_SYSCALL_TRACE or %TIF_SYSCALL_AUDIT.
- * It's invalid to call this with @i + @n > 6; we only support system calls
- * taking up to 6 arguments.
  */
 void syscall_set_arguments(struct task_struct *task, struct pt_regs *regs,
-			   unsigned int i, unsigned int n,
 			   const unsigned long *args);
 /**

include/dt-bindings/reset/amlogic,meson-g12a-reset.h+4−1

 #define RESET_SD_EMMC_A			44
 #define RESET_SD_EMMC_B			45
 #define RESET_SD_EMMC_C			46
-/*					47-60 */
+/*					47	*/
+#define RESET_USB_PHY20			48
+#define RESET_USB_PHY21			49
+/*					50-60	*/
 #define RESET_AUDIO_CODEC		61
 /*					62-63	*/
 /*	RESET2					*/

include/keys/trusted.h+1−1

@@ -38,7 +38,7 @@ enum { · 37 unmodified lines
38		38
39	int TSS_authhmac(unsigned char digest, const unsigned char key,	39	int TSS_authhmac(unsigned char digest, const unsigned char key,
40	unsigned int keylen, unsigned char *h1,	40	unsigned int keylen, unsigned char *h1,
41	unsigned char *h2, unsigned char h3, ...);	41	unsigned char *h2, unsigned int h3, ...);
42	int TSS_checkhmac1(unsigned char *buffer,	42	int TSS_checkhmac1(unsigned char *buffer,
43	const uint32_t command,	43	const uint32_t command,
44	const unsigned char *ononce,	44	const unsigned char *ononce,

include/linux/bitrev.h+23−23

@@ -34,41 +34,41 @@ static inline u32 __bitrev32(u32 x) · 33 unmodified lines
34		34
35	#define __constant_bitrev32(x) \	35	#define __constant_bitrev32(x) \
36	({ \	36	({ \
37	u32 __x = x; \	37	u32 ___x = x; \
38	__x = (__x >> 16) \| (__x << 16); \	38	___x = (___x >> 16) \| (___x << 16); \
39	__x = ((__x & (u32)0xFF00FF00UL) >> 8) \| ((__x & (u32)0x00FF00FFUL) << 8); \	39	___x = ((___x & (u32)0xFF00FF00UL) >> 8) \| ((___x & (u32)0x00FF00FFUL) << 8); \
40	__x = ((__x & (u32)0xF0F0F0F0UL) >> 4) \| ((__x & (u32)0x0F0F0F0FUL) << 4); \	40	___x = ((___x & (u32)0xF0F0F0F0UL) >> 4) \| ((___x & (u32)0x0F0F0F0FUL) << 4); \
41	__x = ((__x & (u32)0xCCCCCCCCUL) >> 2) \| ((__x & (u32)0x33333333UL) << 2); \	41	___x = ((___x & (u32)0xCCCCCCCCUL) >> 2) \| ((___x & (u32)0x33333333UL) << 2); \
42	__x = ((__x & (u32)0xAAAAAAAAUL) >> 1) \| ((__x & (u32)0x55555555UL) << 1); \	42	___x = ((___x & (u32)0xAAAAAAAAUL) >> 1) \| ((___x & (u32)0x55555555UL) << 1); \
43	__x; \	43	___x; \
44	})	44	})
45		45
46	#define __constant_bitrev16(x) \	46	#define __constant_bitrev16(x) \
47	({ \	47	({ \
48	u16 __x = x; \	48	u16 ___x = x; \
49	__x = (__x >> 8) \| (__x << 8); \	49	___x = (___x >> 8) \| (___x << 8); \
50	__x = ((__x & (u16)0xF0F0U) >> 4) \| ((__x & (u16)0x0F0FU) << 4); \	50	___x = ((___x & (u16)0xF0F0U) >> 4) \| ((___x & (u16)0x0F0FU) << 4); \
51	__x = ((__x & (u16)0xCCCCU) >> 2) \| ((__x & (u16)0x3333U) << 2); \	51	___x = ((___x & (u16)0xCCCCU) >> 2) \| ((___x & (u16)0x3333U) << 2); \
52	__x = ((__x & (u16)0xAAAAU) >> 1) \| ((__x & (u16)0x5555U) << 1); \	52	___x = ((___x & (u16)0xAAAAU) >> 1) \| ((___x & (u16)0x5555U) << 1); \
53	__x; \	53	___x; \
54	})	54	})
55		55
56	#define __constant_bitrev8x4(x) \	56	#define __constant_bitrev8x4(x) \
57	({ \	57	({ \
58	u32 __x = x; \	58	u32 ___x = x; \
59	__x = ((__x & (u32)0xF0F0F0F0UL) >> 4) \| ((__x & (u32)0x0F0F0F0FUL) << 4); \	59	___x = ((___x & (u32)0xF0F0F0F0UL) >> 4) \| ((___x & (u32)0x0F0F0F0FUL) << 4); \
60	__x = ((__x & (u32)0xCCCCCCCCUL) >> 2) \| ((__x & (u32)0x33333333UL) << 2); \	60	___x = ((___x & (u32)0xCCCCCCCCUL) >> 2) \| ((___x & (u32)0x33333333UL) << 2); \
61	__x = ((__x & (u32)0xAAAAAAAAUL) >> 1) \| ((__x & (u32)0x55555555UL) << 1); \	61	___x = ((___x & (u32)0xAAAAAAAAUL) >> 1) \| ((___x & (u32)0x55555555UL) << 1); \
62	__x; \	62	___x; \
63	})	63	})
64		64
65	#define __constant_bitrev8(x) \	65	#define __constant_bitrev8(x) \
66	({ \	66	({ \
67	u8 __x = x; \	67	u8 ___x = x; \
68	__x = (__x >> 4) \| (__x << 4); \	68	___x = (___x >> 4) \| (___x << 4); \
69	__x = ((__x & (u8)0xCCU) >> 2) \| ((__x & (u8)0x33U) << 2); \	69	___x = ((___x & (u8)0xCCU) >> 2) \| ((___x & (u8)0x33U) << 2); \
70	__x = ((__x & (u8)0xAAU) >> 1) \| ((__x & (u8)0x55U) << 1); \	70	___x = ((___x & (u8)0xAAU) >> 1) \| ((___x & (u8)0x55U) << 1); \
71	__x; \	71	___x; \
72	})	72	})
73		73
74	#define bitrev32(x) \	74	#define bitrev32(x) \

include/linux/fs.h+4−0

 #define FMODE_OPENED		((__force fmode_t)0x80000)
 #define FMODE_CREATED		((__force fmode_t)0x100000)
+/* File is stream-like */
+#define FMODE_STREAM		((__force fmode_t)0x200000)
 /* File was opened by fanotify and shouldn't generate fanotify events */
 #define FMODE_NONOTIFY		((__force fmode_t)0x4000000)
 extern loff_t no_seek_end_llseek(struct file *, loff_t, int);
 extern int generic_file_open(struct inode * inode, struct file * filp);
 extern int nonseekable_open(struct inode * inode, struct file * filp);
+extern int stream_open(struct inode * inode, struct file * filp);
 #ifdef CONFIG_BLOCK
 typedef void (dio_submit_t)(struct bio *bio, struct inode *inode,

include/linux/memcontrol.h+4−1

 void __unlock_page_memcg(struct mem_cgroup *memcg);
 void unlock_page_memcg(struct page *page);
-/* idx can be of type enum memcg_stat_item or node_stat_item */
+/*
+ * idx can be of type enum memcg_stat_item or node_stat_item.
+ * Keep in sync with memcg_exact_page_state().
+ */
 static inline unsigned long memcg_page_state(struct mem_cgroup *memcg,
 					     int idx)
 {

include/linux/mm_types.h+1−1

@@ -671,7 +671,7 @@ enum vm_fault_reason { · 670 unmodified lines
671		671
672	/* Encode hstate index for a hwpoisoned large page */	672	/* Encode hstate index for a hwpoisoned large page */
673	#define VM_FAULT_SET_HINDEX(x) ((__force vm_fault_t)((x) << 16))	673	#define VM_FAULT_SET_HINDEX(x) ((__force vm_fault_t)((x) << 16))
674	#define VM_FAULT_GET_HINDEX(x) (((x) >> 16) & 0xf)	674	#define VM_FAULT_GET_HINDEX(x) (((__force unsigned int)(x) >> 16) & 0xf)
675		675
676	#define VM_FAULT_ERROR (VM_FAULT_OOM \| VM_FAULT_SIGBUS \| \	676	#define VM_FAULT_ERROR (VM_FAULT_OOM \| VM_FAULT_SIGBUS \| \
677	VM_FAULT_SIGSEGV \| VM_FAULT_HWPOISON \| \	677	VM_FAULT_SIGSEGV \| VM_FAULT_HWPOISON \| \

include/linux/ptrace.h+8−3

 #include <linux/bug.h>			/* For BUG_ON.  */
 #include <linux/pid_namespace.h>	/* For task_active_pid_ns.  */
 #include <uapi/linux/ptrace.h>
+#include <linux/seccomp.h>
+/* Add sp to seccomp_data, as seccomp is user API, we don't want to modify it */
+struct syscall_info {
+	__u64			sp;
+	struct seccomp_data	data;
+};
 extern int ptrace_access_vm(struct task_struct *tsk, unsigned long addr,
 			    void *buf, int len, unsigned int gup_flags);
 #define current_user_stack_pointer() user_stack_pointer(current_pt_regs())
 #endif
-extern int task_current_syscall(struct task_struct *target, long *callno,
+extern int task_current_syscall(struct task_struct *target, struct syscall_info *info);
-				unsigned long args[6], unsigned int maxargs,
-				unsigned long *sp, unsigned long *pc);
 extern void sigaction_compat_abi(struct k_sigaction *act, struct k_sigaction *oact);
 #endif

include/linux/string.h+3−0

 #ifndef __HAVE_ARCH_MEMCMP
 extern int memcmp(const void *,const void *,__kernel_size_t);
 #endif
+#ifndef __HAVE_ARCH_BCMP
+extern int bcmp(const void *,const void *,__kernel_size_t);
+#endif
 #ifndef __HAVE_ARCH_MEMCHR
 extern void * memchr(const void *,int,__kernel_size_t);
 #endif

include/net/nfc/nci_core.h+1−1

@@ -166,7 +166,7 @@ struct nci_conn_info { · 165 unmodified lines
166	* According to specification 102 622 chapter 4.4 Pipes,	166	* According to specification 102 622 chapter 4.4 Pipes,
167	* the pipe identifier is 7 bits long.	167	* the pipe identifier is 7 bits long.
168	*/	168	*/
169	#define NCI_HCI_MAX_PIPES 127	169	#define NCI_HCI_MAX_PIPES 128
170		170
171	struct nci_hci_gate {	171	struct nci_hci_gate {
172	u8 gate;	172	u8 gate;

include/trace/events/syscalls.h+1−1

@@ -28,7 +28,7 @@ TRACE_EVENT_FN(sys_enter, · 27 unmodified lines
28		28
29	TP_fast_assign(	29	TP_fast_assign(
30	__entry->id = id;	30	__entry->id = id;
31	syscall_get_arguments(current, regs, 0, 6, __entry->args);	31	syscall_get_arguments(current, regs, __entry->args);
32	),	32	),
33		33
34	TP_printk("NR %ld (%lx, %lx, %lx, %lx, %lx, %lx)",	34	TP_printk("NR %ld (%lx, %lx, %lx, %lx, %lx, %lx)",

include/uapi/linux/ethtool.h+1−1

@@ -1599,7 +1599,7 @@ enum ethtool_link_mode_bit_indices { · 1598 unmodified lines
1599		1599
1600	static inline int ethtool_validate_speed(__u32 speed)	1600	static inline int ethtool_validate_speed(__u32 speed)
1601	{	1601	{
1602	return speed <= INT_MAX \|\| speed == SPEED_UNKNOWN;	1602	return speed <= INT_MAX \|\| speed == (__u32)SPEED_UNKNOWN;
1603	}	1603	}
1604		1604
1605	/* Duplex, half or full. */	1605	/* Duplex, half or full. */

kernel/seccomp.c+1−1

@@ -149,7 +149,7 @@ static void populate_seccomp_data(struct seccomp_data *sd) · 148 unmodified lines
149		149
150	sd->nr = syscall_get_nr(task, regs);	150	sd->nr = syscall_get_nr(task, regs);
151	sd->arch = syscall_get_arch();	151	sd->arch = syscall_get_arch();
152	syscall_get_arguments(task, regs, 0, 6, args);	152	syscall_get_arguments(task, regs, args);
153	sd->args[0] = args[0];	153	sd->args[0] = args[0];
154	sd->args[1] = args[1];	154	sd->args[1] = args[1];
155	sd->args[2] = args[2];	155	sd->args[2] = args[2];

kernel/sysctl.c+2−1

 static int __maybe_unused one = 1;
 static int __maybe_unused two = 2;
 static int __maybe_unused four = 4;
+static unsigned long zero_ul;
 static unsigned long one_ul = 1;
 static unsigned long long_max = LONG_MAX;
 static int one_hundred = 100;
 		.maxlen		= sizeof(files_stat.max_files),
 		.mode		= 0644,
 		.proc_handler	= proc_doulongvec_minmax,
-		.extra1		= &zero,
+		.extra1		= &zero_ul,
 		.extra2		= &long_max,
 	},
 	{

kernel/trace/trace_syscalls.c+6−3

 	struct ring_buffer_event *event;
 	struct ring_buffer *buffer;
 	unsigned long irq_flags;
+	unsigned long args[6];
 	int pc;
 	int syscall_nr;
 	int size;
 	entry = ring_buffer_event_data(event);
 	entry->nr = syscall_nr;
-	syscall_get_arguments(current, regs, 0, sys_data->nb_args, entry->args);
+	syscall_get_arguments(current, regs, args);
+	memcpy(entry->args, args, sizeof(unsigned long) * sys_data->nb_args);
 	event_trigger_unlock_commit(trace_file, buffer, event, entry,
 				    irq_flags, pc);
 	struct syscall_metadata *sys_data;
 	struct syscall_trace_enter *rec;
 	struct hlist_head *head;
+	unsigned long args[6];
 	bool valid_prog_array;
 	int syscall_nr;
 	int rctx;
 		return;
 	rec->nr = syscall_nr;
-	syscall_get_arguments(current, regs, 0, sys_data->nb_args,
+	syscall_get_arguments(current, regs, args);
-			       (unsigned long *)&rec->args);
+	memcpy(&rec->args, args, sizeof(unsigned long) * sys_data->nb_args);
 	if ((valid_prog_array &&
 	     !perf_call_bpf_enter(sys_data->enter_event, regs, sys_data, rec)) ||

lib/lzo/lzo1x_compress.c+6−3

 {
 	const unsigned char *ip = in;
 	unsigned char *op = out;
+	unsigned char *data_start;
 	size_t l = in_len;
 	size_t t = 0;
 	signed char state_offset = -2;
 	unsigned int m4_max_offset;
-	// LZO v0 will never write 17 as first byte,
+	// LZO v0 will never write 17 as first byte (except for zero-length
-	// so this is used to version the bitstream
+	// input), so this is used to version the bitstream
 	if (bitstream_version > 0) {
 		*op++ = 17;
 		*op++ = bitstream_version;
 		m4_max_offset = M4_MAX_OFFSET_V0;
 	}
+	data_start = op;
 	while (l > 20) {
 		size_t ll = l <= (m4_max_offset + 1) ? l : (m4_max_offset + 1);
 		uintptr_t ll_end = (uintptr_t) ip + ll;
 	if (t > 0) {
 		const unsigned char *ii = in + in_len - t;
-		if (op == out && t <= 238) {
+		if (op == data_start && t <= 238) {
 			*op++ = (17 + t);
 		} else if (t <= 3) {
 			op[state_offset] |= t;

lib/lzo/lzo1x_decompress_safe.c+1−3

 	if (unlikely(in_len < 3))
 		goto input_overrun;
-	if (likely(*ip == 17)) {
+	if (likely(in_len >= 5) && likely(*ip == 17)) {
 		bitstream_version = ip[1];
 		ip += 2;
-		if (unlikely(in_len < 5))
-			goto input_overrun;
 	} else {
 		bitstream_version = 0;
 	}

lib/string.c+20−0

@@ -866,6 +866,26 @@ __visible int memcmp(const void cs, const void ct, size_t count) · 865 unmodified lines
866	EXPORT_SYMBOL(memcmp);	866	EXPORT_SYMBOL(memcmp);
867	#endif	867	#endif
868		868
		869	#ifndef __HAVE_ARCH_BCMP
		870	/**
		871	* bcmp - returns 0 if and only if the buffers have identical contents.
		872	* @a: pointer to first buffer.
		873	* @b: pointer to second buffer.
		874	* @len: size of buffers.
		875	*
		876	* The sign or magnitude of a non-zero return value has no particular
		877	* meaning, and architectures may implement their own more efficient bcmp(). So
		878	* while this particular implementation is a simple (tail) call to memcmp, do
		879	* not rely on anything but whether the return value is zero or non-zero.
		880	*/
		881	#undef bcmp
		882	int bcmp(const void a, const void b, size_t len)
		883	{
		884	return memcmp(a, b, len);
		885	}
		886	EXPORT_SYMBOL(bcmp);
		887	#endif
		888
869	#ifndef __HAVE_ARCH_MEMSCAN	889	#ifndef __HAVE_ARCH_MEMSCAN
870	/**	890	/**
871	* memscan - Find a character in an area of memory.	891	* memscan - Find a character in an area of memory.

lib/syscall.c+25−32

 #include <linux/export.h>
 #include <asm/syscall.h>
-static int collect_syscall(struct task_struct *target, long *callno,
+static int collect_syscall(struct task_struct *target, struct syscall_info *info)
-			   unsigned long args[6], unsigned int maxargs,
-			   unsigned long *sp, unsigned long *pc)
 {
 	struct pt_regs *regs;
 	if (!try_get_task_stack(target)) {
 		/* Task has no stack, so the task isn't in a syscall. */
-		*sp = *pc = 0;
+		memset(info, 0, sizeof(*info));
-		*callno = -1;
+		info->data.nr = -1;
 		return 0;
 	}
 		return -EAGAIN;
 	}
-	*sp = user_stack_pointer(regs);
+	info->sp = user_stack_pointer(regs);
-	*pc = instruction_pointer(regs);
+	info->data.instruction_pointer = instruction_pointer(regs);
-	*callno = syscall_get_nr(target, regs);
+	info->data.nr = syscall_get_nr(target, regs);
-	if (*callno != -1L && maxargs > 0)
+	if (info->data.nr != -1L)
-		syscall_get_arguments(target, regs, 0, maxargs, args);
+		syscall_get_arguments(target, regs,
+				      (unsigned long *)&info->data.args[0]);
 	put_task_stack(target);
 	return 0;
 /**
  * task_current_syscall - Discover what a blocked task is doing.
  * @target:		thread to examine
- * @callno:		filled with system call number or -1
+ * @info:		structure with the following fields:
- * @args:		filled with @maxargs system call arguments
+ *			 .sp        - filled with user stack pointer
- * @maxargs:		number of elements in @args to fill
+ *			 .data.nr   - filled with system call number or -1
- * @sp:			filled with user stack pointer
+ *			 .data.args - filled with @maxargs system call arguments
- * @pc:			filled with user PC
+ *			 .data.instruction_pointer - filled with user PC
  *
- * If @target is blocked in a system call, returns zero with *@callno
+ * If @target is blocked in a system call, returns zero with @info.data.nr
- * set to the the call's number and @args filled in with its arguments.
+ * set to the the call's number and @info.data.args filled in with its
- * Registers not used for system call arguments may not be available and
+ * arguments. Registers not used for system call arguments may not be available
- * it is not kosher to use &struct user_regset calls while the system
+ * and it is not kosher to use &struct user_regset calls while the system
  * call is still in progress.  Note we may get this result if @target
  * has finished its system call but not yet returned to user mode, such
  * as when it's stopped for signal handling or syscall exit tracing.
  *
  * If @target is blocked in the kernel during a fault or exception,
- * returns zero with *@callno set to -1 and does not fill in @args.
+ * returns zero with *@info.data.nr set to -1 and does not fill in
- * If so, it's now safe to examine @target using &struct user_regset
+ * @info.data.args. If so, it's now safe to examine @target using
- * get() calls as long as we're sure @target won't return to user mode.
+ * &struct user_regset get() calls as long as we're sure @target won't return
+ * to user mode.
  *
  * Returns -%EAGAIN if @target does not remain blocked.
- *
- * Returns -%EINVAL if @maxargs is too large (maximum is six).
  */
-int task_current_syscall(struct task_struct *target, long *callno,
+int task_current_syscall(struct task_struct *target, struct syscall_info *info)
-			 unsigned long args[6], unsigned int maxargs,
-			 unsigned long *sp, unsigned long *pc)
 {
 	long state;
 	unsigned long ncsw;
-	if (unlikely(maxargs > 6))
-		return -EINVAL;
 	if (target == current)
-		return collect_syscall(target, callno, args, maxargs, sp, pc);
+		return collect_syscall(target, info);
 	state = target->state;
 	if (unlikely(!state))
 	ncsw = wait_task_inactive(target, state);
 	if (unlikely(!ncsw) ||
-	    unlikely(collect_syscall(target, callno, args, maxargs, sp, pc)) ||
+	    unlikely(collect_syscall(target, info)) ||
 	    unlikely(wait_task_inactive(target, state) != ncsw))
 		return -EAGAIN;

mm/huge_memory.c+36−0

@@ -755,6 +755,21 @@ static void insert_pfn_pmd(struct vm_area_struct *vma, unsigned long addr, · 754 unmodified lines
755	spinlock_t *ptl;	755	spinlock_t *ptl;
756		756
757	ptl = pmd_lock(mm, pmd);	757	ptl = pmd_lock(mm, pmd);
		758	if (!pmd_none(*pmd)) {
		759	if (write) {
		760	if (pmd_pfn(*pmd) != pfn_t_to_pfn(pfn)) {
		761	WARN_ON_ONCE(!is_huge_zero_pmd(*pmd));
		762	goto out_unlock;
		763	}
		764	entry = pmd_mkyoung(*pmd);
		765	entry = maybe_pmd_mkwrite(pmd_mkdirty(entry), vma);
		766	if (pmdp_set_access_flags(vma, addr, pmd, entry, 1))
		767	update_mmu_cache_pmd(vma, addr, pmd);
		768	}
		769
		770	goto out_unlock;
		771	}
		772
758	entry = pmd_mkhuge(pfn_t_pmd(pfn, prot));	773	entry = pmd_mkhuge(pfn_t_pmd(pfn, prot));
759	if (pfn_t_devmap(pfn))	774	if (pfn_t_devmap(pfn))
760	entry = pmd_mkdevmap(entry);	775	entry = pmd_mkdevmap(entry);
@@ -766,11 +781,16 @@ static void insert_pfn_pmd(struct vm_area_struct *vma, unsigned long addr, · 5 unmodified lines
766	if (pgtable) {	781	if (pgtable) {
767	pgtable_trans_huge_deposit(mm, pmd, pgtable);	782	pgtable_trans_huge_deposit(mm, pmd, pgtable);
768	mm_inc_nr_ptes(mm);	783	mm_inc_nr_ptes(mm);
		784	pgtable = NULL;
769	}	785	}
770		786
771	set_pmd_at(mm, addr, pmd, entry);	787	set_pmd_at(mm, addr, pmd, entry);
772	update_mmu_cache_pmd(vma, addr, pmd);	788	update_mmu_cache_pmd(vma, addr, pmd);
		789
		790	out_unlock:
773	spin_unlock(ptl);	791	spin_unlock(ptl);
		792	if (pgtable)
		793	pte_free(mm, pgtable);
774	}	794	}
775		795
776	vm_fault_t vmf_insert_pfn_pmd(struct vm_area_struct *vma, unsigned long addr,	796	vm_fault_t vmf_insert_pfn_pmd(struct vm_area_struct *vma, unsigned long addr,
@@ -821,6 +841,20 @@ static void insert_pfn_pud(struct vm_area_struct *vma, unsigned long addr, · 44 unmodified lines
821	spinlock_t *ptl;	841	spinlock_t *ptl;
822		842
823	ptl = pud_lock(mm, pud);	843	ptl = pud_lock(mm, pud);
		844	if (!pud_none(*pud)) {
		845	if (write) {
		846	if (pud_pfn(*pud) != pfn_t_to_pfn(pfn)) {
		847	WARN_ON_ONCE(!is_huge_zero_pud(*pud));
		848	goto out_unlock;
		849	}
		850	entry = pud_mkyoung(*pud);
		851	entry = maybe_pud_mkwrite(pud_mkdirty(entry), vma);
		852	if (pudp_set_access_flags(vma, addr, pud, entry, 1))
		853	update_mmu_cache_pud(vma, addr, pud);
		854	}
		855	goto out_unlock;
		856	}
		857
824	entry = pud_mkhuge(pfn_t_pud(pfn, prot));	858	entry = pud_mkhuge(pfn_t_pud(pfn, prot));
825	if (pfn_t_devmap(pfn))	859	if (pfn_t_devmap(pfn))
826	entry = pud_mkdevmap(entry);	860	entry = pud_mkdevmap(entry);
@@ -830,6 +864,8 @@ static void insert_pfn_pud(struct vm_area_struct *vma, unsigned long addr, · 3 unmodified lines
830	}	864	}
831	set_pud_at(mm, addr, pud, entry);	865	set_pud_at(mm, addr, pud, entry);
832	update_mmu_cache_pud(vma, addr, pud);	866	update_mmu_cache_pud(vma, addr, pud);
		867
		868	out_unlock:
833	spin_unlock(ptl);	869	spin_unlock(ptl);
834	}	870	}
835		871

mm/kmemleak.c+11−5

 	}
 	rcu_read_unlock();
-	/* data/bss scanning */
-	scan_large_block(_sdata, _edata);
-	scan_large_block(__bss_start, __bss_stop);
-	scan_large_block(__start_ro_after_init, __end_ro_after_init);
 #ifdef CONFIG_SMP
 	/* per-cpu sections scanning */
 	for_each_possible_cpu(i)
 	}
 	local_irq_restore(flags);
+	/* register the data/bss sections */
+	create_object((unsigned long)_sdata, _edata - _sdata,
+		      KMEMLEAK_GREY, GFP_ATOMIC);
+	create_object((unsigned long)__bss_start, __bss_stop - __bss_start,
+		      KMEMLEAK_GREY, GFP_ATOMIC);
+	/* only register .data..ro_after_init if not within .data */
+	if (__start_ro_after_init < _sdata || __end_ro_after_init > _edata)
+		create_object((unsigned long)__start_ro_after_init,
+			      __end_ro_after_init - __start_ro_after_init,
+			      KMEMLEAK_GREY, GFP_ATOMIC);
 	/*
 	 * This is the point where tracking allocations is safe. Automatic
 	 * scanning is started during the late initcall. Add the early logged

mm/memcontrol.c+18−2

 	return &memcg->cgwb_domain;
 }
+/*
+ * idx can be of type enum memcg_stat_item or node_stat_item.
+ * Keep in sync with memcg_exact_page().
+ */
+static unsigned long memcg_exact_page_state(struct mem_cgroup *memcg, int idx)
+{
+	long x = atomic_long_read(&memcg->stat[idx]);
+	int cpu;
+	for_each_online_cpu(cpu)
+		x += per_cpu_ptr(memcg->stat_cpu, cpu)->count[idx];
+	if (x < 0)
+		x = 0;
+	return x;
+}
 /**
  * mem_cgroup_wb_stats - retrieve writeback related stats from its memcg
  * @wb: bdi_writeback in question
 	struct mem_cgroup *memcg = mem_cgroup_from_css(wb->memcg_css);
 	struct mem_cgroup *parent;
-	*pdirty = memcg_page_state(memcg, NR_FILE_DIRTY);
+	*pdirty = memcg_exact_page_state(memcg, NR_FILE_DIRTY);
 	/* this should eventually include NR_UNSTABLE_NFS */
-	*pwriteback = memcg_page_state(memcg, NR_WRITEBACK);
+	*pwriteback = memcg_exact_page_state(memcg, NR_WRITEBACK);
 	*pfilepages = mem_cgroup_nr_lru_pages(memcg, (1 << LRU_INACTIVE_FILE) |
 						     (1 << LRU_ACTIVE_FILE));
 	*pheadroom = PAGE_COUNTER_MAX;

mm/slab.c+2−1

@@ -4308,7 +4308,8 @@ static void show_symbol(struct seq_file *m, unsigned long address) · 4307 unmodified lines
4308		4308
4309	static int leaks_show(struct seq_file m, void p)	4309	static int leaks_show(struct seq_file m, void p)
4310	{	4310	{
4311	struct kmem_cache *cachep = list_entry(p, struct kmem_cache, list);	4311	struct kmem_cache *cachep = list_entry(p, struct kmem_cache,
		4312	root_caches_node);
4312	struct page *page;	4313	struct page *page;
4313	struct kmem_cache_node *n;	4314	struct kmem_cache_node *n;
4314	const char *name;	4315	const char *name;

mm/util.c+1−1

@@ -204,7 +204,7 @@ EXPORT_SYMBOL(vmemdup_user); · 203 unmodified lines
204	* @s: The string to duplicate	204	* @s: The string to duplicate
205	* @n: Maximum number of bytes to copy, including the trailing NUL.	205	* @n: Maximum number of bytes to copy, including the trailing NUL.
206	*	206	*
207	* Return: newly allocated copy of @s or %NULL in case of error	207	* Return: newly allocated copy of @s or an ERR_PTR() in case of error
208	*/	208	*/
209	char strndup_user(const char __user s, long n)	209	char strndup_user(const char __user s, long n)
210	{	210	{

net/ipv4/ip_gre.c+10−5

 	struct net *net = dev_net(skb->dev);
 	struct metadata_dst *tun_dst = NULL;
 	struct erspan_base_hdr *ershdr;
-	struct erspan_metadata *pkt_md;
 	struct ip_tunnel_net *itn;
 	struct ip_tunnel *tunnel;
 	const struct iphdr *iph;
 		if (unlikely(!pskb_may_pull(skb, len)))
 			return PACKET_REJECT;
-		ershdr = (struct erspan_base_hdr *)(skb->data + gre_hdr_len);
-		pkt_md = (struct erspan_metadata *)(ershdr + 1);
 		if (__iptunnel_pull_header(skb,
 					   len,
 					   htons(ETH_P_TEB),
 			goto drop;
 		if (tunnel->collect_md) {
+			struct erspan_metadata *pkt_md, *md;
 			struct ip_tunnel_info *info;
-			struct erspan_metadata *md;
+			unsigned char *gh;
 			__be64 tun_id;
 			__be16 flags;
 			if (!tun_dst)
 				return PACKET_REJECT;
+			/* skb can be uncloned in __iptunnel_pull_header, so
+			 * old pkt_md is no longer valid and we need to reset
+			 * it
+			 */
+			gh = skb_network_header(skb) +
+			     skb_network_header_len(skb);
+			pkt_md = (struct erspan_metadata *)(gh + gre_hdr_len +
+							    sizeof(*ershdr));
 			md = ip_tunnel_info_opts(&tun_dst->u.tun_info);
 			md->version = ver;
 			md2 = &md->u.md2;

net/ipv6/ip6_gre.c+13−7

 }
 static int ip6erspan_rcv(struct sk_buff *skb,
-			 struct tnl_ptk_info *tpi)
+			 struct tnl_ptk_info *tpi,
+			 int gre_hdr_len)
 {
 	struct erspan_base_hdr *ershdr;
-	struct erspan_metadata *pkt_md;
 	const struct ipv6hdr *ipv6h;
 	struct erspan_md2 *md2;
 	struct ip6_tnl *tunnel;
 		if (unlikely(!pskb_may_pull(skb, len)))
 			return PACKET_REJECT;
-		ershdr = (struct erspan_base_hdr *)skb->data;
-		pkt_md = (struct erspan_metadata *)(ershdr + 1);
 		if (__iptunnel_pull_header(skb, len,
 					   htons(ETH_P_TEB),
 					   false, false) < 0)
 			return PACKET_REJECT;
 		if (tunnel->parms.collect_md) {
+			struct erspan_metadata *pkt_md, *md;
 			struct metadata_dst *tun_dst;
 			struct ip_tunnel_info *info;
-			struct erspan_metadata *md;
+			unsigned char *gh;
 			__be64 tun_id;
 			__be16 flags;
 			if (!tun_dst)
 				return PACKET_REJECT;
+			/* skb can be uncloned in __iptunnel_pull_header, so
+			 * old pkt_md is no longer valid and we need to reset
+			 * it
+			 */
+			gh = skb_network_header(skb) +
+			     skb_network_header_len(skb);
+			pkt_md = (struct erspan_metadata *)(gh + gre_hdr_len +
+							    sizeof(*ershdr));
 			info = &tun_dst->u.tun_info;
 			md = ip_tunnel_info_opts(info);
 			md->version = ver;
 	if (unlikely(tpi.proto == htons(ETH_P_ERSPAN) ||
 		     tpi.proto == htons(ETH_P_ERSPAN2))) {
-		if (ip6erspan_rcv(skb, &tpi) == PACKET_RCVD)
+		if (ip6erspan_rcv(skb, &tpi, hdr_len) == PACKET_RCVD)
 			return 0;
 		goto out;
 	}

net/nfc/nci/hci.c+8−0

 		create_info = (struct nci_hci_create_pipe_resp *)skb->data;
 		dest_gate = create_info->dest_gate;
 		new_pipe = create_info->pipe;
+		if (new_pipe >= NCI_HCI_MAX_PIPES) {
+			status = NCI_HCI_ANY_E_NOK;
+			goto exit;
+		}
 		/* Save the new created pipe and bind with local gate,
 		 * the description for skb->data[3] is destination gate id
 			goto exit;
 		}
 		delete_info = (struct nci_hci_delete_pipe_noti *)skb->data;
+		if (delete_info->pipe >= NCI_HCI_MAX_PIPES) {
+			status = NCI_HCI_ANY_E_NOK;
+			goto exit;
+		}
 		ndev->hci_dev->pipes[delete_info->pipe].gate =
 						NCI_HCI_INVALID_GATE;

scripts/coccinelle/api/stream_open.cocci+363−0

@@ -0,0 +1,363 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	// Author: Kirill Smelkov (kirr@nexedi.com)
	3	//
	4	// Search for stream-like files that are using nonseekable_open and convert
	5	// them to stream_open. A stream-like file is a file that does not use ppos in
	6	// its read and write. Rationale for the conversion is to avoid deadlock in
	7	// between read and write.
	8
	9	virtual report
	10	virtual patch
	11	virtual explain // explain decisions in the patch (SPFLAGS="-D explain")
	12
	13	// stream-like reader & writer - ones that do not depend on f_pos.
	14	@ stream_reader @
	15	identifier readstream, ppos;
	16	identifier f, buf, len;
	17	type loff_t;
	18	@@
	19	ssize_t readstream(struct file f, char buf, size_t len, loff_t *ppos)
	20	{
	21	... when != ppos
	22	}
	23
	24	@ stream_writer @
	25	identifier writestream, ppos;
	26	identifier f, buf, len;
	27	type loff_t;
	28	@@
	29	ssize_t writestream(struct file f, const char buf, size_t len, loff_t *ppos)
	30	{
	31	... when != ppos
	32	}
	33
	34
	35	// a function that blocks
	36	@ blocks @
	37	identifier block_f;
	38	identifier wait_event =~ "^wait_event_.*";
	39	@@
	40	block_f(...) {
	41	... when exists
	42	wait_event(...)
	43	... when exists
	44	}
	45
	46	// stream_reader that can block inside.
	47	//
	48	// XXX wait_* can be called not directly from current function (e.g. func -> f -> g -> wait())
	49	// XXX currently reader_blocks supports only direct and 1-level indirect cases.
	50	@ reader_blocks_direct @
	51	identifier stream_reader.readstream;
	52	identifier wait_event =~ "^wait_event_.*";
	53	@@
	54	readstream(...)
	55	{
	56	... when exists
	57	wait_event(...)
	58	... when exists
	59	}
	60
	61	@ reader_blocks_1 @
	62	identifier stream_reader.readstream;
	63	identifier blocks.block_f;
	64	@@
	65	readstream(...)
	66	{
	67	... when exists
	68	block_f(...)
	69	... when exists
	70	}
	71
	72	@ reader_blocks depends on reader_blocks_direct \|\| reader_blocks_1 @
	73	identifier stream_reader.readstream;
	74	@@
	75	readstream(...) {
	76	...
	77	}
	78
	79
	80	// file_operations + whether they have _any_ .read, .write, .llseek ... at all.
	81	//
	82	// XXX add support for file_operations xxx[N] = ... (sound/core/pcm_native.c)
	83	@ fops0 @
	84	identifier fops;
	85	@@
	86	struct file_operations fops = {
	87	...
	88	};
	89
	90	@ has_read @
	91	identifier fops0.fops;
	92	identifier read_f;
	93	@@
	94	struct file_operations fops = {
	95	.read = read_f,
	96	};
	97
	98	@ has_read_iter @
	99	identifier fops0.fops;
	100	identifier read_iter_f;
	101	@@
	102	struct file_operations fops = {
	103	.read_iter = read_iter_f,
	104	};
	105
	106	@ has_write @
	107	identifier fops0.fops;
	108	identifier write_f;
	109	@@
	110	struct file_operations fops = {
	111	.write = write_f,
	112	};
	113
	114	@ has_write_iter @
	115	identifier fops0.fops;
	116	identifier write_iter_f;
	117	@@
	118	struct file_operations fops = {
	119	.write_iter = write_iter_f,
	120	};
	121
	122	@ has_llseek @
	123	identifier fops0.fops;
	124	identifier llseek_f;
	125	@@
	126	struct file_operations fops = {
	127	.llseek = llseek_f,
	128	};
	129
	130	@ has_no_llseek @
	131	identifier fops0.fops;
	132	@@
	133	struct file_operations fops = {
	134	.llseek = no_llseek,
	135	};
	136
	137	@ has_mmap @
	138	identifier fops0.fops;
	139	identifier mmap_f;
	140	@@
	141	struct file_operations fops = {
	142	.mmap = mmap_f,
	143	};
	144
	145	@ has_copy_file_range @
	146	identifier fops0.fops;
	147	identifier copy_file_range_f;
	148	@@
	149	struct file_operations fops = {
	150	.copy_file_range = copy_file_range_f,
	151	};
	152
	153	@ has_remap_file_range @
	154	identifier fops0.fops;
	155	identifier remap_file_range_f;
	156	@@
	157	struct file_operations fops = {
	158	.remap_file_range = remap_file_range_f,
	159	};
	160
	161	@ has_splice_read @
	162	identifier fops0.fops;
	163	identifier splice_read_f;
	164	@@
	165	struct file_operations fops = {
	166	.splice_read = splice_read_f,
	167	};
	168
	169	@ has_splice_write @
	170	identifier fops0.fops;
	171	identifier splice_write_f;
	172	@@
	173	struct file_operations fops = {
	174	.splice_write = splice_write_f,
	175	};
	176
	177
	178	// file_operations that is candidate for stream_open conversion - it does not
	179	// use mmap and other methods that assume @offset access to file.
	180	//
	181	// XXX for simplicity require no .{read/write}_iter and no .splice_{read/write} for now.
	182	// XXX maybe_steam.fops cannot be used in other rules - it gives "bad rule maybe_stream or bad variable fops".
	183	@ maybe_stream depends on (!has_llseek \|\| has_no_llseek) && !has_mmap && !has_copy_file_range && !has_remap_file_range && !has_read_iter && !has_write_iter && !has_splice_read && !has_splice_write @
	184	identifier fops0.fops;
	185	@@
	186	struct file_operations fops = {
	187	};
	188
	189
	190	// ---- conversions ----
	191
	192	// XXX .open = nonseekable_open -> .open = stream_open
	193	// XXX .open = func -> openfunc -> nonseekable_open
	194
	195	// read & write
	196	//
	197	// if both are used in the same file_operations together with an opener -
	198	// under that conditions we can use stream_open instead of nonseekable_open.
	199	@ fops_rw depends on maybe_stream @
	200	identifier fops0.fops, openfunc;
	201	identifier stream_reader.readstream;
	202	identifier stream_writer.writestream;
	203	@@
	204	struct file_operations fops = {
	205	.open = openfunc,
	206	.read = readstream,
	207	.write = writestream,
	208	};
	209
	210	@ report_rw depends on report @
	211	identifier fops_rw.openfunc;
	212	position p1;
	213	@@
	214	openfunc(...) {
	215	<...
	216	nonseekable_open@p1
	217	...>
	218	}
	219
	220	@ script:python depends on report && reader_blocks @
	221	fops << fops0.fops;
	222	p << report_rw.p1;
	223	@@
	224	coccilib.report.print_report(p[0],
	225	"ERROR: %s: .read() can deadlock .write(); change nonseekable_open -> stream_open to fix." % (fops,))
	226
	227	@ script:python depends on report && !reader_blocks @
	228	fops << fops0.fops;
	229	p << report_rw.p1;
	230	@@
	231	coccilib.report.print_report(p[0],
	232	"WARNING: %s: .read() and .write() have stream semantic; safe to change nonseekable_open -> stream_open." % (fops,))
	233
	234
	235	@ explain_rw_deadlocked depends on explain && reader_blocks @
	236	identifier fops_rw.openfunc;
	237	@@
	238	openfunc(...) {
	239	<...
	240	- nonseekable_open
	241	+ nonseekable_open /* read & write (was deadlock) */
	242	...>
	243	}
	244
	245
	246	@ explain_rw_nodeadlock depends on explain && !reader_blocks @
	247	identifier fops_rw.openfunc;
	248	@@
	249	openfunc(...) {
	250	<...
	251	- nonseekable_open
	252	+ nonseekable_open /* read & write (no direct deadlock) */
	253	...>
	254	}
	255
	256	@ patch_rw depends on patch @
	257	identifier fops_rw.openfunc;
	258	@@
	259	openfunc(...) {
	260	<...
	261	- nonseekable_open
	262	+ stream_open
	263	...>
	264	}
	265
	266
	267	// read, but not write
	268	@ fops_r depends on maybe_stream && !has_write @
	269	identifier fops0.fops, openfunc;
	270	identifier stream_reader.readstream;
	271	@@
	272	struct file_operations fops = {
	273	.open = openfunc,
	274	.read = readstream,
	275	};
	276
	277	@ report_r depends on report @
	278	identifier fops_r.openfunc;
	279	position p1;
	280	@@
	281	openfunc(...) {
	282	<...
	283	nonseekable_open@p1
	284	...>
	285	}
	286
	287	@ script:python depends on report @
	288	fops << fops0.fops;
	289	p << report_r.p1;
	290	@@
	291	coccilib.report.print_report(p[0],
	292	"WARNING: %s: .read() has stream semantic; safe to change nonseekable_open -> stream_open." % (fops,))
	293
	294	@ explain_r depends on explain @
	295	identifier fops_r.openfunc;
	296	@@
	297	openfunc(...) {
	298	<...
	299	- nonseekable_open
	300	+ nonseekable_open /* read only */
	301	...>
	302	}
	303
	304	@ patch_r depends on patch @
	305	identifier fops_r.openfunc;
	306	@@
	307	openfunc(...) {
	308	<...
	309	- nonseekable_open
	310	+ stream_open
	311	...>
	312	}
	313
	314
	315	// write, but not read
	316	@ fops_w depends on maybe_stream && !has_read @
	317	identifier fops0.fops, openfunc;
	318	identifier stream_writer.writestream;
	319	@@
	320	struct file_operations fops = {
	321	.open = openfunc,
	322	.write = writestream,
	323	};
	324
	325	@ report_w depends on report @
	326	identifier fops_w.openfunc;
	327	position p1;
	328	@@
	329	openfunc(...) {
	330	<...
	331	nonseekable_open@p1
	332	...>
	333	}
	334
	335	@ script:python depends on report @
	336	fops << fops0.fops;
	337	p << report_w.p1;
	338	@@
	339	coccilib.report.print_report(p[0],
	340	"WARNING: %s: .write() has stream semantic; safe to change nonseekable_open -> stream_open." % (fops,))
	341
	342	@ explain_w depends on explain @
	343	identifier fops_w.openfunc;
	344	@@
	345	openfunc(...) {
	346	<...
	347	- nonseekable_open
	348	+ nonseekable_open /* write only */
	349	...>
	350	}
	351
	352	@ patch_w depends on patch @
	353	identifier fops_w.openfunc;
	354	@@
	355	openfunc(...) {
	356	<...
	357	- nonseekable_open
	358	+ stream_open
	359	...>
	360	}
	361
	362
	363	// no read, no write - don't change anything

security/keys/trusted.c+25−7

  */
 int TSS_authhmac(unsigned char *digest, const unsigned char *key,
 			unsigned int keylen, unsigned char *h1,
-			unsigned char *h2, unsigned char h3, ...)
+			unsigned char *h2, unsigned int h3, ...)
 {
 	unsigned char paramdigest[SHA1_DIGEST_SIZE];
 	struct sdesc *sdesc;
 	int ret;
 	va_list argp;
+	if (!chip)
+		return -ENODEV;
 	sdesc = init_sdesc(hashalg);
 	if (IS_ERR(sdesc)) {
 		pr_info("trusted_key: can't alloc %s\n", hash_alg);
 		return PTR_ERR(sdesc);
 	}
-	c = h3;
+	c = !!h3;
 	ret = crypto_shash_init(&sdesc->shash);
 	if (ret < 0)
 		goto out;
 	va_list argp;
 	int ret;
+	if (!chip)
+		return -ENODEV;
 	bufsize = LOAD32(buffer, TPM_SIZE_OFFSET);
 	tag = LOAD16(buffer, 0);
 	ordinal = command;
 {
 	int rc;
+	if (!chip)
+		return -ENODEV;
 	dump_tpm_buf(cmd);
 	rc = tpm_send(chip, cmd, buflen);
 	dump_tpm_buf(cmd);
 {
 	int ret;
+	if (!chip)
+		return -ENODEV;
 	INIT_BUF(tb);
 	store16(tb, TPM_TAG_RQU_COMMAND);
 	store32(tb, TPM_OIAP_SIZE);
 {
 	int ret;
+	/* encrypted_keys.ko depends on successful load of this module even if
+	 * TPM is not used.
+	 */
 	chip = tpm_default_chip();
 	if (!chip)
-		return -ENOENT;
+		return 0;
 	ret = init_digests();
 	if (ret < 0)
 		goto err_put;
 static void __exit cleanup_trusted(void)
 {
-	put_device(&chip->dev);
+	if (chip) {
-	kfree(digests);
+		put_device(&chip->dev);
-	trusted_shash_release();
+		kfree(digests);
-	unregister_key_type(&key_type_trusted);
+		trusted_shash_release();
+		unregister_key_type(&key_type_trusted);
+	}
 }
 late_initcall(init_trusted);

tools/testing/selftests/tc-testing/tc-tests/filters/tests.json+20−0

@@ -18,6 +18,26 @@ · 17 unmodified lines
18	"$TC qdisc del dev $DEV1 ingress"	18	"$TC qdisc del dev $DEV1 ingress"
19	]	19	]
20	},	20	},
		21	{
		22	"id": "2638",
		23	"name": "Add matchall and try to get it",
		24	"category": [
		25	"filter",
		26	"matchall"
		27	],
		28	"setup": [
		29	"$TC qdisc add dev $DEV1 clsact",
		30	"$TC filter add dev $DEV1 protocol all pref 1 ingress handle 0x1234 matchall action ok"
		31	],
		32	"cmdUnderTest": "$TC filter get dev $DEV1 protocol all pref 1 ingress handle 0x1234 matchall",
		33	"expExitCode": "0",
		34	"verifyCmd": "$TC filter show dev $DEV1 ingress",
		35	"matchPattern": "filter protocol all pref 1 matchall chain 0 handle 0x1234",
		36	"matchCount": "1",
		37	"teardown": [
		38	"$TC qdisc del dev $DEV1 clsact"
		39	]
		40	},
21	{	41	{
22	"id": "d052",	42	"id": "d052",
23	"name": "Add 1M filters with the same action",	43	"name": "Add 1M filters with the same action",

tools/testing/selftests/tpm2/tpm2.py+3−2

 TPM2_CC_FLUSH_CONTEXT = 0x0165
 TPM2_CC_START_AUTH_SESSION = 0x0176
 TPM2_CC_GET_CAPABILITY	= 0x017A
+TPM2_CC_GET_RANDOM = 0x017B
 TPM2_CC_PCR_READ = 0x017E
 TPM2_CC_POLICY_PCR = 0x017F
 TPM2_CC_PCR_EXTEND = 0x0182
         self.flags = flags
         if (self.flags & Client.FLAG_SPACE) == 0:
-            self.tpm = open('/dev/tpm0', 'r+b')
+            self.tpm = open('/dev/tpm0', 'r+b', buffering=0)
         else:
-            self.tpm = open('/dev/tpmrm0', 'r+b')
+            self.tpm = open('/dev/tpmrm0', 'r+b', buffering=0)
     def close(self):
         self.tpm.close()

tools/testing/selftests/tpm2/tpm2_tests.py+63−0

@@ -158,6 +158,69 @@ class SmokeTest(unittest.TestCase): · 157 unmodified lines
158	pass	158	pass
159	self.assertEqual(rejected, True)	159	self.assertEqual(rejected, True)
160		160
		161	def test_read_partial_resp(self):
		162	try:
		163	fmt = '>HIIH'
		164	cmd = struct.pack(fmt,
		165	tpm2.TPM2_ST_NO_SESSIONS,
		166	struct.calcsize(fmt),
		167	tpm2.TPM2_CC_GET_RANDOM,
		168	0x20)
		169	self.client.tpm.write(cmd)
		170	hdr = self.client.tpm.read(10)
		171	sz = struct.unpack('>I', hdr[2:6])[0]
		172	rsp = self.client.tpm.read()
		173	except:
		174	pass
		175	self.assertEqual(sz, 10 + 2 + 32)
		176	self.assertEqual(len(rsp), 2 + 32)
		177
		178	def test_read_partial_overwrite(self):
		179	try:
		180	fmt = '>HIIH'
		181	cmd = struct.pack(fmt,
		182	tpm2.TPM2_ST_NO_SESSIONS,
		183	struct.calcsize(fmt),
		184	tpm2.TPM2_CC_GET_RANDOM,
		185	0x20)
		186	self.client.tpm.write(cmd)
		187	# Read part of the respone
		188	rsp1 = self.client.tpm.read(15)
		189
		190	# Send a new cmd
		191	self.client.tpm.write(cmd)
		192
		193	# Read the whole respone
		194	rsp2 = self.client.tpm.read()
		195	except:
		196	pass
		197	self.assertEqual(len(rsp1), 15)
		198	self.assertEqual(len(rsp2), 10 + 2 + 32)
		199
		200	def test_send_two_cmds(self):
		201	rejected = False
		202	try:
		203	fmt = '>HIIH'
		204	cmd = struct.pack(fmt,
		205	tpm2.TPM2_ST_NO_SESSIONS,
		206	struct.calcsize(fmt),
		207	tpm2.TPM2_CC_GET_RANDOM,
		208	0x20)
		209	self.client.tpm.write(cmd)
		210
		211	# expect the second one to raise -EBUSY error
		212	self.client.tpm.write(cmd)
		213	rsp = self.client.tpm.read()
		214
		215	except IOError, e:
		216	# read the response
		217	rsp = self.client.tpm.read()
		218	rejected = True
		219	pass
		220	except:
		221	pass
		222	self.assertEqual(rejected, True)
		223
161	class SpaceTest(unittest.TestCase):	224	class SpaceTest(unittest.TestCase):
162	def setUp(self):	225	def setUp(self):
163	logging.basicConfig(filename='SpaceTest.log', level=logging.DEBUG)	226	logging.basicConfig(filename='SpaceTest.log', level=logging.DEBUG)