lael-labs/linux

.clang-format+24−0

   - 'ata_qc_for_each_with_internal'
   - 'ax25_for_each'
   - 'ax25_uid_for_each'
+  - '__bio_for_each_bvec'
+  - 'bio_for_each_bvec'
   - 'bio_for_each_integrity_vec'
   - '__bio_for_each_segment'
   - 'bio_for_each_segment'
   - 'drm_for_each_legacy_plane'
   - 'drm_for_each_plane'
   - 'drm_for_each_plane_mask'
+  - 'drm_for_each_privobj'
   - 'drm_mm_for_each_hole'
   - 'drm_mm_for_each_node'
   - 'drm_mm_for_each_node_in_range'
   - 'drm_mm_for_each_node_safe'
+  - 'flow_action_for_each'
   - 'for_each_active_drhd_unit'
   - 'for_each_active_iommu'
   - 'for_each_available_child_of_node'
   - 'for_each_dss_dev'
   - 'for_each_efi_memory_desc'
   - 'for_each_efi_memory_desc_in_map'
+  - 'for_each_element'
+  - 'for_each_element_extid'
+  - 'for_each_element_id'
   - 'for_each_endpoint_of_node'
   - 'for_each_evictable_lru'
   - 'for_each_fib6_node_rt_rcu'
   - 'for_each_net_rcu'
   - 'for_each_new_connector_in_state'
   - 'for_each_new_crtc_in_state'
+  - 'for_each_new_mst_mgr_in_state'
   - 'for_each_new_plane_in_state'
   - 'for_each_new_private_obj_in_state'
   - 'for_each_node'
   - 'for_each_of_pci_range'
   - 'for_each_old_connector_in_state'
   - 'for_each_old_crtc_in_state'
+  - 'for_each_old_mst_mgr_in_state'
   - 'for_each_oldnew_connector_in_state'
   - 'for_each_oldnew_crtc_in_state'
+  - 'for_each_oldnew_mst_mgr_in_state'
   - 'for_each_oldnew_plane_in_state'
   - 'for_each_oldnew_plane_in_state_reverse'
   - 'for_each_oldnew_private_obj_in_state'
   - 'for_each_sg_dma_page'
   - 'for_each_sg_page'
   - 'for_each_sibling_event'
+  - 'for_each_subelement'
+  - 'for_each_subelement_extid'
+  - 'for_each_subelement_id'
   - '__for_each_thread'
   - 'for_each_thread'
   - 'for_each_zone'
   - 'fwnode_for_each_child_node'
   - 'fwnode_graph_for_each_endpoint'
   - 'gadget_for_each_ep'
+  - 'genradix_for_each'
+  - 'genradix_for_each_from'
   - 'hash_for_each'
   - 'hash_for_each_possible'
   - 'hash_for_each_possible_rcu'
   - 'key_for_each'
   - 'key_for_each_safe'
   - 'klp_for_each_func'
+  - 'klp_for_each_func_safe'
+  - 'klp_for_each_func_static'
   - 'klp_for_each_object'
+  - 'klp_for_each_object_safe'
+  - 'klp_for_each_object_static'
   - 'kvm_for_each_memslot'
   - 'kvm_for_each_vcpu'
   - 'list_for_each'
   - 'media_device_for_each_intf'
   - 'media_device_for_each_link'
   - 'media_device_for_each_pad'
+  - 'mp_bvec_for_each_page'
+  - 'mp_bvec_for_each_segment'
   - 'nanddev_io_for_each_page'
   - 'netdev_for_each_lower_dev'
   - 'netdev_for_each_lower_private'
   - 'rht_for_each_rcu'
   - 'rht_for_each_rcu_continue'
   - '__rq_for_each_bio'
+  - 'rq_for_each_bvec'
   - 'rq_for_each_segment'
   - 'scsi_for_each_prot_sg'
   - 'scsi_for_each_sg'
   - 'v4l2_m2m_for_each_src_buf_safe'
   - 'virtio_device_for_each_vq'
   - 'xa_for_each'
+  - 'xa_for_each_marked'
+  - 'xa_for_each_start'
   - 'xas_for_each'
   - 'xas_for_each_conflict'
   - 'xas_for_each_marked'

.mailmap+2−0

 Morten Welinder <welinder@troll.com>
 Mythri P K <mythripk@ti.com>
 Nguyen Anh Quynh <aquynh@gmail.com>
+Nicolas Pitre <nico@fluxnic.net> <nicolas.pitre@linaro.org>
+Nicolas Pitre <nico@fluxnic.net> <nico@linaro.org>
 Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
 Patrick Mochel <mochel@digitalimplant.org>
 Paul Burton <paul.burton@mips.com> <paul.burton@imgtec.com>

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/bpf/btf.rst+4−4

 for the type. The maximum value of ``BTF_INT_BITS()`` is 128.
 The ``BTF_INT_OFFSET()`` specifies the starting bit offset to calculate values
-for this int. For example, a bitfield struct member has: * btf member bit
+for this int. For example, a bitfield struct member has:
-offset 100 from the start of the structure, * btf member pointing to an int
+ * btf member bit offset 100 from the start of the structure,
-type, * the int type has ``BTF_INT_OFFSET() = 2`` and ``BTF_INT_BITS() = 4``
+ * btf member pointing to an int type,
+ * the int type has ``BTF_INT_OFFSET() = 2`` and ``BTF_INT_BITS() = 4``
 Then in the struct memory layout, this member will occupy ``4`` bits starting
 from bits ``100 + 2 = 102``.
 Alternatively, the bitfield struct member can be the following to access the
 same bits as the above:
  * btf member bit offset 102,
  * btf member pointing to an int type,
  * the int type has ``BTF_INT_OFFSET() = 0`` and ``BTF_INT_BITS() = 4``

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/devicetree/bindings/hwmon/adc128d818.txt+2−2

@@ -26,7 +26,7 @@ Required node properties: · 25 unmodified lines
26		26
27	Optional node properties:	27	Optional node properties:
28		28
29	- ti,mode: Operation mode (see above).	29	- ti,mode: Operation mode (u8) (see above).
30		30
31		31
32	Example (operation mode 2):	32	Example (operation mode 2):
@@ -34,5 +34,5 @@ Example (operation mode 2): · 1 unmodified line
34	adc128d818@1d {	34	adc128d818@1d {
35	compatible = "ti,adc128d818";	35	compatible = "ti,adc128d818";
36	reg = <0x1d>;	36	reg = <0x1d>;
37	ti,mode = <2>;	37	ti,mode = /bits/ 8 <2>;
38	};	38	};

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 ]

Documentation/media/uapi/rc/rc-tables.rst+2−2

@@ -623,7 +623,7 @@ the remote via /dev/input/event devices. · 622 unmodified lines
623		623
624	- .. row 78	624	- .. row 78
625		625
626	- ``KEY_SCREEN``	626	- ``KEY_ASPECT_RATIO``
627		627
628	- Select screen aspect ratio	628	- Select screen aspect ratio
629		629
@@ -631,7 +631,7 @@ the remote via /dev/input/event devices. · 1 unmodified line
631		631
632	- .. row 79	632	- .. row 79
633		633
634	- ``KEY_ZOOM``	634	- ``KEY_FULL_SCREEN``
635		635
636	- Put device into zoom/full screen mode	636	- Put device into zoom/full screen mode
637		637

Documentation/networking/bpf_flow_dissector.rst+126−0

@@ -0,0 +1,126 @@
	1	.. SPDX-License-Identifier: GPL-2.0
	2
	3	==================
	4	BPF Flow Dissector
	5	==================
	6
	7	Overview
	8	========
	9
	10	Flow dissector is a routine that parses metadata out of the packets. It's
	11	used in the various places in the networking subsystem (RFS, flow hash, etc).
	12
	13	BPF flow dissector is an attempt to reimplement C-based flow dissector logic
	14	in BPF to gain all the benefits of BPF verifier (namely, limits on the
	15	number of instructions and tail calls).
	16
	17	API
	18	===
	19
	20	BPF flow dissector programs operate on an ``__sk_buff``. However, only the
	21	limited set of fields is allowed: ``data``, ``data_end`` and ``flow_keys``.
	22	``flow_keys`` is ``struct bpf_flow_keys`` and contains flow dissector input
	23	and output arguments.
	24
	25	The inputs are:
	26	* ``nhoff`` - initial offset of the networking header
	27	* ``thoff`` - initial offset of the transport header, initialized to nhoff
	28	* ``n_proto`` - L3 protocol type, parsed out of L2 header
	29
	30	Flow dissector BPF program should fill out the rest of the ``struct
	31	bpf_flow_keys`` fields. Input arguments ``nhoff/thoff/n_proto`` should be
	32	also adjusted accordingly.
	33
	34	The return code of the BPF program is either BPF_OK to indicate successful
	35	dissection, or BPF_DROP to indicate parsing error.
	36
	37	__sk_buff->data
	38	===============
	39
	40	In the VLAN-less case, this is what the initial state of the BPF flow
	41	dissector looks like::
	42
	43	+------+------+------------+-----------+
	44	\| DMAC \| SMAC \| ETHER_TYPE \| L3_HEADER \|
	45	+------+------+------------+-----------+
	46	^
	47	\|
	48	+-- flow dissector starts here
	49
	50
	51	.. code:: c
	52
	53	skb->data + flow_keys->nhoff point to the first byte of L3_HEADER
	54	flow_keys->thoff = nhoff
	55	flow_keys->n_proto = ETHER_TYPE
	56
	57	In case of VLAN, flow dissector can be called with the two different states.
	58
	59	Pre-VLAN parsing::
	60
	61	+------+------+------+-----+-----------+-----------+
	62	\| DMAC \| SMAC \| TPID \| TCI \|ETHER_TYPE \| L3_HEADER \|
	63	+------+------+------+-----+-----------+-----------+
	64	^
	65	\|
	66	+-- flow dissector starts here
	67
	68	.. code:: c
	69
	70	skb->data + flow_keys->nhoff point the to first byte of TCI
	71	flow_keys->thoff = nhoff
	72	flow_keys->n_proto = TPID
	73
	74	Please note that TPID can be 802.1AD and, hence, BPF program would
	75	have to parse VLAN information twice for double tagged packets.
	76
	77
	78	Post-VLAN parsing::
	79
	80	+------+------+------+-----+-----------+-----------+
	81	\| DMAC \| SMAC \| TPID \| TCI \|ETHER_TYPE \| L3_HEADER \|
	82	+------+------+------+-----+-----------+-----------+
	83	^
	84	\|
	85	+-- flow dissector starts here
	86
	87	.. code:: c
	88
	89	skb->data + flow_keys->nhoff point the to first byte of L3_HEADER
	90	flow_keys->thoff = nhoff
	91	flow_keys->n_proto = ETHER_TYPE
	92
	93	In this case VLAN information has been processed before the flow dissector
	94	and BPF flow dissector is not required to handle it.
	95
	96
	97	The takeaway here is as follows: BPF flow dissector program can be called with
	98	the optional VLAN header and should gracefully handle both cases: when single
	99	or double VLAN is present and when it is not present. The same program
	100	can be called for both cases and would have to be written carefully to
	101	handle both cases.
	102
	103
	104	Reference Implementation
	105	========================
	106
	107	See ``tools/testing/selftests/bpf/progs/bpf_flow.c`` for the reference
	108	implementation and ``tools/testing/selftests/bpf/flow_dissector_load.[hc]``
	109	for the loader. bpftool can be used to load BPF flow dissector program as well.
	110
	111	The reference implementation is organized as follows:
	112	* ``jmp_table`` map that contains sub-programs for each supported L3 protocol
	113	* ``_dissect`` routine - entry point; it does input ``n_proto`` parsing and
	114	does ``bpf_tail_call`` to the appropriate L3 handler
	115
	116	Since BPF at this point doesn't support looping (or any jumping back),
	117	jmp_table is used instead to handle multiple levels of encapsulation (and
	118	IPv6 options).
	119
	120
	121	Current Limitations
	122	===================
	123	BPF flow dissector doesn't support exporting all the metadata that in-kernel
	124	C-based implementation can export. Notable example is single VLAN (802.1Q)
	125	and double VLAN (802.1AD) tags. Please refer to the ``struct bpf_flow_keys``
	126	for a set of information that's currently can be exported from the BPF context.

Documentation/networking/index.rst+1−0

@@ -9,6 +9,7 @@ Contents: · 8 unmodified lines
9	netdev-FAQ	9	netdev-FAQ
10	af_xdp	10	af_xdp
11	batman-adv	11	batman-adv
		12	bpf_flow_dissector
12	can	13	can
13	can_ucan_protocol	14	can_ucan_protocol
14	device_drivers/freescale/dpaa2/index	15	device_drivers/freescale/dpaa2/index

Documentation/networking/rxrpc.txt+9−7

@@ -1009,16 +1009,18 @@ The kernel interface functions are as follows: · 1008 unmodified lines
1009		1009
1010	(*) Check call still alive.	1010	(*) Check call still alive.
1011		1011
1012	u32 rxrpc_kernel_check_life(struct socket *sock,	1012	bool rxrpc_kernel_check_life(struct socket *sock,
1013	struct rxrpc_call *call);	1013	struct rxrpc_call *call,
		1014	u32 *_life);
1014	void rxrpc_kernel_probe_life(struct socket *sock,	1015	void rxrpc_kernel_probe_life(struct socket *sock,
1015	struct rxrpc_call *call);	1016	struct rxrpc_call *call);
1016		1017
1017	The first function returns a number that is updated when ACKs are received	1018	The first function passes back in *_life a number that is updated when
1018	from the peer (notably including PING RESPONSE ACKs which we can elicit by	1019	ACKs are received from the peer (notably including PING RESPONSE ACKs
1019	sending PING ACKs to see if the call still exists on the server). The	1020	which we can elicit by sending PING ACKs to see if the call still exists
1020	caller should compare the numbers of two calls to see if the call is still	1021	on the server). The caller should compare the numbers of two calls to see
1021	alive after waiting for a suitable interval.	1022	if the call is still alive after waiting for a suitable interval. It also
		1023	returns true as long as the call hasn't yet reached the completed state.
1022		1024
1023	This allows the caller to work out if the server is still contactable and	1025	This allows the caller to work out if the server is still contactable and
1024	if the call is still alive on the server while waiting for the server to	1026	if the call is still alive on the server while waiting for the server to

MAINTAINERS+22−9

 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/linux/cpuidle.h
 CRAMFS FILESYSTEM
-M:	Nicolas Pitre <nico@linaro.org>
+M:	Nicolas Pitre <nico@fluxnic.net>
 S:	Maintained
 F:	Documentation/filesystems/cramfs.txt
 F:	fs/cramfs/
 S:	Maintained
 F:	Documentation/ABI/testing/sysfs-bus-mdio
 F:	Documentation/devicetree/bindings/net/mdio*
-F:	Documentation/networking/phy.txt
+F:	Documentation/networking/phy.rst
 F:	drivers/net/phy/
 F:	drivers/of/of_mdio.c
 F:	drivers/of/of_net.c
 F:	Documentation/driver-api/i3c
 F:	drivers/i3c/
 F:	include/linux/i3c/
-F:	include/dt-bindings/i3c/
 I3C DRIVER FOR SYNOPSYS DESIGNWARE
 M:	Vitor Soares <vitor.soares@synopsys.com>
 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>
 F:	Documentation/devicetree/bindings/mfd/atmel-usart.txt
 MICROCHIP KSZ SERIES ETHERNET SWITCH DRIVER
-M:	Woojung Huh <Woojung.Huh@microchip.com>
+M:	Woojung Huh <woojung.huh@microchip.com>
 M:	Microchip Linux Driver Support <UNGLinuxDriver@microchip.com>
 L:	netdev@vger.kernel.org
 S:	Maintained
 SFC NETWORK DRIVER
 M:	Solarflare linux maintainers <linux-net-drivers@solarflare.com>
 M:	Edward Cree <ecree@solarflare.com>
-M:	Bert Kenward <bkenward@solarflare.com>
+M:	Martin Habets <mhabets@solarflare.com>
 L:	netdev@vger.kernel.org
 S:	Supported
 F:	drivers/net/ethernet/sfc/
 F:	include/linux/virtio_console.h
 F:	include/uapi/linux/virtio_console.h
-VIRTIO CORE, NET AND BLOCK DRIVERS
+VIRTIO CORE AND NET DRIVERS
 M:	"Michael S. Tsirkin" <mst@redhat.com>
 M:	Jason Wang <jasowang@redhat.com>
 L:	virtualization@lists.linux-foundation.org
 F:	drivers/crypto/virtio/
 F:	mm/balloon_compaction.c
+VIRTIO BLOCK AND SCSI DRIVERS
+M:	"Michael S. Tsirkin" <mst@redhat.com>
+M:	Jason Wang <jasowang@redhat.com>
+R:	Paolo Bonzini <pbonzini@redhat.com>
+R:	Stefan Hajnoczi <stefanha@redhat.com>
+L:	virtualization@lists.linux-foundation.org
+S:	Maintained
+F:	drivers/block/virtio_blk.c
+F:	drivers/scsi/virtio_scsi.c
+F:	include/uapi/linux/virtio_blk.h
+F:	include/uapi/linux/virtio_scsi.h
+F:	drivers/vhost/scsi.c
 VIRTIO CRYPTO DRIVER
 M:	Gonglei <arei.gonglei@huawei.com>
 L:	virtualization@lists.linux-foundation.org

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 = -rc6
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/futex.h+7−7

@@ -30,8 +30,8 @@ do { \ · 29 unmodified lines
30	" prfm pstl1strm, %2\n" \	30	" prfm pstl1strm, %2\n" \
31	"1: ldxr %w1, %2\n" \	31	"1: ldxr %w1, %2\n" \
32	insn "\n" \	32	insn "\n" \
33	"2: stlxr %w3, %w0, %2\n" \	33	"2: stlxr %w0, %w3, %2\n" \
34	" cbnz %w3, 1b\n" \	34	" cbnz %w0, 1b\n" \
35	" dmb ish\n" \	35	" dmb ish\n" \
36	"3:\n" \	36	"3:\n" \
37	" .pushsection .fixup,\"ax\"\n" \	37	" .pushsection .fixup,\"ax\"\n" \
@@ -57,23 +57,23 @@ arch_futex_atomic_op_inuser(int op, int oparg, int oval, u32 __user _uaddr) · 19 unmodified lines
57		57
58	switch (op) {	58	switch (op) {
59	case FUTEX_OP_SET:	59	case FUTEX_OP_SET:
60	__futex_atomic_op("mov %w0, %w4",	60	__futex_atomic_op("mov %w3, %w4",
61	ret, oldval, uaddr, tmp, oparg);	61	ret, oldval, uaddr, tmp, oparg);
62	break;	62	break;
63	case FUTEX_OP_ADD:	63	case FUTEX_OP_ADD:
64	__futex_atomic_op("add %w0, %w1, %w4",	64	__futex_atomic_op("add %w3, %w1, %w4",
65	ret, oldval, uaddr, tmp, oparg);	65	ret, oldval, uaddr, tmp, oparg);
66	break;	66	break;
67	case FUTEX_OP_OR:	67	case FUTEX_OP_OR:
68	__futex_atomic_op("orr %w0, %w1, %w4",	68	__futex_atomic_op("orr %w3, %w1, %w4",
69	ret, oldval, uaddr, tmp, oparg);	69	ret, oldval, uaddr, tmp, oparg);
70	break;	70	break;
71	case FUTEX_OP_ANDN:	71	case FUTEX_OP_ANDN:
72	__futex_atomic_op("and %w0, %w1, %w4",	72	__futex_atomic_op("and %w3, %w1, %w4",
73	ret, oldval, uaddr, tmp, ~oparg);	73	ret, oldval, uaddr, tmp, ~oparg);
74	break;	74	break;
75	case FUTEX_OP_XOR:	75	case FUTEX_OP_XOR:
76	__futex_atomic_op("eor %w0, %w1, %w4",	76	__futex_atomic_op("eor %w3, %w1, %w4",
77	ret, oldval, uaddr, tmp, oparg);	77	ret, oldval, uaddr, tmp, oparg);
78	break;	78	break;
79	default:	79	default:

arch/arm64/include/asm/module.h+5−0

@@ -73,4 +73,9 @@ static inline bool is_forbidden_offset_for_adrp(void *place) · 72 unmodified lines
73	struct plt_entry get_plt_entry(u64 dst, void *pc);	73	struct plt_entry get_plt_entry(u64 dst, void *pc);
74	bool plt_entries_equal(const struct plt_entry a, const struct plt_entry b);	74	bool plt_entries_equal(const struct plt_entry a, const struct plt_entry b);
75		75
		76	static inline bool plt_entry_is_initialized(const struct plt_entry *e)
		77	{
		78	return e->adrp \|\| e->add \|\| e->br;
		79	}
		80
76	#endif /* __ASM_MODULE_H */	81	#endif /* __ASM_MODULE_H */

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/ftrace.c+1−2

 		trampoline = get_plt_entry(addr, mod->arch.ftrace_trampoline);
 		if (!plt_entries_equal(mod->arch.ftrace_trampoline,
 				       &trampoline)) {
-			if (!plt_entries_equal(mod->arch.ftrace_trampoline,
+			if (plt_entry_is_initialized(mod->arch.ftrace_trampoline)) {
-					       &(struct plt_entry){})) {
 				pr_err("ftrace: far branches to multiple entry points unsupported inside a single module\n");
 				return -EINVAL;
 			}

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/arm64/kernel/traps.c+9−6

 void dump_backtrace(struct pt_regs *regs, struct task_struct *tsk)
 {
 	struct stackframe frame;
-	int skip;
+	int skip = 0;
 	pr_debug("%s(regs = %p tsk = %p)\n", __func__, regs, tsk);
+	if (regs) {
+		if (user_mode(regs))
+			return;
+		skip = 1;
+	}
 	if (!tsk)
 		tsk = current;
 	frame.graph = 0;
 #endif
-	skip = !!regs;
 	printk("Call trace:\n");
 	do {
 		/* skip until specified stack frame */
 		return ret;
 	print_modules();
-	__show_regs(regs);
 	pr_emerg("Process %.*s (pid: %d, stack limit = 0x%p)\n",
 		 TASK_COMM_LEN, tsk->comm, task_pid_nr(tsk),
 		 end_of_stack(tsk));
+	show_regs(regs);
-	if (!user_mode(regs)) {
+	if (!user_mode(regs))
-		dump_backtrace(regs, tsk);
 		dump_instr(KERN_EMERG, regs);
-	}
 	return ret;
 }

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/configs/generic/board-ocelot.config+8−0

 # require CONFIG_CPU_MIPS32_R2=y
 CONFIG_LEGACY_BOARD_OCELOT=y
+CONFIG_FIT_IMAGE_FDT_OCELOT=y
+CONFIG_BRIDGE=y
+CONFIG_GENERIC_PHY=y
 CONFIG_MTD=y
 CONFIG_MTD_CMDLINE_PARTS=y
 CONFIG_SERIAL_OF_PLATFORM=y
 CONFIG_NETDEVICES=y
+CONFIG_NET_SWITCHDEV=y
+CONFIG_NET_DSA=y
 CONFIG_MSCC_OCELOT_SWITCH=y
 CONFIG_MSCC_OCELOT_SWITCH_OCELOT=y
 CONFIG_MDIO_MSCC_MIIM=y
 CONFIG_SPI_DW_MMIO=y
 CONFIG_SPI_SPIDEV=y
+CONFIG_PINCTRL_OCELOT=y
 CONFIG_GPIO_SYSFS=y
 CONFIG_POWER_RESET=y

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/kgdb.c+2−1

 #include <asm/processor.h>
 #include <asm/sigcontext.h>
 #include <linux/uaccess.h>
+#include <asm/irq_regs.h>
 static struct hard_trap_info {
 	unsigned char tt;	/* Trap type code for MIPS R3xxx and R4xxx */
 	old_fs = get_fs();
 	set_fs(KERNEL_DS);
-	kgdb_nmicallback(raw_smp_processor_id(), NULL);
+	kgdb_nmicallback(raw_smp_processor_id(), get_irq_regs());
 	set_fs(old_fs);
 }

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/mips/sgi-ip27/ip27-irq.c+1−2

 {
 	struct hub_irq_data *hd = irq_data_get_irq_chip_data(d);
 	struct bridge_controller *bc;
-	int pin = hd->pin;
 	if (!hd)
 		return;
 	disable_hub_irq(d);
 	bc = hd->bc;
-	bridge_clr(bc, b_int_enable, (1 << pin));
+	bridge_clr(bc, b_int_enable, (1 << hd->pin));
 	bridge_read(bc, b_wid_tflush);
 }

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/mmu.h+1−1

@@ -352,7 +352,7 @@ static inline bool strict_kernel_rwx_enabled(void) · 351 unmodified lines
352	#if defined(CONFIG_SPARSEMEM_VMEMMAP) && defined(CONFIG_SPARSEMEM_EXTREME) && \	352	#if defined(CONFIG_SPARSEMEM_VMEMMAP) && defined(CONFIG_SPARSEMEM_EXTREME) && \
353	defined (CONFIG_PPC_64K_PAGES)	353	defined (CONFIG_PPC_64K_PAGES)
354	#define MAX_PHYSMEM_BITS 51	354	#define MAX_PHYSMEM_BITS 51
355	#elif defined(CONFIG_SPARSEMEM)	355	#elif defined(CONFIG_PPC64)
356	#define MAX_PHYSMEM_BITS 46	356	#define MAX_PHYSMEM_BITS 46
357	#endif	357	#endif
358		358

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/exceptions-64s.S+12−0

 	ld	r4,PACA_EXSLB+EX_DAR(r13)
 	std	r4,_DAR(r1)
 	addi	r3,r1,STACK_FRAME_OVERHEAD
+BEGIN_MMU_FTR_SECTION
+	/* HPT case, do SLB fault */
 	bl	do_slb_fault
 	cmpdi	r3,0
 	bne-	1f
 	b	fast_exception_return
 1:	/* Error case */
+MMU_FTR_SECTION_ELSE
+	/* Radix case, access is outside page table range */
+	li	r3,-EFAULT
+ALT_MMU_FTR_SECTION_END_IFCLR(MMU_FTR_TYPE_RADIX)
 	std	r3,RESULT(r1)
 	bl	save_nvgprs
 	RECONCILE_IRQ_STATE(r10, r11)
 	EXCEPTION_PROLOG_COMMON(0x480, PACA_EXSLB)
 	ld	r4,_NIP(r1)
 	addi	r3,r1,STACK_FRAME_OVERHEAD
+BEGIN_MMU_FTR_SECTION
+	/* HPT case, do SLB fault */
 	bl	do_slb_fault
 	cmpdi	r3,0
 	bne-	1f
 	b	fast_exception_return
 1:	/* Error case */
+MMU_FTR_SECTION_ELSE
+	/* Radix case, access is outside page table range */
+	li	r3,-EFAULT
+ALT_MMU_FTR_SECTION_END_IFCLR(MMU_FTR_TYPE_RADIX)
 	std	r3,RESULT(r1)
 	bl	save_nvgprs
 	RECONCILE_IRQ_STATE(r10, r11)

arch/powerpc/kernel/head_32.S+0−8

 	tophys(r4,r2)
 	addi	r4,r4,THREAD	/* phys address of our thread_struct */
 	mtspr	SPRN_SPRG_THREAD,r4
-#ifdef CONFIG_PPC_RTAS
-	li	r3,0
-	stw	r3, RTAS_SP(r4)		/* 0 => not in RTAS */
-#endif
 	lis	r4, (swapper_pg_dir - PAGE_OFFSET)@h
 	ori	r4, r4, (swapper_pg_dir - PAGE_OFFSET)@l
 	mtspr	SPRN_SPRG_PGDIR, r4
 	tophys(r4,r2)
 	addi	r4,r4,THREAD	/* init task's THREAD */
 	mtspr	SPRN_SPRG_THREAD,r4
-#ifdef CONFIG_PPC_RTAS
-	li	r3,0
-	stw	r3, RTAS_SP(r4)		/* 0 => not in RTAS */
-#endif
 	lis	r4, (swapper_pg_dir - PAGE_OFFSET)@h
 	ori	r4, r4, (swapper_pg_dir - PAGE_OFFSET)@l
 	mtspr	SPRN_SPRG_PGDIR, r4

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/powerpc/kernel/vdso32/gettimeofday.S+1−1

@@ -98,7 +98,7 @@ V_FUNCTION_BEGIN(__kernel_clock_gettime) · 97 unmodified lines
98	* can be used, r7 contains NSEC_PER_SEC.	98	* can be used, r7 contains NSEC_PER_SEC.
99	*/	99	*/
100		100
101	lwz r5,WTOM_CLOCK_SEC(r9)	101	lwz r5,(WTOM_CLOCK_SEC+LOPART)(r9)
102	lwz r6,WTOM_CLOCK_NSEC(r9)	102	lwz r6,WTOM_CLOCK_NSEC(r9)
103		103
104	/* We now have our offset in r5,r6. We create a fake dependency	104	/* We now have our offset in r5,r6. We create a fake dependency

arch/riscv/configs/rv32_defconfig+84−0

@@ -0,0 +1,84 @@
	1	CONFIG_SYSVIPC=y
	2	CONFIG_POSIX_MQUEUE=y
	3	CONFIG_IKCONFIG=y
	4	CONFIG_IKCONFIG_PROC=y
	5	CONFIG_CGROUPS=y
	6	CONFIG_CGROUP_SCHED=y
	7	CONFIG_CFS_BANDWIDTH=y
	8	CONFIG_CGROUP_BPF=y
	9	CONFIG_NAMESPACES=y
	10	CONFIG_USER_NS=y
	11	CONFIG_CHECKPOINT_RESTORE=y
	12	CONFIG_BLK_DEV_INITRD=y
	13	CONFIG_EXPERT=y
	14	CONFIG_BPF_SYSCALL=y
	15	CONFIG_ARCH_RV32I=y
	16	CONFIG_SMP=y
	17	CONFIG_MODULES=y
	18	CONFIG_MODULE_UNLOAD=y
	19	CONFIG_NET=y
	20	CONFIG_PACKET=y
	21	CONFIG_UNIX=y
	22	CONFIG_INET=y
	23	CONFIG_IP_MULTICAST=y
	24	CONFIG_IP_ADVANCED_ROUTER=y
	25	CONFIG_IP_PNP=y
	26	CONFIG_IP_PNP_DHCP=y
	27	CONFIG_IP_PNP_BOOTP=y
	28	CONFIG_IP_PNP_RARP=y
	29	CONFIG_NETLINK_DIAG=y
	30	CONFIG_PCI=y
	31	CONFIG_PCIEPORTBUS=y
	32	CONFIG_PCI_HOST_GENERIC=y
	33	CONFIG_PCIE_XILINX=y
	34	CONFIG_DEVTMPFS=y
	35	CONFIG_BLK_DEV_LOOP=y
	36	CONFIG_VIRTIO_BLK=y
	37	CONFIG_BLK_DEV_SD=y
	38	CONFIG_BLK_DEV_SR=y
	39	CONFIG_ATA=y
	40	CONFIG_SATA_AHCI=y
	41	CONFIG_SATA_AHCI_PLATFORM=y
	42	CONFIG_NETDEVICES=y
	43	CONFIG_VIRTIO_NET=y
	44	CONFIG_MACB=y
	45	CONFIG_E1000E=y
	46	CONFIG_R8169=y
	47	CONFIG_MICROSEMI_PHY=y
	48	CONFIG_INPUT_MOUSEDEV=y
	49	CONFIG_SERIAL_8250=y
	50	CONFIG_SERIAL_8250_CONSOLE=y
	51	CONFIG_SERIAL_OF_PLATFORM=y
	52	CONFIG_SERIAL_EARLYCON_RISCV_SBI=y
	53	CONFIG_HVC_RISCV_SBI=y
	54	# CONFIG_PTP_1588_CLOCK is not set
	55	CONFIG_DRM=y
	56	CONFIG_DRM_RADEON=y
	57	CONFIG_FRAMEBUFFER_CONSOLE=y
	58	CONFIG_USB=y
	59	CONFIG_USB_XHCI_HCD=y
	60	CONFIG_USB_XHCI_PLATFORM=y
	61	CONFIG_USB_EHCI_HCD=y
	62	CONFIG_USB_EHCI_HCD_PLATFORM=y
	63	CONFIG_USB_OHCI_HCD=y
	64	CONFIG_USB_OHCI_HCD_PLATFORM=y
	65	CONFIG_USB_STORAGE=y
	66	CONFIG_USB_UAS=y
	67	CONFIG_VIRTIO_MMIO=y
	68	CONFIG_SIFIVE_PLIC=y
	69	CONFIG_EXT4_FS=y
	70	CONFIG_EXT4_FS_POSIX_ACL=y
	71	CONFIG_AUTOFS4_FS=y
	72	CONFIG_MSDOS_FS=y
	73	CONFIG_VFAT_FS=y
	74	CONFIG_TMPFS=y
	75	CONFIG_TMPFS_POSIX_ACL=y
	76	CONFIG_NFS_FS=y
	77	CONFIG_NFS_V4=y
	78	CONFIG_NFS_V4_1=y
	79	CONFIG_NFS_V4_2=y
	80	CONFIG_ROOT_NFS=y
	81	CONFIG_CRYPTO_USER_API_HASH=y
	82	CONFIG_CRYPTO_DEV_VIRTIO=y
	83	CONFIG_PRINTK_TIME=y
	84	# CONFIG_RCU_TRACE is not set

arch/riscv/include/asm/fixmap.h+1−1

@@ -26,7 +26,7 @@ enum fixed_addresses { · 25 unmodified lines
26	};	26	};
27		27
28	#define FIXADDR_SIZE (__end_of_fixed_addresses * PAGE_SIZE)	28	#define FIXADDR_SIZE (__end_of_fixed_addresses * PAGE_SIZE)
29	#define FIXADDR_TOP (PAGE_OFFSET)	29	#define FIXADDR_TOP (VMALLOC_START)
30	#define FIXADDR_START (FIXADDR_TOP - FIXADDR_SIZE)	30	#define FIXADDR_START (FIXADDR_TOP - FIXADDR_SIZE)
31		31
32	#define FIXMAP_PAGE_IO PAGE_KERNEL	32	#define FIXMAP_PAGE_IO PAGE_KERNEL

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/riscv/include/asm/uaccess.h+1−1

@@ -300,7 +300,7 @@ do { \ · 299 unmodified lines
300	" .balign 4\n" \	300	" .balign 4\n" \
301	"4:\n" \	301	"4:\n" \
302	" li %0, %6\n" \	302	" li %0, %6\n" \
303	" jump 2b, %1\n" \	303	" jump 3b, %1\n" \
304	" .previous\n" \	304	" .previous\n" \
305	" .section __ex_table,\"a\"\n" \	305	" .section __ex_table,\"a\"\n" \
306	" .balign " RISCV_SZPTR "\n" \	306	" .balign " RISCV_SZPTR "\n" \

arch/riscv/kernel/Makefile+0−3

 ifdef CONFIG_FTRACE
 CFLAGS_REMOVE_ftrace.o = -pg
-CFLAGS_REMOVE_setup.o = -pg
 endif
 extra-y += head.o
 obj-y	+= cacheinfo.o
 obj-y	+= vdso/
-CFLAGS_setup.o := -mcmodel=medany
 obj-$(CONFIG_FPU)		+= fpu.o
 obj-$(CONFIG_SMP)		+= smpboot.o
 obj-$(CONFIG_SMP)		+= smp.o

arch/riscv/kernel/module.c+1−1

@@ -141,7 +141,7 @@ static int apply_r_riscv_hi20_rela(struct module me, u32 location, · 140 unmodified lines
141	{	141	{
142	s32 hi20;	142	s32 hi20;
143		143
144	if (IS_ENABLED(CMODEL_MEDLOW)) {	144	if (IS_ENABLED(CONFIG_CMODEL_MEDLOW)) {
145	pr_err(	145	pr_err(
146	"%s: target %016llx can not be addressed by the 32-bit offset from PC = %p\n",	146	"%s: target %016llx can not be addressed by the 32-bit offset from PC = %p\n",
147	me->name, (long long)v, location);	147	me->name, (long long)v, location);

arch/riscv/kernel/setup.c+0−8

@@ -48,14 +48,6 @@ struct screen_info screen_info = { · 47 unmodified lines
48	};	48	};
49	#endif	49	#endif
50		50
51	unsigned long va_pa_offset;
52	EXPORT_SYMBOL(va_pa_offset);
53	unsigned long pfn_base;
54	EXPORT_SYMBOL(pfn_base);
55
56	unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)] __page_aligned_bss;
57	EXPORT_SYMBOL(empty_zero_page);
58
59	/* The lucky hart to first increment this variable will boot the other cores */	51	/* The lucky hart to first increment this variable will boot the other cores */
60	atomic_t hart_lottery;	52	atomic_t hart_lottery;
61	unsigned long boot_cpu_hartid;	53	unsigned long boot_cpu_hartid;

arch/riscv/mm/Makefile+6−0

@@ -1,3 +1,9 @@
		1
		2	CFLAGS_init.o := -mcmodel=medany
		3	ifdef CONFIG_FTRACE
		4	CFLAGS_REMOVE_init.o = -pg
		5	endif
		6
1	obj-y += init.o	7	obj-y += init.o
2	obj-y += fault.o	8	obj-y += fault.o
3	obj-y += extable.o	9	obj-y += extable.o

arch/riscv/mm/init.c+36−0

@@ -25,6 +25,10 @@ · 24 unmodified lines
25	#include <asm/pgtable.h>	25	#include <asm/pgtable.h>
26	#include <asm/io.h>	26	#include <asm/io.h>
27		27
		28	unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)]
		29	__page_aligned_bss;
		30	EXPORT_SYMBOL(empty_zero_page);
		31
28	static void __init zone_sizes_init(void)	32	static void __init zone_sizes_init(void)
29	{	33	{
30	unsigned long max_zone_pfns[MAX_NR_ZONES] = { 0, };	34	unsigned long max_zone_pfns[MAX_NR_ZONES] = { 0, };
@@ -117,6 +121,14 @@ void __init setup_bootmem(void) · 86 unmodified lines
117	*/	121	*/
118	memblock_reserve(reg->base, vmlinux_end - reg->base);	122	memblock_reserve(reg->base, vmlinux_end - reg->base);
119	mem_size = min(reg->size, (phys_addr_t)-PAGE_OFFSET);	123	mem_size = min(reg->size, (phys_addr_t)-PAGE_OFFSET);
		124
		125	/*
		126	* Remove memblock from the end of usable area to the
		127	* end of region
		128	*/
		129	if (reg->base + mem_size < end)
		130	memblock_remove(reg->base + mem_size,
		131	end - reg->base - mem_size);
120	}	132	}
121	}	133	}
122	BUG_ON(mem_size == 0);	134	BUG_ON(mem_size == 0);
@@ -143,6 +155,11 @@ void __init setup_bootmem(void) · 20 unmodified lines
143	}	155	}
144	}	156	}
145		157
		158	unsigned long va_pa_offset;
		159	EXPORT_SYMBOL(va_pa_offset);
		160	unsigned long pfn_base;
		161	EXPORT_SYMBOL(pfn_base);
		162
146	pgd_t swapper_pg_dir[PTRS_PER_PGD] __page_aligned_bss;	163	pgd_t swapper_pg_dir[PTRS_PER_PGD] __page_aligned_bss;
147	pgd_t trampoline_pg_dir[PTRS_PER_PGD] __initdata __aligned(PAGE_SIZE);	164	pgd_t trampoline_pg_dir[PTRS_PER_PGD] __initdata __aligned(PAGE_SIZE);
148		165
@@ -172,6 +189,25 @@ void __set_fixmap(enum fixed_addresses idx, phys_addr_t phys, pgprot_t prot) · 23 unmodified lines
172	}	189	}
173	}	190	}
174		191
		192	/*
		193	* setup_vm() is called from head.S with MMU-off.
		194	*
		195	* Following requirements should be honoured for setup_vm() to work
		196	* correctly:
		197	* 1) It should use PC-relative addressing for accessing kernel symbols.
		198	* To achieve this we always use GCC cmodel=medany.
		199	* 2) The compiler instrumentation for FTRACE will not work for setup_vm()
		200	* so disable compiler instrumentation when FTRACE is enabled.
		201	*
		202	* Currently, the above requirements are honoured by using custom CFLAGS
		203	* for init.o in mm/Makefile.
		204	*/
		205
		206	#ifndef __riscv_cmodel_medany
		207	#error "setup_vm() is called from head.S before relocate so it should "
		208	"not use absolute addressing."
		209	#endif
		210
175	asmlinkage void __init setup_vm(void)	211	asmlinkage void __init setup_vm(void)
176	{	212	{
177	extern char _start;	213	extern char _start;

arch/s390/boot/mem_detect.c+1−1

@@ -25,7 +25,7 @@ static void *mem_detect_alloc_extended(void) · 24 unmodified lines
25	{	25	{
26	unsigned long offset = ALIGN(mem_safe_offset(), sizeof(u64));	26	unsigned long offset = ALIGN(mem_safe_offset(), sizeof(u64));
27		27
28	if (IS_ENABLED(BLK_DEV_INITRD) && INITRD_START && INITRD_SIZE &&	28	if (IS_ENABLED(CONFIG_BLK_DEV_INITRD) && INITRD_START && INITRD_SIZE &&
29	INITRD_START < offset + ENTRIES_EXTENDED_MAX)	29	INITRD_START < offset + ENTRIES_EXTENDED_MAX)
30	offset = ALIGN(INITRD_START + INITRD_SIZE, sizeof(u64));	30	offset = ALIGN(INITRD_START + INITRD_SIZE, sizeof(u64));
31		31

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/s390/kernel/fpu.c+1−1

@@ -23,7 +23,7 @@ void __kernel_fpu_begin(struct kernel_fpu *state, u32 flags) · 22 unmodified lines
23		23
24	if (flags & KERNEL_FPC)	24	if (flags & KERNEL_FPC)
25	/* Save floating point control */	25	/* Save floating point control */
26	asm volatile("stfpc %0" : "=m" (state->fpc));	26	asm volatile("stfpc %0" : "=Q" (state->fpc));
27		27
28	if (!MACHINE_HAS_VX) {	28	if (!MACHINE_HAS_VX) {
29	if (flags & KERNEL_VXR_V0V7) {	29	if (flags & KERNEL_VXR_V0V7) {

arch/s390/kernel/vtime.c+4−4

@@ -37,7 +37,7 @@ static inline u64 get_vtimer(void) · 36 unmodified lines
37	{	37	{
38	u64 timer;	38	u64 timer;
39		39
40	asm volatile("stpt %0" : "=m" (timer));	40	asm volatile("stpt %0" : "=Q" (timer));
41	return timer;	41	return timer;
42	}	42	}
43		43
@@ -48,7 +48,7 @@ static inline void set_vtimer(u64 expires) · 4 unmodified lines
48	asm volatile(	48	asm volatile(
49	" stpt %0\n" /* Store current cpu timer value */	49	" stpt %0\n" /* Store current cpu timer value */
50	" spt %1" /* Set new value imm. afterwards */	50	" spt %1" /* Set new value imm. afterwards */
51	: "=m" (timer) : "m" (expires));	51	: "=Q" (timer) : "Q" (expires));
52	S390_lowcore.system_timer += S390_lowcore.last_update_timer - timer;	52	S390_lowcore.system_timer += S390_lowcore.last_update_timer - timer;
53	S390_lowcore.last_update_timer = expires;	53	S390_lowcore.last_update_timer = expires;
54	}	54	}
@@ -135,8 +135,8 @@ static int do_account_vtime(struct task_struct *tsk) · 80 unmodified lines
135	#else	135	#else
136	" stck %1" /* Store current tod clock value */	136	" stck %1" /* Store current tod clock value */
137	#endif	137	#endif
138	: "=m" (S390_lowcore.last_update_timer),	138	: "=Q" (S390_lowcore.last_update_timer),
139	"=m" (S390_lowcore.last_update_clock));	139	"=Q" (S390_lowcore.last_update_clock));
140	clock = S390_lowcore.last_update_clock - clock;	140	clock = S390_lowcore.last_update_clock - clock;
141	timer -= S390_lowcore.last_update_timer;	141	timer -= S390_lowcore.last_update_timer;
142		142

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/sparc/kernel/pci_sun4v.c+11−9

 	p->npages	= 0;
 }
+static inline bool iommu_use_atu(struct iommu *iommu, u64 mask)
+{
+	return iommu->atu && mask > DMA_BIT_MASK(32);
+}
 /* Interrupts must be disabled.  */
 static long iommu_batch_flush(struct iommu_batch *p, u64 mask)
 {
 		prot &= (HV_PCI_MAP_ATTR_READ | HV_PCI_MAP_ATTR_WRITE);
 	while (npages != 0) {
-		if (mask <= DMA_BIT_MASK(32) || !pbm->iommu->atu) {
+		if (!iommu_use_atu(pbm->iommu, mask)) {
 			num = pci_sun4v_iommu_map(devhandle,
 						  HV_PCI_TSBID(0, entry),
 						  npages,
 	unsigned long flags, order, first_page, npages, n;
 	unsigned long prot = 0;
 	struct iommu *iommu;
-	struct atu *atu;
 	struct iommu_map_table *tbl;
 	struct page *page;
 	void *ret;
 	memset((char *)first_page, 0, PAGE_SIZE << order);
 	iommu = dev->archdata.iommu;
-	atu = iommu->atu;
 	mask = dev->coherent_dma_mask;
-	if (mask <= DMA_BIT_MASK(32) || !atu)
+	if (!iommu_use_atu(iommu, mask))
 		tbl = &iommu->tbl;
 	else
-		tbl = &atu->tbl;
+		tbl = &iommu->atu->tbl;
 	entry = iommu_tbl_range_alloc(dev, tbl, npages, NULL,
 				      (unsigned long)(-1), 0);
 	atu = iommu->atu;
 	devhandle = pbm->devhandle;
-	if (dvma <= DMA_BIT_MASK(32)) {
+	if (!iommu_use_atu(iommu, dvma)) {
 		tbl = &iommu->tbl;
 		iotsb_num = 0; /* we don't care for legacy iommu */
 	} else {
 	npages >>= IO_PAGE_SHIFT;
 	mask = *dev->dma_mask;
-	if (mask <= DMA_BIT_MASK(32))
+	if (!iommu_use_atu(iommu, mask))
 		tbl = &iommu->tbl;
 	else
 		tbl = &atu->tbl;
 				  IO_PAGE_SIZE) >> IO_PAGE_SHIFT;
 	mask = *dev->dma_mask;
-	if (mask <= DMA_BIT_MASK(32))
+	if (!iommu_use_atu(iommu, mask))
 		tbl = &iommu->tbl;
 	else
 		tbl = &atu->tbl;

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/Kconfig+1−1

@@ -1499,7 +1499,7 @@ config X86_CPA_STATISTICS · 1498 unmodified lines
1499	depends on DEBUG_FS	1499	depends on DEBUG_FS
1500	---help---	1500	---help---
1501	Expose statistics about the Change Page Attribute mechanims, which	1501	Expose statistics about the Change Page Attribute mechanims, which
1502	helps to determine the effectivness of preserving large and huge	1502	helps to determine the effectiveness of preserving large and huge
1503	page mappings when mapping protections are changed.	1503	page mappings when mapping protections are changed.
1504		1504
1505	config ARCH_HAS_MEM_ENCRYPT	1505	config ARCH_HAS_MEM_ENCRYPT

arch/x86/crypto/poly1305-avx2-x86_64.S+10−4

 	vpaddq		t2,t1,t1
 	vmovq		t1x,d4
+	# Now do a partial reduction mod (2^130)-5, carrying h0 -> h1 -> h2 ->
+	# h3 -> h4 -> h0 -> h1 to get h0,h2,h3,h4 < 2^26 and h1 < 2^26 + a small
+	# amount.  Careful: we must not assume the carry bits 'd0 >> 26',
+	# 'd1 >> 26', 'd2 >> 26', 'd3 >> 26', and '(d4 >> 26) * 5' fit in 32-bit
+	# integers.  It's true in a single-block implementation, but not here.
 	# d1 += d0 >> 26
 	mov		d0,%rax
 	shr		$26,%rax
 	# h0 += (d4 >> 26) * 5
 	mov		d4,%rax
 	shr		$26,%rax
-	lea		(%eax,%eax,4),%eax
+	lea		(%rax,%rax,4),%rax
-	add		%eax,%ebx
+	add		%rax,%rbx
 	# h4 = d4 & 0x3ffffff
 	mov		d4,%rax
 	and		$0x3ffffff,%eax
 	mov		%eax,h4
 	# h1 += h0 >> 26
-	mov		%ebx,%eax
+	mov		%rbx,%rax
-	shr		$26,%eax
+	shr		$26,%rax
 	add		%eax,h1
 	# h0 = h0 & 0x3ffffff
 	andl		$0x3ffffff,%ebx

arch/x86/crypto/poly1305-sse2-x86_64.S+14−8

 	# h0 += (d4 >> 26) * 5
 	mov		d4,%rax
 	shr		$26,%rax
-	lea		(%eax,%eax,4),%eax
+	lea		(%rax,%rax,4),%rax
-	add		%eax,%ebx
+	add		%rax,%rbx
 	# h4 = d4 & 0x3ffffff
 	mov		d4,%rax
 	and		$0x3ffffff,%eax
 	mov		%eax,h4
 	# h1 += h0 >> 26
-	mov		%ebx,%eax
+	mov		%rbx,%rax
-	shr		$26,%eax
+	shr		$26,%rax
 	add		%eax,h1
 	# h0 = h0 & 0x3ffffff
 	andl		$0x3ffffff,%ebx
 	paddq		t2,t1
 	movq		t1,d4
+	# Now do a partial reduction mod (2^130)-5, carrying h0 -> h1 -> h2 ->
+	# h3 -> h4 -> h0 -> h1 to get h0,h2,h3,h4 < 2^26 and h1 < 2^26 + a small
+	# amount.  Careful: we must not assume the carry bits 'd0 >> 26',
+	# 'd1 >> 26', 'd2 >> 26', 'd3 >> 26', and '(d4 >> 26) * 5' fit in 32-bit
+	# integers.  It's true in a single-block implementation, but not here.
 	# d1 += d0 >> 26
 	mov		d0,%rax
 	shr		$26,%rax
 	# h0 += (d4 >> 26) * 5
 	mov		d4,%rax
 	shr		$26,%rax
-	lea		(%eax,%eax,4),%eax
+	lea		(%rax,%rax,4),%rax
-	add		%eax,%ebx
+	add		%rax,%rbx
 	# h4 = d4 & 0x3ffffff
 	mov		d4,%rax
 	and		$0x3ffffff,%eax
 	mov		%eax,h4
 	# h1 += h0 >> 26
-	mov		%ebx,%eax
+	mov		%rbx,%rax
-	shr		$26,%eax
+	shr		$26,%rax
 	add		%eax,h1
 	# h0 = h0 & 0x3ffffff
 	andl		$0x3ffffff,%ebx

arch/x86/events/amd/core.c+161−14

@@ -3,10 +3,14 @@ · 2 unmodified lines
3	#include <linux/types.h>	3	#include <linux/types.h>
4	#include <linux/init.h>	4	#include <linux/init.h>
5	#include <linux/slab.h>	5	#include <linux/slab.h>
		6	#include <linux/delay.h>
6	#include <asm/apicdef.h>	7	#include <asm/apicdef.h>
		8	#include <asm/nmi.h>
7		9
8	#include "../perf_event.h"	10	#include "../perf_event.h"
9		11
		12	static DEFINE_PER_CPU(unsigned int, perf_nmi_counter);
		13
10	static __initconst const u64 amd_hw_cache_event_ids	14	static __initconst const u64 amd_hw_cache_event_ids
11	[PERF_COUNT_HW_CACHE_MAX]	15	[PERF_COUNT_HW_CACHE_MAX]
12	[PERF_COUNT_HW_CACHE_OP_MAX]	16	[PERF_COUNT_HW_CACHE_OP_MAX]
@@ -113,22 +117,39 @@ static __initconst const u64 amd_hw_cache_event_ids · 100 unmodified lines
113	};	117	};
114		118
115	/*	119	/*
116	* AMD Performance Monitor K7 and later.	120	* AMD Performance Monitor K7 and later, up to and including Family 16h:
117	*/	121	*/
118	static const u64 amd_perfmon_event_map[PERF_COUNT_HW_MAX] =	122	static const u64 amd_perfmon_event_map[PERF_COUNT_HW_MAX] =
119	{	123	{
120	[PERF_COUNT_HW_CPU_CYCLES] = 0x0076,	124	[PERF_COUNT_HW_CPU_CYCLES] = 0x0076,
121	[PERF_COUNT_HW_INSTRUCTIONS] = 0x00c0,	125	[PERF_COUNT_HW_INSTRUCTIONS] = 0x00c0,
122	[PERF_COUNT_HW_CACHE_REFERENCES] = 0x077d,	126	[PERF_COUNT_HW_CACHE_REFERENCES] = 0x077d,
123	[PERF_COUNT_HW_CACHE_MISSES] = 0x077e,	127	[PERF_COUNT_HW_CACHE_MISSES] = 0x077e,
124	[PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = 0x00c2,	128	[PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = 0x00c2,
125	[PERF_COUNT_HW_BRANCH_MISSES] = 0x00c3,	129	[PERF_COUNT_HW_BRANCH_MISSES] = 0x00c3,
126	[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = 0x00d0, /* "Decoder empty" event */	130	[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = 0x00d0, /* "Decoder empty" event */
127	[PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = 0x00d1, /* "Dispatch stalls" event */	131	[PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = 0x00d1, /* "Dispatch stalls" event */
		132	};
		133
		134	/*
		135	* AMD Performance Monitor Family 17h and later:
		136	*/
		137	static const u64 amd_f17h_perfmon_event_map[PERF_COUNT_HW_MAX] =
		138	{
		139	[PERF_COUNT_HW_CPU_CYCLES] = 0x0076,
		140	[PERF_COUNT_HW_INSTRUCTIONS] = 0x00c0,
		141	[PERF_COUNT_HW_CACHE_REFERENCES] = 0xff60,
		142	[PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = 0x00c2,
		143	[PERF_COUNT_HW_BRANCH_MISSES] = 0x00c3,
		144	[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = 0x0287,
		145	[PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = 0x0187,
128	};	146	};
129		147
130	static u64 amd_pmu_event_map(int hw_event)	148	static u64 amd_pmu_event_map(int hw_event)
131	{	149	{
		150	if (boot_cpu_data.x86 >= 0x17)
		151	return amd_f17h_perfmon_event_map[hw_event];
		152
132	return amd_perfmon_event_map[hw_event];	153	return amd_perfmon_event_map[hw_event];
133	}	154	}
134		155
@@ -429,6 +450,132 @@ static void amd_pmu_cpu_dead(int cpu) · 294 unmodified lines
429	}	450	}
430	}	451	}
431		452
		453	/*
		454	* When a PMC counter overflows, an NMI is used to process the event and
		455	* reset the counter. NMI latency can result in the counter being updated
		456	* before the NMI can run, which can result in what appear to be spurious
		457	* NMIs. This function is intended to wait for the NMI to run and reset
		458	* the counter to avoid possible unhandled NMI messages.
		459	*/
		460	#define OVERFLOW_WAIT_COUNT 50
		461
		462	static void amd_pmu_wait_on_overflow(int idx)
		463	{
		464	unsigned int i;
		465	u64 counter;
		466
		467	/*
		468	* Wait for the counter to be reset if it has overflowed. This loop
		469	* should exit very, very quickly, but just in case, don't wait
		470	* forever...
		471	*/
		472	for (i = 0; i < OVERFLOW_WAIT_COUNT; i++) {
		473	rdmsrl(x86_pmu_event_addr(idx), counter);
		474	if (counter & (1ULL << (x86_pmu.cntval_bits - 1)))
		475	break;
		476
		477	/* Might be in IRQ context, so can't sleep */
		478	udelay(1);
		479	}
		480	}
		481
		482	static void amd_pmu_disable_all(void)
		483	{
		484	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);
		485	int idx;
		486
		487	x86_pmu_disable_all();
		488
		489	/*
		490	* This shouldn't be called from NMI context, but add a safeguard here
		491	* to return, since if we're in NMI context we can't wait for an NMI
		492	* to reset an overflowed counter value.
		493	*/
		494	if (in_nmi())
		495	return;
		496
		497	/*
		498	* Check each counter for overflow and wait for it to be reset by the
		499	* NMI if it has overflowed. This relies on the fact that all active
		500	* counters are always enabled when this function is caled and
		501	* ARCH_PERFMON_EVENTSEL_INT is always set.
		502	*/
		503	for (idx = 0; idx < x86_pmu.num_counters; idx++) {
		504	if (!test_bit(idx, cpuc->active_mask))
		505	continue;
		506
		507	amd_pmu_wait_on_overflow(idx);
		508	}
		509	}
		510
		511	static void amd_pmu_disable_event(struct perf_event *event)
		512	{
		513	x86_pmu_disable_event(event);
		514
		515	/*
		516	* This can be called from NMI context (via x86_pmu_stop). The counter
		517	* may have overflowed, but either way, we'll never see it get reset
		518	* by the NMI if we're already in the NMI. And the NMI latency support
		519	* below will take care of any pending NMI that might have been
		520	* generated by the overflow.
		521	*/
		522	if (in_nmi())
		523	return;
		524
		525	amd_pmu_wait_on_overflow(event->hw.idx);
		526	}
		527
		528	/*
		529	* Because of NMI latency, if multiple PMC counters are active or other sources
		530	* of NMIs are received, the perf NMI handler can handle one or more overflowed
		531	* PMC counters outside of the NMI associated with the PMC overflow. If the NMI
		532	* doesn't arrive at the LAPIC in time to become a pending NMI, then the kernel
		533	* back-to-back NMI support won't be active. This PMC handler needs to take into
		534	* account that this can occur, otherwise this could result in unknown NMI
		535	* messages being issued. Examples of this is PMC overflow while in the NMI
		536	* handler when multiple PMCs are active or PMC overflow while handling some
		537	* other source of an NMI.
		538	*
		539	* Attempt to mitigate this by using the number of active PMCs to determine
		540	* whether to return NMI_HANDLED if the perf NMI handler did not handle/reset
		541	* any PMCs. The per-CPU perf_nmi_counter variable is set to a minimum of the
		542	* number of active PMCs or 2. The value of 2 is used in case an NMI does not
		543	* arrive at the LAPIC in time to be collapsed into an already pending NMI.
		544	*/
		545	static int amd_pmu_handle_irq(struct pt_regs *regs)
		546	{
		547	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);
		548	int active, handled;
		549
		550	/*
		551	* Obtain the active count before calling x86_pmu_handle_irq() since
		552	* it is possible that x86_pmu_handle_irq() may make a counter
		553	* inactive (through x86_pmu_stop).
		554	*/
		555	active = __bitmap_weight(cpuc->active_mask, X86_PMC_IDX_MAX);
		556
		557	/* Process any counter overflows */
		558	handled = x86_pmu_handle_irq(regs);
		559
		560	/*
		561	* If a counter was handled, record the number of possible remaining
		562	* NMIs that can occur.
		563	*/
		564	if (handled) {
		565	this_cpu_write(perf_nmi_counter,
		566	min_t(unsigned int, 2, active));
		567
		568	return handled;
		569	}
		570
		571	if (!this_cpu_read(perf_nmi_counter))
		572	return NMI_DONE;
		573
		574	this_cpu_dec(perf_nmi_counter);
		575
		576	return NMI_HANDLED;
		577	}
		578
432	static struct event_constraint *	579	static struct event_constraint *
433	amd_get_event_constraints(struct cpu_hw_events *cpuc, int idx,	580	amd_get_event_constraints(struct cpu_hw_events *cpuc, int idx,
434	struct perf_event *event)	581	struct perf_event *event)
@@ -621,11 +768,11 @@ static ssize_t amd_event_sysfs_show(char *page, u64 config) · 186 unmodified lines
621		768
622	static __initconst const struct x86_pmu amd_pmu = {	769	static __initconst const struct x86_pmu amd_pmu = {
623	.name = "AMD",	770	.name = "AMD",
624	.handle_irq = x86_pmu_handle_irq,	771	.handle_irq = amd_pmu_handle_irq,
625	.disable_all = x86_pmu_disable_all,	772	.disable_all = amd_pmu_disable_all,
626	.enable_all = x86_pmu_enable_all,	773	.enable_all = x86_pmu_enable_all,
627	.enable = x86_pmu_enable_event,	774	.enable = x86_pmu_enable_event,
628	.disable = x86_pmu_disable_event,	775	.disable = amd_pmu_disable_event,
629	.hw_config = amd_pmu_hw_config,	776	.hw_config = amd_pmu_hw_config,
630	.schedule_events = x86_schedule_events,	777	.schedule_events = x86_schedule_events,
631	.eventsel = MSR_K7_EVNTSEL0,	778	.eventsel = MSR_K7_EVNTSEL0,
@@ -732,7 +879,7 @@ void amd_pmu_enable_virt(void) · 100 unmodified lines
732	cpuc->perf_ctr_virt_mask = 0;	879	cpuc->perf_ctr_virt_mask = 0;
733		880
734	/* Reload all events */	881	/* Reload all events */
735	x86_pmu_disable_all();	882	amd_pmu_disable_all();
736	x86_pmu_enable_all(0);	883	x86_pmu_enable_all(0);
737	}	884	}
738	EXPORT_SYMBOL_GPL(amd_pmu_enable_virt);	885	EXPORT_SYMBOL_GPL(amd_pmu_enable_virt);
@@ -750,7 +897,7 @@ void amd_pmu_disable_virt(void) · 11 unmodified lines
750	cpuc->perf_ctr_virt_mask = AMD64_EVENTSEL_HOSTONLY;	897	cpuc->perf_ctr_virt_mask = AMD64_EVENTSEL_HOSTONLY;
751		898
752	/* Reload all events */	899	/* Reload all events */
753	x86_pmu_disable_all();	900	amd_pmu_disable_all();
754	x86_pmu_enable_all(0);	901	x86_pmu_enable_all(0);
755	}	902	}
756	EXPORT_SYMBOL_GPL(amd_pmu_disable_virt);	903	EXPORT_SYMBOL_GPL(amd_pmu_disable_virt);

arch/x86/events/core.c+3−10

 	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);
 	struct hw_perf_event *hwc = &event->hw;
-	if (__test_and_clear_bit(hwc->idx, cpuc->active_mask)) {
+	if (test_bit(hwc->idx, cpuc->active_mask)) {
 		x86_pmu.disable(event);
+		__clear_bit(hwc->idx, cpuc->active_mask);
 		cpuc->events[hwc->idx] = NULL;
 		WARN_ON_ONCE(hwc->state & PERF_HES_STOPPED);
 		hwc->state |= PERF_HES_STOPPED;
 	apic_write(APIC_LVTPC, APIC_DM_NMI);
 	for (idx = 0; idx < x86_pmu.num_counters; idx++) {
-		if (!test_bit(idx, cpuc->active_mask)) {
+		if (!test_bit(idx, cpuc->active_mask))
-			/*
-			 * Though we deactivated the counter some cpus
-			 * might still deliver spurious interrupts still
-			 * in flight. Catch them:
-			 */
-			if (__test_and_clear_bit(idx, cpuc->running))
-				handled++;
 			continue;
-		}
 		event = cpuc->events[idx];

arch/x86/events/intel/core.c+8−2

 		flags &= ~PERF_SAMPLE_TIME;
 	if (!event->attr.exclude_kernel)
 		flags &= ~PERF_SAMPLE_REGS_USER;
-	if (event->attr.sample_regs_user & ~PEBS_REGS)
+	if (event->attr.sample_regs_user & ~PEBS_GP_REGS)
 		flags &= ~(PERF_SAMPLE_REGS_USER | PERF_SAMPLE_REGS_INTR);
 	return flags;
 }
 		return ret;
 	if (event->attr.precise_ip) {
-		if (!event->attr.freq) {
+		if (!(event->attr.freq || event->attr.wakeup_events)) {
 			event->hw.flags |= PERF_X86_EVENT_AUTO_RELOAD;
 			if (!(event->attr.sample_type &
 			      ~intel_pmu_large_pebs_flags(event)))
 	cpuc->lbr_sel = NULL;
+	if (x86_pmu.flags & PMU_FL_TFA) {
+		WARN_ON_ONCE(cpuc->tfa_shadow);
+		cpuc->tfa_shadow = ~0ULL;
+		intel_set_tfa(cpuc, false);
+	}
 	if (x86_pmu.version > 1)
 		flip_smm_bit(&x86_pmu.attr_freeze_on_smi);

arch/x86/events/perf_event.h+19−19

@@ -96,25 +96,25 @@ struct amd_nb { · 95 unmodified lines
96	PERF_SAMPLE_REGS_INTR \| PERF_SAMPLE_REGS_USER \| \	96	PERF_SAMPLE_REGS_INTR \| PERF_SAMPLE_REGS_USER \| \
97	PERF_SAMPLE_PERIOD)	97	PERF_SAMPLE_PERIOD)
98		98
99	#define PEBS_REGS \	99	#define PEBS_GP_REGS \
100	(PERF_REG_X86_AX \| \	100	((1ULL << PERF_REG_X86_AX) \| \
101	PERF_REG_X86_BX \| \	101	(1ULL << PERF_REG_X86_BX) \| \
102	PERF_REG_X86_CX \| \	102	(1ULL << PERF_REG_X86_CX) \| \
103	PERF_REG_X86_DX \| \	103	(1ULL << PERF_REG_X86_DX) \| \
104	PERF_REG_X86_DI \| \	104	(1ULL << PERF_REG_X86_DI) \| \
105	PERF_REG_X86_SI \| \	105	(1ULL << PERF_REG_X86_SI) \| \
106	PERF_REG_X86_SP \| \	106	(1ULL << PERF_REG_X86_SP) \| \
107	PERF_REG_X86_BP \| \	107	(1ULL << PERF_REG_X86_BP) \| \
108	PERF_REG_X86_IP \| \	108	(1ULL << PERF_REG_X86_IP) \| \
109	PERF_REG_X86_FLAGS \| \	109	(1ULL << PERF_REG_X86_FLAGS) \| \
110	PERF_REG_X86_R8 \| \	110	(1ULL << PERF_REG_X86_R8) \| \
111	PERF_REG_X86_R9 \| \	111	(1ULL << PERF_REG_X86_R9) \| \
112	PERF_REG_X86_R10 \| \	112	(1ULL << PERF_REG_X86_R10) \| \
113	PERF_REG_X86_R11 \| \	113	(1ULL << PERF_REG_X86_R11) \| \
114	PERF_REG_X86_R12 \| \	114	(1ULL << PERF_REG_X86_R12) \| \
115	PERF_REG_X86_R13 \| \	115	(1ULL << PERF_REG_X86_R13) \| \
116	PERF_REG_X86_R14 \| \	116	(1ULL << PERF_REG_X86_R14) \| \
117	PERF_REG_X86_R15)	117	(1ULL << PERF_REG_X86_R15))
118		118
119	/*	119	/*
120	* Per register state.	120	* Per register state.

arch/x86/include/asm/bitops.h+18−23

  * bit 0 is the LSB of addr; bit 32 is the LSB of (addr+1).
  */
-#define BITOP_ADDR(x) "+m" (*(volatile long *) (x))
+#define RLONG_ADDR(x)			 "m" (*(volatile long *) (x))
+#define WBYTE_ADDR(x)			"+m" (*(volatile char *) (x))
-#define ADDR				BITOP_ADDR(addr)
+#define ADDR				RLONG_ADDR(addr)
 /*
  * We do the locked ops that don't return the old value as
  * a mask operation on a byte.
  */
 #define IS_IMMEDIATE(nr)		(__builtin_constant_p(nr))
-#define CONST_MASK_ADDR(nr, addr)	BITOP_ADDR((void *)(addr) + ((nr)>>3))
+#define CONST_MASK_ADDR(nr, addr)	WBYTE_ADDR((void *)(addr) + ((nr)>>3))
 #define CONST_MASK(nr)			(1 << ((nr) & 7))
 /**
 			: "memory");
 	} else {
 		asm volatile(LOCK_PREFIX __ASM_SIZE(bts) " %1,%0"
-			: BITOP_ADDR(addr) : "Ir" (nr) : "memory");
+			: : RLONG_ADDR(addr), "Ir" (nr) : "memory");
 	}
 }
  */
 static __always_inline void __set_bit(long nr, volatile unsigned long *addr)
 {
-	asm volatile(__ASM_SIZE(bts) " %1,%0" : ADDR : "Ir" (nr) : "memory");
+	asm volatile(__ASM_SIZE(bts) " %1,%0" : : ADDR, "Ir" (nr) : "memory");
 }
 /**
 			: "iq" ((u8)~CONST_MASK(nr)));
 	} else {
 		asm volatile(LOCK_PREFIX __ASM_SIZE(btr) " %1,%0"
-			: BITOP_ADDR(addr)
+			: : RLONG_ADDR(addr), "Ir" (nr) : "memory");
-			: "Ir" (nr));
 	}
 }
 static __always_inline void __clear_bit(long nr, volatile unsigned long *addr)
 {
-	asm volatile(__ASM_SIZE(btr) " %1,%0" : ADDR : "Ir" (nr));
+	asm volatile(__ASM_SIZE(btr) " %1,%0" : : ADDR, "Ir" (nr) : "memory");
 }
 static __always_inline bool clear_bit_unlock_is_negative_byte(long nr, volatile unsigned long *addr)
 	bool negative;
 	asm volatile(LOCK_PREFIX "andb %2,%1"
 		CC_SET(s)
-		: CC_OUT(s) (negative), ADDR
+		: CC_OUT(s) (negative), WBYTE_ADDR(addr)
 		: "ir" ((char) ~(1 << nr)) : "memory");
 	return negative;
 }
  * __clear_bit() is non-atomic and implies release semantics before the memory
  * operation. It can be used for an unlock if no other CPUs can concurrently
  * modify other bits in the word.
- *
- * No memory barrier is required here, because x86 cannot reorder stores past
- * older loads. Same principle as spin_unlock.
  */
 static __always_inline void __clear_bit_unlock(long nr, volatile unsigned long *addr)
 {
-	barrier();
 	__clear_bit(nr, addr);
 }
  */
 static __always_inline void __change_bit(long nr, volatile unsigned long *addr)
 {
-	asm volatile(__ASM_SIZE(btc) " %1,%0" : ADDR : "Ir" (nr));
+	asm volatile(__ASM_SIZE(btc) " %1,%0" : : ADDR, "Ir" (nr) : "memory");
 }
 /**
 			: "iq" ((u8)CONST_MASK(nr)));
 	} else {
 		asm volatile(LOCK_PREFIX __ASM_SIZE(btc) " %1,%0"
-			: BITOP_ADDR(addr)
+			: : RLONG_ADDR(addr), "Ir" (nr) : "memory");
-			: "Ir" (nr));
 	}
 }
 	asm(__ASM_SIZE(bts) " %2,%1"
 	    CC_SET(c)
-	    : CC_OUT(c) (oldbit), ADDR
+	    : CC_OUT(c) (oldbit)
-	    : "Ir" (nr));
+	    : ADDR, "Ir" (nr) : "memory");
 	return oldbit;
 }
 	asm volatile(__ASM_SIZE(btr) " %2,%1"
 		     CC_SET(c)
-		     : CC_OUT(c) (oldbit), ADDR
+		     : CC_OUT(c) (oldbit)
-		     : "Ir" (nr));
+		     : ADDR, "Ir" (nr) : "memory");
 	return oldbit;
 }
 	asm volatile(__ASM_SIZE(btc) " %2,%1"
 		     CC_SET(c)
-		     : CC_OUT(c) (oldbit), ADDR
+		     : CC_OUT(c) (oldbit)
-		     : "Ir" (nr) : "memory");
+		     : ADDR, "Ir" (nr) : "memory");
 	return oldbit;
 }
 	asm volatile(__ASM_SIZE(bt) " %2,%1"
 		     CC_SET(c)
 		     : CC_OUT(c) (oldbit)
-		     : "m" (*(unsigned long *)addr), "Ir" (nr));
+		     : "m" (*(unsigned long *)addr), "Ir" (nr) : "memory");
 	return oldbit;
 }

arch/x86/include/asm/kvm_emulate.h+3−1

@@ -226,7 +226,9 @@ struct x86_emulate_ops { · 225 unmodified lines
226		226
227	unsigned (get_hflags)(struct x86_emulate_ctxt ctxt);	227	unsigned (get_hflags)(struct x86_emulate_ctxt ctxt);
228	void (set_hflags)(struct x86_emulate_ctxt ctxt, unsigned hflags);	228	void (set_hflags)(struct x86_emulate_ctxt ctxt, unsigned hflags);
229	int (pre_leave_smm)(struct x86_emulate_ctxt ctxt, u64 smbase);	229	int (pre_leave_smm)(struct x86_emulate_ctxt ctxt,
		230	const char *smstate);
		231	void (post_leave_smm)(struct x86_emulate_ctxt ctxt);
230		232
231	};	233	};
232		234

arch/x86/include/asm/kvm_host.h+10−7

 }
 #define KVM_PERMILLE_MMU_PAGES 20
-#define KVM_MIN_ALLOC_MMU_PAGES 64
+#define KVM_MIN_ALLOC_MMU_PAGES 64UL
 #define KVM_MMU_HASH_SHIFT 12
 #define KVM_NUM_MMU_PAGES (1 << KVM_MMU_HASH_SHIFT)
 #define KVM_MIN_FREE_MMU_PAGES 5
 };
 struct kvm_arch {
-	unsigned int n_used_mmu_pages;
+	unsigned long n_used_mmu_pages;
-	unsigned int n_requested_mmu_pages;
+	unsigned long n_requested_mmu_pages;
-	unsigned int n_max_mmu_pages;
+	unsigned long n_max_mmu_pages;
 	unsigned int indirect_shadow_pages;
 	struct hlist_head mmu_page_hash[KVM_NUM_MMU_PAGES];
 	/*
 	int (*smi_allowed)(struct kvm_vcpu *vcpu);
 	int (*pre_enter_smm)(struct kvm_vcpu *vcpu, char *smstate);
-	int (*pre_leave_smm)(struct kvm_vcpu *vcpu, u64 smbase);
+	int (*pre_leave_smm)(struct kvm_vcpu *vcpu, const char *smstate);
 	int (*enable_smi_window)(struct kvm_vcpu *vcpu);
 	int (*mem_enc_op)(struct kvm *kvm, void __user *argp);
 				   gfn_t gfn_offset, unsigned long mask);
 void kvm_mmu_zap_all(struct kvm *kvm);
 void kvm_mmu_invalidate_mmio_sptes(struct kvm *kvm, u64 gen);
-unsigned int kvm_mmu_calculate_default_mmu_pages(struct kvm *kvm);
+unsigned long kvm_mmu_calculate_default_mmu_pages(struct kvm *kvm);
-void kvm_mmu_change_mmu_pages(struct kvm *kvm, unsigned int kvm_nr_mmu_pages);
+void kvm_mmu_change_mmu_pages(struct kvm *kvm, unsigned long kvm_nr_mmu_pages);
 int load_pdptrs(struct kvm_vcpu *vcpu, struct kvm_mmu *mmu, unsigned long cr3);
 bool pdptrs_changed(struct kvm_vcpu *vcpu);
 #define put_smstate(type, buf, offset, val)                      \
 	*(type *)((buf) + (offset) - 0x7e00) = val
+#define GET_SMSTATE(type, buf, offset)		\
+	(*(type *)((buf) + (offset) - 0x7e00))
 #endif /* _ASM_X86_KVM_HOST_H */

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/include/uapi/asm/vmx.h+1−0

@@ -146,6 +146,7 @@ · 145 unmodified lines
146		146
147	#define VMX_ABORT_SAVE_GUEST_MSR_FAIL 1	147	#define VMX_ABORT_SAVE_GUEST_MSR_FAIL 1
148	#define VMX_ABORT_LOAD_HOST_PDPTE_FAIL 2	148	#define VMX_ABORT_LOAD_HOST_PDPTE_FAIL 2
		149	#define VMX_ABORT_VMCS_CORRUPTED 3
149	#define VMX_ABORT_LOAD_HOST_MSR_FAIL 4	150	#define VMX_ABORT_LOAD_HOST_MSR_FAIL 4
150		151
151	#endif /* _UAPIVMX_H */	152	#endif /* _UAPIVMX_H */

arch/x86/kernel/cpu/bugs.c+3−3

@@ -275,7 +275,7 @@ static const struct { · 274 unmodified lines
275	const char *option;	275	const char *option;
276	enum spectre_v2_user_cmd cmd;	276	enum spectre_v2_user_cmd cmd;
277	bool secure;	277	bool secure;
278	} v2_user_options[] __initdata = {	278	} v2_user_options[] __initconst = {
279	{ "auto", SPECTRE_V2_USER_CMD_AUTO, false },	279	{ "auto", SPECTRE_V2_USER_CMD_AUTO, false },
280	{ "off", SPECTRE_V2_USER_CMD_NONE, false },	280	{ "off", SPECTRE_V2_USER_CMD_NONE, false },
281	{ "on", SPECTRE_V2_USER_CMD_FORCE, true },	281	{ "on", SPECTRE_V2_USER_CMD_FORCE, true },
@@ -419,7 +419,7 @@ static const struct { · 137 unmodified lines
419	const char *option;	419	const char *option;
420	enum spectre_v2_mitigation_cmd cmd;	420	enum spectre_v2_mitigation_cmd cmd;
421	bool secure;	421	bool secure;
422	} mitigation_options[] __initdata = {	422	} mitigation_options[] __initconst = {
423	{ "off", SPECTRE_V2_CMD_NONE, false },	423	{ "off", SPECTRE_V2_CMD_NONE, false },
424	{ "on", SPECTRE_V2_CMD_FORCE, true },	424	{ "on", SPECTRE_V2_CMD_FORCE, true },
425	{ "retpoline", SPECTRE_V2_CMD_RETPOLINE, false },	425	{ "retpoline", SPECTRE_V2_CMD_RETPOLINE, false },
@@ -658,7 +658,7 @@ static const char * const ssb_strings[] = { · 232 unmodified lines
658	static const struct {	658	static const struct {
659	const char *option;	659	const char *option;
660	enum ssb_mitigation_cmd cmd;	660	enum ssb_mitigation_cmd cmd;
661	} ssb_mitigation_options[] __initdata = {	661	} ssb_mitigation_options[] __initconst = {
662	{ "auto", SPEC_STORE_BYPASS_CMD_AUTO }, /* Platform decides */	662	{ "auto", SPEC_STORE_BYPASS_CMD_AUTO }, /* Platform decides */
663	{ "on", SPEC_STORE_BYPASS_CMD_ON }, /* Disable Speculative Store Bypass */	663	{ "on", SPEC_STORE_BYPASS_CMD_ON }, /* Disable Speculative Store Bypass */
664	{ "off", SPEC_STORE_BYPASS_CMD_NONE }, /* Don't touch Speculative Store Bypass */	664	{ "off", SPEC_STORE_BYPASS_CMD_NONE }, /* Don't touch Speculative Store Bypass */

arch/x86/kernel/cpu/intel.c+2−2

@@ -611,8 +611,8 @@ static void init_intel_energy_perf(struct cpuinfo_x86 *c) · 610 unmodified lines
611	if ((epb & 0xF) != ENERGY_PERF_BIAS_PERFORMANCE)	611	if ((epb & 0xF) != ENERGY_PERF_BIAS_PERFORMANCE)
612	return;	612	return;
613		613
614	pr_warn_once("ENERGY_PERF_BIAS: Set to 'normal', was 'performance'\n");	614	pr_info_once("ENERGY_PERF_BIAS: Set to 'normal', was 'performance'\n");
615	pr_warn_once("ENERGY_PERF_BIAS: View and update with x86_energy_perf_policy(8)\n");	615	pr_info_once("ENERGY_PERF_BIAS: View and update with x86_energy_perf_policy(8)\n");
616	epb = (epb & ~0xF) \| ENERGY_PERF_BIAS_NORMAL;	616	epb = (epb & ~0xF) \| ENERGY_PERF_BIAS_NORMAL;
617	wrmsrl(MSR_IA32_ENERGY_PERF_BIAS, epb);	617	wrmsrl(MSR_IA32_ENERGY_PERF_BIAS, epb);
618	}	618	}

arch/x86/kernel/cpu/resctrl/rdtgroup.c+5−4

 enum rdt_param {
 	Opt_cdp,
 	Opt_cdpl2,
-	Opt_mba_mpbs,
+	Opt_mba_mbps,
 	nr__rdt_params
 };
 static const struct fs_parameter_spec rdt_param_specs[] = {
 	fsparam_flag("cdp",		Opt_cdp),
 	fsparam_flag("cdpl2",		Opt_cdpl2),
-	fsparam_flag("mba_mpbs",	Opt_mba_mpbs),
+	fsparam_flag("mba_MBps",	Opt_mba_mbps),
 	{}
 };
 	case Opt_cdpl2:
 		ctx->enable_cdpl2 = true;
 		return 0;
-	case Opt_mba_mpbs:
+	case Opt_mba_mbps:
 		if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL)
 			return -EINVAL;
 		ctx->enable_mba_mbps = true;
 			rdt_last_cmd_puts("Failed to initialize allocations\n");
 			return ret;
 		}
-		rdtgrp->mode = RDT_MODE_SHAREABLE;
 	}
+	rdtgrp->mode = RDT_MODE_SHAREABLE;
 	return 0;
 }

arch/x86/kernel/kprobes/core.c+46−2

 	unsigned long *sara = stack_addr(regs);
 	ri->ret_addr = (kprobe_opcode_t *) *sara;
+	ri->fp = sara;
 	/* Replace the return addr with trampoline addr */
 	*sara = (unsigned long) &kretprobe_trampoline;
 NOKPROBE_SYMBOL(kretprobe_trampoline);
 STACK_FRAME_NON_STANDARD(kretprobe_trampoline);
+static struct kprobe kretprobe_kprobe = {
+	.addr = (void *)kretprobe_trampoline,
+};
 /*
  * Called from kretprobe_trampoline
  */
 static __used void *trampoline_handler(struct pt_regs *regs)
 {
+	struct kprobe_ctlblk *kcb;
 	struct kretprobe_instance *ri = NULL;
 	struct hlist_head *head, empty_rp;
 	struct hlist_node *tmp;
 	unsigned long flags, orig_ret_address = 0;
 	unsigned long trampoline_address = (unsigned long)&kretprobe_trampoline;
 	kprobe_opcode_t *correct_ret_addr = NULL;
+	void *frame_pointer;
+	bool skipped = false;
+	preempt_disable();
+	/*
+	 * Set a dummy kprobe for avoiding kretprobe recursion.
+	 * Since kretprobe never run in kprobe handler, kprobe must not
+	 * be running at this point.
+	 */
+	kcb = get_kprobe_ctlblk();
+	__this_cpu_write(current_kprobe, &kretprobe_kprobe);
+	kcb->kprobe_status = KPROBE_HIT_ACTIVE;
 	INIT_HLIST_HEAD(&empty_rp);
 	kretprobe_hash_lock(current, &head, &flags);
 	/* fixup registers */
 #ifdef CONFIG_X86_64
 	regs->cs = __KERNEL_CS;
+	/* On x86-64, we use pt_regs->sp for return address holder. */
+	frame_pointer = &regs->sp;
 #else
 	regs->cs = __KERNEL_CS | get_kernel_rpl();
 	regs->gs = 0;
+	/* On x86-32, we use pt_regs->flags for return address holder. */
+	frame_pointer = &regs->flags;
 #endif
 	regs->ip = trampoline_address;
 	regs->orig_ax = ~0UL;
 		if (ri->task != current)
 			/* another task is sharing our hash bucket */
 			continue;
+		/*
+		 * Return probes must be pushed on this hash list correct
+		 * order (same as return order) so that it can be poped
+		 * correctly. However, if we find it is pushed it incorrect
+		 * order, this means we find a function which should not be
+		 * probed, because the wrong order entry is pushed on the
+		 * path of processing other kretprobe itself.
+		 */
+		if (ri->fp != frame_pointer) {
+			if (!skipped)
+				pr_warn("kretprobe is stacked incorrectly. Trying to fixup.\n");
+			skipped = true;
+			continue;
+		}
 		orig_ret_address = (unsigned long)ri->ret_addr;
+		if (skipped)
+			pr_warn("%ps must be blacklisted because of incorrect kretprobe order\n",
+				ri->rp->kp.addr);
 		if (orig_ret_address != trampoline_address)
 			/*
 		if (ri->task != current)
 			/* another task is sharing our hash bucket */
 			continue;
+		if (ri->fp != frame_pointer)
+			continue;
 		orig_ret_address = (unsigned long)ri->ret_addr;
 		if (ri->rp && ri->rp->handler) {
 			__this_cpu_write(current_kprobe, &ri->rp->kp);
-			get_kprobe_ctlblk()->kprobe_status = KPROBE_HIT_ACTIVE;
 			ri->ret_addr = correct_ret_addr;
 			ri->rp->handler(ri, regs);
-			__this_cpu_write(current_kprobe, NULL);
+			__this_cpu_write(current_kprobe, &kretprobe_kprobe);
 		}
 		recycle_rp_inst(ri, &empty_rp);
 	kretprobe_hash_unlock(current, &flags);
+	__this_cpu_write(current_kprobe, NULL);
+	preempt_enable();
 	hlist_for_each_entry_safe(ri, tmp, &empty_rp, hlist) {
 		hlist_del(&ri->hlist);
 		kfree(ri);

arch/x86/kernel/process.c+6−2

 	u64 msr = x86_spec_ctrl_base;
 	bool updmsr = false;
+	lockdep_assert_irqs_disabled();
 	/*
 	 * If TIF_SSBD is different, select the proper mitigation
 	 * method. Note that if SSBD mitigation is disabled or permanentely
 void speculation_ctrl_update(unsigned long tif)
 {
+	unsigned long flags;
 	/* Forced update. Make sure all relevant TIF flags are different */
-	preempt_disable();
+	local_irq_save(flags);
 	__speculation_ctrl_update(~tif, tif);
-	preempt_enable();
+	local_irq_restore(flags);
 }
 /* Called from seccomp/prctl update */

arch/x86/kernel/reboot.c+21−0

@@ -81,6 +81,19 @@ static int __init set_bios_reboot(const struct dmi_system_id *d) · 80 unmodified lines
81	return 0;	81	return 0;
82	}	82	}
83		83
		84	/*
		85	* Some machines don't handle the default ACPI reboot method and
		86	* require the EFI reboot method:
		87	*/
		88	static int __init set_efi_reboot(const struct dmi_system_id *d)
		89	{
		90	if (reboot_type != BOOT_EFI && !efi_runtime_disabled()) {
		91	reboot_type = BOOT_EFI;
		92	pr_info("%s series board detected. Selecting EFI-method for reboot.\n", d->ident);
		93	}
		94	return 0;
		95	}
		96
84	void __noreturn machine_real_restart(unsigned int type)	97	void __noreturn machine_real_restart(unsigned int type)
85	{	98	{
86	local_irq_disable();	99	local_irq_disable();
@@ -166,6 +179,14 @@ static const struct dmi_system_id reboot_dmi_table[] __initconst = { · 79 unmodified lines
166	DMI_MATCH(DMI_PRODUCT_NAME, "AOA110"),	179	DMI_MATCH(DMI_PRODUCT_NAME, "AOA110"),
167	},	180	},
168	},	181	},
		182	{ /* Handle reboot issue on Acer TravelMate X514-51T */
		183	.callback = set_efi_reboot,
		184	.ident = "Acer TravelMate X514-51T",
		185	.matches = {
		186	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
		187	DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate X514-51T"),
		188	},
		189	},
169		190
170	/* Apple */	191	/* Apple */
171	{ /* Handle problems with rebooting on Apple MacBook5 */	192	{ /* Handle problems with rebooting on Apple MacBook5 */

arch/x86/kernel/vmlinux.lds.S+1−1

@@ -362,7 +362,7 @@ SECTIONS · 361 unmodified lines
362	.bss : AT(ADDR(.bss) - LOAD_OFFSET) {	362	.bss : AT(ADDR(.bss) - LOAD_OFFSET) {
363	__bss_start = .;	363	__bss_start = .;
364	*(.bss..page_aligned)	364	*(.bss..page_aligned)
365	*(.bss)	365	*(BSS_MAIN)
366	BSS_DECRYPTED	366	BSS_DECRYPTED
367	. = ALIGN(PAGE_SIZE);	367	. = ALIGN(PAGE_SIZE);
368	__bss_stop = .;	368	__bss_stop = .;

arch/x86/kvm/emulate.c+102−89

@@ -2331,24 +2331,18 @@ static int em_lseg(struct x86_emulate_ctxt *ctxt) · 2330 unmodified lines
2331		2331
2332	static int emulator_has_longmode(struct x86_emulate_ctxt *ctxt)	2332	static int emulator_has_longmode(struct x86_emulate_ctxt *ctxt)
2333	{	2333	{
		2334	#ifdef CONFIG_X86_64
2334	u32 eax, ebx, ecx, edx;	2335	u32 eax, ebx, ecx, edx;
2335		2336
2336	eax = 0x80000001;	2337	eax = 0x80000001;
2337	ecx = 0;	2338	ecx = 0;
2338	ctxt->ops->get_cpuid(ctxt, &eax, &ebx, &ecx, &edx, false);	2339	ctxt->ops->get_cpuid(ctxt, &eax, &ebx, &ecx, &edx, false);
2339	return edx & bit(X86_FEATURE_LM);	2340	return edx & bit(X86_FEATURE_LM);
		2341	#else
		2342	return false;
		2343	#endif
2340	}	2344	}
2341		2345
2342	#define GET_SMSTATE(type, smbase, offset) \
2343	({ \
2344	type __val; \
2345	int r = ctxt->ops->read_phys(ctxt, smbase + offset, &__val, \
2346	sizeof(__val)); \
2347	if (r != X86EMUL_CONTINUE) \
2348	return X86EMUL_UNHANDLEABLE; \
2349	__val; \
2350	})
2351
2352	static void rsm_set_desc_flags(struct desc_struct *desc, u32 flags)	2346	static void rsm_set_desc_flags(struct desc_struct *desc, u32 flags)
2353	{	2347	{
2354	desc->g = (flags >> 23) & 1;	2348	desc->g = (flags >> 23) & 1;
@@ -2361,27 +2355,30 @@ static void rsm_set_desc_flags(struct desc_struct *desc, u32 flags) · 6 unmodified lines
2361	desc->type = (flags >> 8) & 15;	2355	desc->type = (flags >> 8) & 15;
2362	}	2356	}
2363		2357
2364	static int rsm_load_seg_32(struct x86_emulate_ctxt *ctxt, u64 smbase, int n)	2358	static int rsm_load_seg_32(struct x86_emulate_ctxt ctxt, const char smstate,
		2359	int n)
2365	{	2360	{
2366	struct desc_struct desc;	2361	struct desc_struct desc;
2367	int offset;	2362	int offset;
2368	u16 selector;	2363	u16 selector;
2369		2364
2370	selector = GET_SMSTATE(u32, smbase, 0x7fa8 + n * 4);	2365	selector = GET_SMSTATE(u32, smstate, 0x7fa8 + n * 4);
2371		2366
2372	if (n < 3)	2367	if (n < 3)
2373	offset = 0x7f84 + n * 12;	2368	offset = 0x7f84 + n * 12;
2374	else	2369	else
2375	offset = 0x7f2c + (n - 3) * 12;	2370	offset = 0x7f2c + (n - 3) * 12;
2376		2371
2377	set_desc_base(&desc, GET_SMSTATE(u32, smbase, offset + 8));	2372	set_desc_base(&desc, GET_SMSTATE(u32, smstate, offset + 8));
2378	set_desc_limit(&desc, GET_SMSTATE(u32, smbase, offset + 4));	2373	set_desc_limit(&desc, GET_SMSTATE(u32, smstate, offset + 4));
2379	rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smbase, offset));	2374	rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smstate, offset));
2380	ctxt->ops->set_segment(ctxt, selector, &desc, 0, n);	2375	ctxt->ops->set_segment(ctxt, selector, &desc, 0, n);
2381	return X86EMUL_CONTINUE;	2376	return X86EMUL_CONTINUE;
2382	}	2377	}
2383		2378
2384	static int rsm_load_seg_64(struct x86_emulate_ctxt *ctxt, u64 smbase, int n)	2379	#ifdef CONFIG_X86_64
		2380	static int rsm_load_seg_64(struct x86_emulate_ctxt ctxt, const char smstate,
		2381	int n)
2385	{	2382	{
2386	struct desc_struct desc;	2383	struct desc_struct desc;
2387	int offset;	2384	int offset;
@@ -2390,15 +2387,16 @@ static int rsm_load_seg_64(struct x86_emulate_ctxt *ctxt, u64 smbase, int n) · 2 unmodified lines
2390		2387
2391	offset = 0x7e00 + n * 16;	2388	offset = 0x7e00 + n * 16;
2392		2389
2393	selector = GET_SMSTATE(u16, smbase, offset);	2390	selector = GET_SMSTATE(u16, smstate, offset);
2394	rsm_set_desc_flags(&desc, GET_SMSTATE(u16, smbase, offset + 2) << 8);	2391	rsm_set_desc_flags(&desc, GET_SMSTATE(u16, smstate, offset + 2) << 8);
2395	set_desc_limit(&desc, GET_SMSTATE(u32, smbase, offset + 4));	2392	set_desc_limit(&desc, GET_SMSTATE(u32, smstate, offset + 4));
2396	set_desc_base(&desc, GET_SMSTATE(u32, smbase, offset + 8));	2393	set_desc_base(&desc, GET_SMSTATE(u32, smstate, offset + 8));
2397	base3 = GET_SMSTATE(u32, smbase, offset + 12);	2394	base3 = GET_SMSTATE(u32, smstate, offset + 12);
2398		2395
2399	ctxt->ops->set_segment(ctxt, selector, &desc, base3, n);	2396	ctxt->ops->set_segment(ctxt, selector, &desc, base3, n);
2400	return X86EMUL_CONTINUE;	2397	return X86EMUL_CONTINUE;
2401	}	2398	}
		2399	#endif
2402		2400
2403	static int rsm_enter_protected_mode(struct x86_emulate_ctxt *ctxt,	2401	static int rsm_enter_protected_mode(struct x86_emulate_ctxt *ctxt,
2404	u64 cr0, u64 cr3, u64 cr4)	2402	u64 cr0, u64 cr3, u64 cr4)
@@ -2445,7 +2443,8 @@ static int rsm_enter_protected_mode(struct x86_emulate_ctxt *ctxt, · 40 unmodified lines
2445	return X86EMUL_CONTINUE;	2443	return X86EMUL_CONTINUE;
2446	}	2444	}
2447		2445
2448	static int rsm_load_state_32(struct x86_emulate_ctxt *ctxt, u64 smbase)	2446	static int rsm_load_state_32(struct x86_emulate_ctxt *ctxt,
		2447	const char *smstate)
2449	{	2448	{
2450	struct desc_struct desc;	2449	struct desc_struct desc;
2451	struct desc_ptr dt;	2450	struct desc_ptr dt;
@@ -2453,53 +2452,55 @@ static int rsm_load_state_32(struct x86_emulate_ctxt *ctxt, u64 smbase) · 1 unmodified line
2453	u32 val, cr0, cr3, cr4;	2452	u32 val, cr0, cr3, cr4;
2454	int i;	2453	int i;
2455		2454
2456	cr0 = GET_SMSTATE(u32, smbase, 0x7ffc);	2455	cr0 = GET_SMSTATE(u32, smstate, 0x7ffc);
2457	cr3 = GET_SMSTATE(u32, smbase, 0x7ff8);	2456	cr3 = GET_SMSTATE(u32, smstate, 0x7ff8);
2458	ctxt->eflags = GET_SMSTATE(u32, smbase, 0x7ff4) \| X86_EFLAGS_FIXED;	2457	ctxt->eflags = GET_SMSTATE(u32, smstate, 0x7ff4) \| X86_EFLAGS_FIXED;
2459	ctxt->_eip = GET_SMSTATE(u32, smbase, 0x7ff0);	2458	ctxt->_eip = GET_SMSTATE(u32, smstate, 0x7ff0);
2460		2459
2461	for (i = 0; i < 8; i++)	2460	for (i = 0; i < 8; i++)
2462	reg_write(ctxt, i) = GET_SMSTATE(u32, smbase, 0x7fd0 + i 4);	2461	reg_write(ctxt, i) = GET_SMSTATE(u32, smstate, 0x7fd0 + i 4);
2463		2462
2464	val = GET_SMSTATE(u32, smbase, 0x7fcc);	2463	val = GET_SMSTATE(u32, smstate, 0x7fcc);
2465	ctxt->ops->set_dr(ctxt, 6, (val & DR6_VOLATILE) \| DR6_FIXED_1);	2464	ctxt->ops->set_dr(ctxt, 6, (val & DR6_VOLATILE) \| DR6_FIXED_1);
2466	val = GET_SMSTATE(u32, smbase, 0x7fc8);	2465	val = GET_SMSTATE(u32, smstate, 0x7fc8);
2467	ctxt->ops->set_dr(ctxt, 7, (val & DR7_VOLATILE) \| DR7_FIXED_1);	2466	ctxt->ops->set_dr(ctxt, 7, (val & DR7_VOLATILE) \| DR7_FIXED_1);
2468		2467
2469	selector = GET_SMSTATE(u32, smbase, 0x7fc4);	2468	selector = GET_SMSTATE(u32, smstate, 0x7fc4);
2470	set_desc_base(&desc, GET_SMSTATE(u32, smbase, 0x7f64));	2469	set_desc_base(&desc, GET_SMSTATE(u32, smstate, 0x7f64));
2471	set_desc_limit(&desc, GET_SMSTATE(u32, smbase, 0x7f60));	2470	set_desc_limit(&desc, GET_SMSTATE(u32, smstate, 0x7f60));
2472	rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smbase, 0x7f5c));	2471	rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smstate, 0x7f5c));
2473	ctxt->ops->set_segment(ctxt, selector, &desc, 0, VCPU_SREG_TR);	2472	ctxt->ops->set_segment(ctxt, selector, &desc, 0, VCPU_SREG_TR);
2474		2473
2475	selector = GET_SMSTATE(u32, smbase, 0x7fc0);	2474	selector = GET_SMSTATE(u32, smstate, 0x7fc0);
2476	set_desc_base(&desc, GET_SMSTATE(u32, smbase, 0x7f80));	2475	set_desc_base(&desc, GET_SMSTATE(u32, smstate, 0x7f80));
2477	set_desc_limit(&desc, GET_SMSTATE(u32, smbase, 0x7f7c));	2476	set_desc_limit(&desc, GET_SMSTATE(u32, smstate, 0x7f7c));
2478	rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smbase, 0x7f78));	2477	rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smstate, 0x7f78));
2479	ctxt->ops->set_segment(ctxt, selector, &desc, 0, VCPU_SREG_LDTR);	2478	ctxt->ops->set_segment(ctxt, selector, &desc, 0, VCPU_SREG_LDTR);
2480		2479
2481	dt.address = GET_SMSTATE(u32, smbase, 0x7f74);	2480	dt.address = GET_SMSTATE(u32, smstate, 0x7f74);
2482	dt.size = GET_SMSTATE(u32, smbase, 0x7f70);	2481	dt.size = GET_SMSTATE(u32, smstate, 0x7f70);
2483	ctxt->ops->set_gdt(ctxt, &dt);	2482	ctxt->ops->set_gdt(ctxt, &dt);
2484		2483
2485	dt.address = GET_SMSTATE(u32, smbase, 0x7f58);	2484	dt.address = GET_SMSTATE(u32, smstate, 0x7f58);
2486	dt.size = GET_SMSTATE(u32, smbase, 0x7f54);	2485	dt.size = GET_SMSTATE(u32, smstate, 0x7f54);
2487	ctxt->ops->set_idt(ctxt, &dt);	2486	ctxt->ops->set_idt(ctxt, &dt);
2488		2487
2489	for (i = 0; i < 6; i++) {	2488	for (i = 0; i < 6; i++) {
2490	int r = rsm_load_seg_32(ctxt, smbase, i);	2489	int r = rsm_load_seg_32(ctxt, smstate, i);
2491	if (r != X86EMUL_CONTINUE)	2490	if (r != X86EMUL_CONTINUE)
2492	return r;	2491	return r;
2493	}	2492	}
2494		2493
2495	cr4 = GET_SMSTATE(u32, smbase, 0x7f14);	2494	cr4 = GET_SMSTATE(u32, smstate, 0x7f14);
2496		2495
2497	ctxt->ops->set_smbase(ctxt, GET_SMSTATE(u32, smbase, 0x7ef8));	2496	ctxt->ops->set_smbase(ctxt, GET_SMSTATE(u32, smstate, 0x7ef8));
2498		2497
2499	return rsm_enter_protected_mode(ctxt, cr0, cr3, cr4);	2498	return rsm_enter_protected_mode(ctxt, cr0, cr3, cr4);
2500	}	2499	}
2501		2500
2502	static int rsm_load_state_64(struct x86_emulate_ctxt *ctxt, u64 smbase)	2501	#ifdef CONFIG_X86_64
		2502	static int rsm_load_state_64(struct x86_emulate_ctxt *ctxt,
		2503	const char *smstate)
2503	{	2504	{
2504	struct desc_struct desc;	2505	struct desc_struct desc;
2505	struct desc_ptr dt;	2506	struct desc_ptr dt;
@@ -2509,43 +2510,43 @@ static int rsm_load_state_64(struct x86_emulate_ctxt *ctxt, u64 smbase) · 3 unmodified lines
2509	int i, r;	2510	int i, r;
2510		2511
2511	for (i = 0; i < 16; i++)	2512	for (i = 0; i < 16; i++)
2512	reg_write(ctxt, i) = GET_SMSTATE(u64, smbase, 0x7ff8 - i 8);	2513	reg_write(ctxt, i) = GET_SMSTATE(u64, smstate, 0x7ff8 - i 8);
2513		2514
2514	ctxt->_eip = GET_SMSTATE(u64, smbase, 0x7f78);	2515	ctxt->_eip = GET_SMSTATE(u64, smstate, 0x7f78);
2515	ctxt->eflags = GET_SMSTATE(u32, smbase, 0x7f70) \| X86_EFLAGS_FIXED;	2516	ctxt->eflags = GET_SMSTATE(u32, smstate, 0x7f70) \| X86_EFLAGS_FIXED;
2516		2517
2517	val = GET_SMSTATE(u32, smbase, 0x7f68);	2518	val = GET_SMSTATE(u32, smstate, 0x7f68);
2518	ctxt->ops->set_dr(ctxt, 6, (val & DR6_VOLATILE) \| DR6_FIXED_1);	2519	ctxt->ops->set_dr(ctxt, 6, (val & DR6_VOLATILE) \| DR6_FIXED_1);
2519	val = GET_SMSTATE(u32, smbase, 0x7f60);	2520	val = GET_SMSTATE(u32, smstate, 0x7f60);
2520	ctxt->ops->set_dr(ctxt, 7, (val & DR7_VOLATILE) \| DR7_FIXED_1);	2521	ctxt->ops->set_dr(ctxt, 7, (val & DR7_VOLATILE) \| DR7_FIXED_1);
2521		2522
2522	cr0 = GET_SMSTATE(u64, smbase, 0x7f58);	2523	cr0 = GET_SMSTATE(u64, smstate, 0x7f58);
2523	cr3 = GET_SMSTATE(u64, smbase, 0x7f50);	2524	cr3 = GET_SMSTATE(u64, smstate, 0x7f50);
2524	cr4 = GET_SMSTATE(u64, smbase, 0x7f48);	2525	cr4 = GET_SMSTATE(u64, smstate, 0x7f48);
2525	ctxt->ops->set_smbase(ctxt, GET_SMSTATE(u32, smbase, 0x7f00));	2526	ctxt->ops->set_smbase(ctxt, GET_SMSTATE(u32, smstate, 0x7f00));
2526	val = GET_SMSTATE(u64, smbase, 0x7ed0);	2527	val = GET_SMSTATE(u64, smstate, 0x7ed0);
2527	ctxt->ops->set_msr(ctxt, MSR_EFER, val & ~EFER_LMA);	2528	ctxt->ops->set_msr(ctxt, MSR_EFER, val & ~EFER_LMA);
2528		2529
2529	selector = GET_SMSTATE(u32, smbase, 0x7e90);	2530	selector = GET_SMSTATE(u32, smstate, 0x7e90);
2530	rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smbase, 0x7e92) << 8);	2531	rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smstate, 0x7e92) << 8);
2531	set_desc_limit(&desc, GET_SMSTATE(u32, smbase, 0x7e94));	2532	set_desc_limit(&desc, GET_SMSTATE(u32, smstate, 0x7e94));
2532	set_desc_base(&desc, GET_SMSTATE(u32, smbase, 0x7e98));	2533	set_desc_base(&desc, GET_SMSTATE(u32, smstate, 0x7e98));
2533	base3 = GET_SMSTATE(u32, smbase, 0x7e9c);	2534	base3 = GET_SMSTATE(u32, smstate, 0x7e9c);
2534	ctxt->ops->set_segment(ctxt, selector, &desc, base3, VCPU_SREG_TR);	2535	ctxt->ops->set_segment(ctxt, selector, &desc, base3, VCPU_SREG_TR);
2535		2536
2536	dt.size = GET_SMSTATE(u32, smbase, 0x7e84);	2537	dt.size = GET_SMSTATE(u32, smstate, 0x7e84);
2537	dt.address = GET_SMSTATE(u64, smbase, 0x7e88);	2538	dt.address = GET_SMSTATE(u64, smstate, 0x7e88);
2538	ctxt->ops->set_idt(ctxt, &dt);	2539	ctxt->ops->set_idt(ctxt, &dt);
2539		2540
2540	selector = GET_SMSTATE(u32, smbase, 0x7e70);	2541	selector = GET_SMSTATE(u32, smstate, 0x7e70);
2541	rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smbase, 0x7e72) << 8);	2542	rsm_set_desc_flags(&desc, GET_SMSTATE(u32, smstate, 0x7e72) << 8);
2542	set_desc_limit(&desc, GET_SMSTATE(u32, smbase, 0x7e74));	2543	set_desc_limit(&desc, GET_SMSTATE(u32, smstate, 0x7e74));
2543	set_desc_base(&desc, GET_SMSTATE(u32, smbase, 0x7e78));	2544	set_desc_base(&desc, GET_SMSTATE(u32, smstate, 0x7e78));
2544	base3 = GET_SMSTATE(u32, smbase, 0x7e7c);	2545	base3 = GET_SMSTATE(u32, smstate, 0x7e7c);
2545	ctxt->ops->set_segment(ctxt, selector, &desc, base3, VCPU_SREG_LDTR);	2546	ctxt->ops->set_segment(ctxt, selector, &desc, base3, VCPU_SREG_LDTR);
2546		2547
2547	dt.size = GET_SMSTATE(u32, smbase, 0x7e64);	2548	dt.size = GET_SMSTATE(u32, smstate, 0x7e64);
2548	dt.address = GET_SMSTATE(u64, smbase, 0x7e68);	2549	dt.address = GET_SMSTATE(u64, smstate, 0x7e68);
2549	ctxt->ops->set_gdt(ctxt, &dt);	2550	ctxt->ops->set_gdt(ctxt, &dt);
2550		2551
2551	r = rsm_enter_protected_mode(ctxt, cr0, cr3, cr4);	2552	r = rsm_enter_protected_mode(ctxt, cr0, cr3, cr4);
@@ -2553,37 +2554,49 @@ static int rsm_load_state_64(struct x86_emulate_ctxt *ctxt, u64 smbase) · 1 unmodified line
2553	return r;	2554	return r;
2554		2555
2555	for (i = 0; i < 6; i++) {	2556	for (i = 0; i < 6; i++) {
2556	r = rsm_load_seg_64(ctxt, smbase, i);	2557	r = rsm_load_seg_64(ctxt, smstate, i);
2557	if (r != X86EMUL_CONTINUE)	2558	if (r != X86EMUL_CONTINUE)
2558	return r;	2559	return r;
2559	}	2560	}
2560		2561
2561	return X86EMUL_CONTINUE;	2562	return X86EMUL_CONTINUE;
2562	}	2563	}
		2564	#endif
2563		2565
2564	static int em_rsm(struct x86_emulate_ctxt *ctxt)	2566	static int em_rsm(struct x86_emulate_ctxt *ctxt)
2565	{	2567	{
2566	unsigned long cr0, cr4, efer;	2568	unsigned long cr0, cr4, efer;
		2569	char buf[512];
2567	u64 smbase;	2570	u64 smbase;
2568	int ret;	2571	int ret;
2569		2572
2570	if ((ctxt->ops->get_hflags(ctxt) & X86EMUL_SMM_MASK) == 0)	2573	if ((ctxt->ops->get_hflags(ctxt) & X86EMUL_SMM_MASK) == 0)
2571	return emulate_ud(ctxt);	2574	return emulate_ud(ctxt);
2572		2575
		2576	smbase = ctxt->ops->get_smbase(ctxt);
		2577
		2578	ret = ctxt->ops->read_phys(ctxt, smbase + 0xfe00, buf, sizeof(buf));
		2579	if (ret != X86EMUL_CONTINUE)
		2580	return X86EMUL_UNHANDLEABLE;
		2581
		2582	if ((ctxt->ops->get_hflags(ctxt) & X86EMUL_SMM_INSIDE_NMI_MASK) == 0)
		2583	ctxt->ops->set_nmi_mask(ctxt, false);
		2584
		2585	ctxt->ops->set_hflags(ctxt, ctxt->ops->get_hflags(ctxt) &
		2586	~(X86EMUL_SMM_INSIDE_NMI_MASK \| X86EMUL_SMM_MASK));
		2587
2573	/*	2588	/*
2574	* Get back to real mode, to prepare a safe state in which to load	2589	* Get back to real mode, to prepare a safe state in which to load
2575	* CR0/CR3/CR4/EFER. It's all a bit more complicated if the vCPU	2590	* CR0/CR3/CR4/EFER. It's all a bit more complicated if the vCPU
2576	* supports long mode.	2591	* supports long mode.
2577	*/	2592	*/
2578	cr4 = ctxt->ops->get_cr(ctxt, 4);
2579	if (emulator_has_longmode(ctxt)) {	2593	if (emulator_has_longmode(ctxt)) {
2580	struct desc_struct cs_desc;	2594	struct desc_struct cs_desc;
2581		2595
2582	/* Zero CR4.PCIDE before CR0.PG. */	2596	/* Zero CR4.PCIDE before CR0.PG. */
2583	if (cr4 & X86_CR4_PCIDE) {	2597	cr4 = ctxt->ops->get_cr(ctxt, 4);
		2598	if (cr4 & X86_CR4_PCIDE)
2584	ctxt->ops->set_cr(ctxt, 4, cr4 & ~X86_CR4_PCIDE);	2599	ctxt->ops->set_cr(ctxt, 4, cr4 & ~X86_CR4_PCIDE);
2585	cr4 &= ~X86_CR4_PCIDE;
2586	}
2587		2600
2588	/* A 32-bit code segment is required to clear EFER.LMA. */	2601	/* A 32-bit code segment is required to clear EFER.LMA. */
2589	memset(&cs_desc, 0, sizeof(cs_desc));	2602	memset(&cs_desc, 0, sizeof(cs_desc));
@@ -2597,39 +2610,39 @@ static int em_rsm(struct x86_emulate_ctxt *ctxt) · 7 unmodified lines
2597	if (cr0 & X86_CR0_PE)	2610	if (cr0 & X86_CR0_PE)
2598	ctxt->ops->set_cr(ctxt, 0, cr0 & ~(X86_CR0_PG \| X86_CR0_PE));	2611	ctxt->ops->set_cr(ctxt, 0, cr0 & ~(X86_CR0_PG \| X86_CR0_PE));
2599		2612
2600	/* Now clear CR4.PAE (which must be done before clearing EFER.LME). */	2613	if (emulator_has_longmode(ctxt)) {
2601	if (cr4 & X86_CR4_PAE)	2614	/* Clear CR4.PAE before clearing EFER.LME. */
2602	ctxt->ops->set_cr(ctxt, 4, cr4 & ~X86_CR4_PAE);	2615	cr4 = ctxt->ops->get_cr(ctxt, 4);
2603		2616	if (cr4 & X86_CR4_PAE)
2604	/* And finally go back to 32-bit mode. */	2617	ctxt->ops->set_cr(ctxt, 4, cr4 & ~X86_CR4_PAE);
2605	efer = 0;
2606	ctxt->ops->set_msr(ctxt, MSR_EFER, efer);
2607		2618
2608	smbase = ctxt->ops->get_smbase(ctxt);	2619	/* And finally go back to 32-bit mode. */
		2620	efer = 0;
		2621	ctxt->ops->set_msr(ctxt, MSR_EFER, efer);
		2622	}
2609		2623
2610	/*	2624	/*
2611	* Give pre_leave_smm() a chance to make ISA-specific changes to the	2625	* Give pre_leave_smm() a chance to make ISA-specific changes to the
2612	* vCPU state (e.g. enter guest mode) before loading state from the SMM	2626	* vCPU state (e.g. enter guest mode) before loading state from the SMM
2613	* state-save area.	2627	* state-save area.
2614	*/	2628	*/
2615	if (ctxt->ops->pre_leave_smm(ctxt, smbase))	2629	if (ctxt->ops->pre_leave_smm(ctxt, buf))
2616	return X86EMUL_UNHANDLEABLE;	2630	return X86EMUL_UNHANDLEABLE;
2617		2631
		2632	#ifdef CONFIG_X86_64
2618	if (emulator_has_longmode(ctxt))	2633	if (emulator_has_longmode(ctxt))
2619	ret = rsm_load_state_64(ctxt, smbase + 0x8000);	2634	ret = rsm_load_state_64(ctxt, buf);
2620	else	2635	else
2621	ret = rsm_load_state_32(ctxt, smbase + 0x8000);	2636	#endif
		2637	ret = rsm_load_state_32(ctxt, buf);
2622		2638
2623	if (ret != X86EMUL_CONTINUE) {	2639	if (ret != X86EMUL_CONTINUE) {
2624	/* FIXME: should triple fault */	2640	/* FIXME: should triple fault */
2625	return X86EMUL_UNHANDLEABLE;	2641	return X86EMUL_UNHANDLEABLE;
2626	}	2642	}
2627		2643
2628	if ((ctxt->ops->get_hflags(ctxt) & X86EMUL_SMM_INSIDE_NMI_MASK) == 0)	2644	ctxt->ops->post_leave_smm(ctxt);
2629	ctxt->ops->set_nmi_mask(ctxt, false);
2630		2645
2631	ctxt->ops->set_hflags(ctxt, ctxt->ops->get_hflags(ctxt) &
2632	~(X86EMUL_SMM_INSIDE_NMI_MASK \| X86EMUL_SMM_MASK));
2633	return X86EMUL_CONTINUE;	2646	return X86EMUL_CONTINUE;
2634	}	2647	}
2635		2648

arch/x86/kvm/lapic.c+3−1

 		if (offset <= max_apic_id) {
 			u8 cluster_size = min(max_apic_id - offset + 1, 16U);
+			offset = array_index_nospec(offset, map->max_apic_id + 1);
 			*cluster = &map->phys_map[offset];
 			*mask = dest_id & (0xffff >> (16 - cluster_size));
 		} else {
 		if (irq->dest_id > map->max_apic_id) {
 			*bitmap = 0;
 		} else {
-			*dst = &map->phys_map[irq->dest_id];
+			u32 dest_id = array_index_nospec(irq->dest_id, map->max_apic_id + 1);
+			*dst = &map->phys_map[dest_id];
 			*bitmap = 1;
 		}
 		return true;

arch/x86/kvm/mmu.c+7−8

  * aggregate version in order to make the slab shrinker
  * faster
  */
-static inline void kvm_mod_used_mmu_pages(struct kvm *kvm, int nr)
+static inline void kvm_mod_used_mmu_pages(struct kvm *kvm, unsigned long nr)
 {
 	kvm->arch.n_used_mmu_pages += nr;
 	percpu_counter_add(&kvm_total_used_mmu_pages, nr);
 					struct list_head *invalid_list,
 					bool remote_flush)
 {
-	if (!remote_flush && !list_empty(invalid_list))
+	if (!remote_flush && list_empty(invalid_list))
 		return false;
 	if (!list_empty(invalid_list))
  * Changing the number of mmu pages allocated to the vm
  * Note: if goal_nr_mmu_pages is too small, you will get dead lock
  */
-void kvm_mmu_change_mmu_pages(struct kvm *kvm, unsigned int goal_nr_mmu_pages)
+void kvm_mmu_change_mmu_pages(struct kvm *kvm, unsigned long goal_nr_mmu_pages)
 {
 	LIST_HEAD(invalid_list);
 /*
  * Calculate mmu pages needed for kvm.
  */
-unsigned int kvm_mmu_calculate_default_mmu_pages(struct kvm *kvm)
+unsigned long kvm_mmu_calculate_default_mmu_pages(struct kvm *kvm)
 {
-	unsigned int nr_mmu_pages;
+	unsigned long nr_mmu_pages;
-	unsigned int  nr_pages = 0;
+	unsigned long nr_pages = 0;
 	struct kvm_memslots *slots;
 	struct kvm_memory_slot *memslot;
 	int i;
 	}
 	nr_mmu_pages = nr_pages * KVM_PERMILLE_MMU_PAGES / 1000;
-	nr_mmu_pages = max(nr_mmu_pages,
+	nr_mmu_pages = max(nr_mmu_pages, KVM_MIN_ALLOC_MMU_PAGES);
-			   (unsigned int) KVM_MIN_ALLOC_MMU_PAGES);
 	return nr_mmu_pages;
 }

arch/x86/kvm/mmu.h+1−1

@@ -64,7 +64,7 @@ bool kvm_can_do_async_pf(struct kvm_vcpu *vcpu); · 63 unmodified lines
64	int kvm_handle_page_fault(struct kvm_vcpu *vcpu, u64 error_code,	64	int kvm_handle_page_fault(struct kvm_vcpu *vcpu, u64 error_code,
65	u64 fault_address, char *insn, int insn_len);	65	u64 fault_address, char *insn, int insn_len);
66		66
67	static inline unsigned int kvm_mmu_available_pages(struct kvm *kvm)	67	static inline unsigned long kvm_mmu_available_pages(struct kvm *kvm)
68	{	68	{
69	if (kvm->arch.n_max_mmu_pages > kvm->arch.n_used_mmu_pages)	69	if (kvm->arch.n_max_mmu_pages > kvm->arch.n_used_mmu_pages)
70	return kvm->arch.n_max_mmu_pages -	70	return kvm->arch.n_max_mmu_pages -

arch/x86/kvm/pmu.c+4−0

 int kvm_pmu_rdpmc(struct kvm_vcpu *vcpu, unsigned idx, u64 *data)
 {
 	bool fast_mode = idx & (1u << 31);
+	struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);
 	struct kvm_pmc *pmc;
 	u64 ctr_val;
+	if (!pmu->version)
+		return 1;
 	if (is_vmware_backdoor_pmc(idx))
 		return kvm_pmu_rdpmc_vmware(vcpu, idx, data);

arch/x86/kvm/svm.c+47−32

 };
 #define AVIC_LOGICAL_ID_ENTRY_GUEST_PHYSICAL_ID_MASK	(0xFF)
+#define AVIC_LOGICAL_ID_ENTRY_VALID_BIT			31
 #define AVIC_LOGICAL_ID_ENTRY_VALID_MASK		(1 << 31)
 #define AVIC_PHYSICAL_ID_ENTRY_HOST_PHYSICAL_ID_MASK	(0xFFULL)
 static int db_interception(struct vcpu_svm *svm)
 {
 	struct kvm_run *kvm_run = svm->vcpu.run;
+	struct kvm_vcpu *vcpu = &svm->vcpu;
 	if (!(svm->vcpu.guest_debug &
 	      (KVM_GUESTDBG_SINGLESTEP | KVM_GUESTDBG_USE_HW_BP)) &&
 	if (svm->nmi_singlestep) {
 		disable_nmi_singlestep(svm);
+		/* Make sure we check for pending NMIs upon entry */
+		kvm_make_request(KVM_REQ_EVENT, vcpu);
 	}
 	if (svm->vcpu.guest_debug &
 		kvm_lapic_reg_write(apic, APIC_ICR, icrl);
 		break;
 	case AVIC_IPI_FAILURE_TARGET_NOT_RUNNING: {
+		int i;
+		struct kvm_vcpu *vcpu;
+		struct kvm *kvm = svm->vcpu.kvm;
 		struct kvm_lapic *apic = svm->vcpu.arch.apic;
 		/*
-		 * Update ICR high and low, then emulate sending IPI,
+		 * At this point, we expect that the AVIC HW has already
-		 * which is handled when writing APIC_ICR.
+		 * set the appropriate IRR bits on the valid target
+		 * vcpus. So, we just need to kick the appropriate vcpu.
 		 */
-		kvm_lapic_reg_write(apic, APIC_ICR2, icrh);
+		kvm_for_each_vcpu(i, vcpu, kvm) {
-		kvm_lapic_reg_write(apic, APIC_ICR, icrl);
+			bool m = kvm_apic_match_dest(vcpu, apic,
+						     icrl & KVM_APIC_SHORT_MASK,
+						     GET_APIC_DEST_FIELD(icrh),
+						     icrl & KVM_APIC_DEST_MASK);
+			if (m && !avic_vcpu_is_running(vcpu))
+				kvm_vcpu_wake_up(vcpu);
+		}
 		break;
 	}
 	case AVIC_IPI_FAILURE_INVALID_TARGET:
 	u32 *entry = avic_get_logical_id_entry(vcpu, svm->ldr_reg, flat);
 	if (entry)
-		WRITE_ONCE(*entry, (u32) ~AVIC_LOGICAL_ID_ENTRY_VALID_MASK);
+		clear_bit(AVIC_LOGICAL_ID_ENTRY_VALID_BIT, (unsigned long *)entry);
 }
 static int avic_handle_ldr_update(struct kvm_vcpu *vcpu)
 	svm->vmcb->save.cr2 = vcpu->arch.cr2;
 	clgi();
+	kvm_load_guest_xcr0(vcpu);
 	/*
 	 * If this vCPU has touched SPEC_CTRL, restore the guest's value if
 	if (unlikely(svm->vmcb->control.exit_code == SVM_EXIT_NMI))
 		kvm_before_interrupt(&svm->vcpu);
+	kvm_put_guest_xcr0(vcpu);
 	stgi();
 	/* Any pending NMI will happen here */
 	return 0;
 }
-static int svm_pre_leave_smm(struct kvm_vcpu *vcpu, u64 smbase)
+static int svm_pre_leave_smm(struct kvm_vcpu *vcpu, const char *smstate)
 {
 	struct vcpu_svm *svm = to_svm(vcpu);
 	struct vmcb *nested_vmcb;
 	struct page *page;
-	struct {
+	u64 guest;
-		u64 guest;
+	u64 vmcb;
-		u64 vmcb;
-	} svm_state_save;
-	int ret;
-	ret = kvm_vcpu_read_guest(vcpu, smbase + 0xfed8, &svm_state_save,
+	guest = GET_SMSTATE(u64, smstate, 0x7ed8);
-				  sizeof(svm_state_save));
+	vmcb = GET_SMSTATE(u64, smstate, 0x7ee0);
-	if (ret)
-		return ret;
-	if (svm_state_save.guest) {
+	if (guest) {
-		vcpu->arch.hflags &= ~HF_SMM_MASK;
+		nested_vmcb = nested_svm_map(svm, vmcb, &page);
-		nested_vmcb = nested_svm_map(svm, svm_state_save.vmcb, &page);
+		if (!nested_vmcb)
-		if (nested_vmcb)
+			return 1;
-			enter_svm_guest_mode(svm, svm_state_save.vmcb, nested_vmcb, page);
+		enter_svm_guest_mode(svm, vmcb, nested_vmcb, page);
-		else
-			ret = 1;
-		vcpu->arch.hflags |= HF_SMM_MASK;
 	}
-	return ret;
+	return 0;
 }
 static int enable_smi_window(struct kvm_vcpu *vcpu)
 	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/trace.h+2−2

@@ -438,13 +438,13 @@ TRACE_EVENT(kvm_apic_ipi, · 437 unmodified lines
438	);	438	);
439		439
440	TRACE_EVENT(kvm_apic_accept_irq,	440	TRACE_EVENT(kvm_apic_accept_irq,
441	TP_PROTO(__u32 apicid, __u16 dm, __u8 tm, __u8 vec),	441	TP_PROTO(__u32 apicid, __u16 dm, __u16 tm, __u8 vec),
442	TP_ARGS(apicid, dm, tm, vec),	442	TP_ARGS(apicid, dm, tm, vec),
443		443
444	TP_STRUCT__entry(	444	TP_STRUCT__entry(
445	__field( __u32, apicid )	445	__field( __u32, apicid )
446	__field( __u16, dm )	446	__field( __u16, dm )
447	__field( __u8, tm )	447	__field( __u16, tm )
448	__field( __u8, vec )	448	__field( __u8, vec )
449	),	449	),
450		450

arch/x86/kvm/vmx/nested.c+81−40

@@ -500,6 +500,17 @@ static void nested_vmx_disable_intercept_for_msr(unsigned long *msr_bitmap_l1, · 499 unmodified lines
500	}	500	}
501	}	501	}
502		502
		503	static inline void enable_x2apic_msr_intercepts(unsigned long *msr_bitmap) {
		504	int msr;
		505
		506	for (msr = 0x800; msr <= 0x8ff; msr += BITS_PER_LONG) {
		507	unsigned word = msr / BITS_PER_LONG;
		508
		509	msr_bitmap[word] = ~0;
		510	msr_bitmap[word + (0x800 / sizeof(long))] = ~0;
		511	}
		512	}
		513
503	/*	514	/*
504	* Merge L0's and L1's MSR bitmap, return false to indicate that	515	* Merge L0's and L1's MSR bitmap, return false to indicate that
505	* we do not use the hardware.	516	* we do not use the hardware.
@@ -541,39 +552,44 @@ static inline bool nested_vmx_prepare_msr_bitmap(struct kvm_vcpu *vcpu, · 35 unmodified lines
541	return false;	552	return false;
542		553
543	msr_bitmap_l1 = (unsigned long *)kmap(page);	554	msr_bitmap_l1 = (unsigned long *)kmap(page);
544	if (nested_cpu_has_apic_reg_virt(vmcs12)) {
545	/*
546	* L0 need not intercept reads for MSRs between 0x800 and 0x8ff, it
547	* just lets the processor take the value from the virtual-APIC page;
548	* take those 256 bits directly from the L1 bitmap.
549	*/
550	for (msr = 0x800; msr <= 0x8ff; msr += BITS_PER_LONG) {
551	unsigned word = msr / BITS_PER_LONG;
552	msr_bitmap_l0[word] = msr_bitmap_l1[word];
553	msr_bitmap_l0[word + (0x800 / sizeof(long))] = ~0;
554	}
555	} else {
556	for (msr = 0x800; msr <= 0x8ff; msr += BITS_PER_LONG) {
557	unsigned word = msr / BITS_PER_LONG;
558	msr_bitmap_l0[word] = ~0;
559	msr_bitmap_l0[word + (0x800 / sizeof(long))] = ~0;
560	}
561	}
562		555
563	nested_vmx_disable_intercept_for_msr(	556	/*
564	msr_bitmap_l1, msr_bitmap_l0,	557	* To keep the control flow simple, pay eight 8-byte writes (sixteen
565	X2APIC_MSR(APIC_TASKPRI),	558	* 4-byte writes on 32-bit systems) up front to enable intercepts for
566	MSR_TYPE_W);	559	* the x2APIC MSR range and selectively disable them below.
		560	*/
		561	enable_x2apic_msr_intercepts(msr_bitmap_l0);
		562
		563	if (nested_cpu_has_virt_x2apic_mode(vmcs12)) {
		564	if (nested_cpu_has_apic_reg_virt(vmcs12)) {
		565	/*
		566	* L0 need not intercept reads for MSRs between 0x800
		567	* and 0x8ff, it just lets the processor take the value
		568	* from the virtual-APIC page; take those 256 bits
		569	* directly from the L1 bitmap.
		570	*/
		571	for (msr = 0x800; msr <= 0x8ff; msr += BITS_PER_LONG) {
		572	unsigned word = msr / BITS_PER_LONG;
		573
		574	msr_bitmap_l0[word] = msr_bitmap_l1[word];
		575	}
		576	}
567		577
568	if (nested_cpu_has_vid(vmcs12)) {
569	nested_vmx_disable_intercept_for_msr(
570	msr_bitmap_l1, msr_bitmap_l0,
571	X2APIC_MSR(APIC_EOI),
572	MSR_TYPE_W);
573	nested_vmx_disable_intercept_for_msr(	578	nested_vmx_disable_intercept_for_msr(
574	msr_bitmap_l1, msr_bitmap_l0,	579	msr_bitmap_l1, msr_bitmap_l0,
575	X2APIC_MSR(APIC_SELF_IPI),	580	X2APIC_MSR(APIC_TASKPRI),
576	MSR_TYPE_W);	581	MSR_TYPE_R \| MSR_TYPE_W);
		582
		583	if (nested_cpu_has_vid(vmcs12)) {
		584	nested_vmx_disable_intercept_for_msr(
		585	msr_bitmap_l1, msr_bitmap_l0,
		586	X2APIC_MSR(APIC_EOI),
		587	MSR_TYPE_W);
		588	nested_vmx_disable_intercept_for_msr(
		589	msr_bitmap_l1, msr_bitmap_l0,
		590	X2APIC_MSR(APIC_SELF_IPI),
		591	MSR_TYPE_W);
		592	}
577	}	593	}
578		594
579	if (spec_ctrl)	595	if (spec_ctrl)
@@ -2857,20 +2873,27 @@ static void nested_get_vmcs12_pages(struct kvm_vcpu *vcpu) · 2277 unmodified lines
2857	/*	2873	/*
2858	* If translation failed, VM entry will fail because	2874	* If translation failed, VM entry will fail because
2859	* prepare_vmcs02 set VIRTUAL_APIC_PAGE_ADDR to -1ull.	2875	* prepare_vmcs02 set VIRTUAL_APIC_PAGE_ADDR to -1ull.
2860	* Failing the vm entry is _not_ what the processor
2861	* does but it's basically the only possibility we
2862	* have. We could still enter the guest if CR8 load
2863	* exits are enabled, CR8 store exits are enabled, and
2864	* virtualize APIC access is disabled; in this case
2865	* the processor would never use the TPR shadow and we
2866	* could simply clear the bit from the execution
2867	* control. But such a configuration is useless, so
2868	* let's keep the code simple.
2869	*/	2876	*/
2870	if (!is_error_page(page)) {	2877	if (!is_error_page(page)) {
2871	vmx->nested.virtual_apic_page = page;	2878	vmx->nested.virtual_apic_page = page;
2872	hpa = page_to_phys(vmx->nested.virtual_apic_page);	2879	hpa = page_to_phys(vmx->nested.virtual_apic_page);
2873	vmcs_write64(VIRTUAL_APIC_PAGE_ADDR, hpa);	2880	vmcs_write64(VIRTUAL_APIC_PAGE_ADDR, hpa);
		2881	} else if (nested_cpu_has(vmcs12, CPU_BASED_CR8_LOAD_EXITING) &&
		2882	nested_cpu_has(vmcs12, CPU_BASED_CR8_STORE_EXITING) &&
		2883	!nested_cpu_has2(vmcs12, SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES)) {
		2884	/*
		2885	* The processor will never use the TPR shadow, simply
		2886	* clear the bit from the execution control. Such a
		2887	* configuration is useless, but it happens in tests.
		2888	* For any other configuration, failing the vm entry is
		2889	* _not_ what the processor does but it's basically the
		2890	* only possibility we have.
		2891	*/
		2892	vmcs_clear_bits(CPU_BASED_VM_EXEC_CONTROL,
		2893	CPU_BASED_TPR_SHADOW);
		2894	} else {
		2895	printk("bad virtual-APIC page address\n");
		2896	dump_vmcs();
2874	}	2897	}
2875	}	2898	}
2876		2899
@@ -3773,8 +3796,18 @@ static void nested_vmx_restore_host_state(struct kvm_vcpu *vcpu) · 896 unmodified lines
3773	vmx_set_cr4(vcpu, vmcs_readl(CR4_READ_SHADOW));	3796	vmx_set_cr4(vcpu, vmcs_readl(CR4_READ_SHADOW));
3774		3797
3775	nested_ept_uninit_mmu_context(vcpu);	3798	nested_ept_uninit_mmu_context(vcpu);
3776	vcpu->arch.cr3 = vmcs_readl(GUEST_CR3);	3799
3777	__set_bit(VCPU_EXREG_CR3, (ulong *)&vcpu->arch.regs_avail);	3800	/*
		3801	* This is only valid if EPT is in use, otherwise the vmcs01 GUEST_CR3
		3802	* points to shadow pages! Fortunately we only get here after a WARN_ON
		3803	* if EPT is disabled, so a VMabort is perfectly fine.
		3804	*/
		3805	if (enable_ept) {
		3806	vcpu->arch.cr3 = vmcs_readl(GUEST_CR3);
		3807	__set_bit(VCPU_EXREG_CR3, (ulong *)&vcpu->arch.regs_avail);
		3808	} else {
		3809	nested_vmx_abort(vcpu, VMX_ABORT_VMCS_CORRUPTED);
		3810	}
3778		3811
3779	/*	3812	/*
3780	* Use ept_save_pdptrs(vcpu) to load the MMU's cached PDPTRs	3813	* Use ept_save_pdptrs(vcpu) to load the MMU's cached PDPTRs
@@ -5722,6 +5755,14 @@ __init int nested_vmx_hardware_setup(int (exit_handlers[])(struct kvm_vcpu )) · 1941 unmodified lines
5722	{	5755	{
5723	int i;	5756	int i;
5724		5757
		5758	/*
		5759	* Without EPT it is not possible to restore L1's CR3 and PDPTR on
		5760	* VMfail, because they are not available in vmcs01. Just always
		5761	* use hardware checks.
		5762	*/
		5763	if (!enable_ept)
		5764	nested_early_check = 1;
		5765
5725	if (!cpu_has_vmx_shadow_vmcs())	5766	if (!cpu_has_vmx_shadow_vmcs())
5726	enable_shadow_vmcs = 0;	5767	enable_shadow_vmcs = 0;
5727	if (enable_shadow_vmcs) {	5768	if (enable_shadow_vmcs) {

arch/x86/kvm/vmx/vmx.c+31−4

 	       vmcs_readl(limit + GUEST_GDTR_BASE - GUEST_GDTR_LIMIT));
 }
-static void dump_vmcs(void)
+void dump_vmcs(void)
 {
 	u32 vmentry_ctl = vmcs_read32(VM_ENTRY_CONTROLS);
 	u32 vmexit_ctl = vmcs_read32(VM_EXIT_CONTROLS);
 	if (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP)
 		vmx_set_interrupt_shadow(vcpu, 0);
+	kvm_load_guest_xcr0(vcpu);
 	if (static_cpu_has(X86_FEATURE_PKU) &&
 	    kvm_read_cr4_bits(vcpu, X86_CR4_PKE) &&
 	    vcpu->arch.pkru != vmx->host_pkru)
 			__write_pkru(vmx->host_pkru);
 	}
+	kvm_put_guest_xcr0(vcpu);
 	vmx->nested.nested_run_pending = 0;
 	vmx->idt_vectoring_info = 0;
 	}
 }
+static bool guest_cpuid_has_pmu(struct kvm_vcpu *vcpu)
+{
+	struct kvm_cpuid_entry2 *entry;
+	union cpuid10_eax eax;
+	entry = kvm_find_cpuid_entry(vcpu, 0xa, 0);
+	if (!entry)
+		return false;
+	eax.full = entry->eax;
+	return (eax.split.version_id > 0);
+}
+static void nested_vmx_procbased_ctls_update(struct kvm_vcpu *vcpu)
+{
+	struct vcpu_vmx *vmx = to_vmx(vcpu);
+	bool pmu_enabled = guest_cpuid_has_pmu(vcpu);
+	if (pmu_enabled)
+		vmx->nested.msrs.procbased_ctls_high |= CPU_BASED_RDPMC_EXITING;
+	else
+		vmx->nested.msrs.procbased_ctls_high &= ~CPU_BASED_RDPMC_EXITING;
+}
 static void update_intel_pt_cfg(struct kvm_vcpu *vcpu)
 {
 	struct vcpu_vmx *vmx = to_vmx(vcpu);
 	if (nested_vmx_allowed(vcpu)) {
 		nested_vmx_cr_fixed1_bits_update(vcpu);
 		nested_vmx_entry_exit_ctls_update(vcpu);
+		nested_vmx_procbased_ctls_update(vcpu);
 	}
 	if (boot_cpu_has(X86_FEATURE_INTEL_PT) &&
 	return 0;
 }
-static int vmx_pre_leave_smm(struct kvm_vcpu *vcpu, u64 smbase)
+static int vmx_pre_leave_smm(struct kvm_vcpu *vcpu, const char *smstate)
 {
 	struct vcpu_vmx *vmx = to_vmx(vcpu);
 	int ret;
 	}
 	if (vmx->nested.smm.guest_mode) {
-		vcpu->arch.hflags &= ~HF_SMM_MASK;
 		ret = nested_vmx_enter_non_root_mode(vcpu, false);
-		vcpu->arch.hflags |= HF_SMM_MASK;
 		if (ret)
 			return ret;

arch/x86/kvm/vmx/vmx.h+2−0

@@ -517,4 +517,6 @@ static inline void decache_tsc_multiplier(struct vcpu_vmx *vmx) · 516 unmodified lines
517	vmcs_write64(TSC_MULTIPLIER, vmx->current_tsc_ratio);	517	vmcs_write64(TSC_MULTIPLIER, vmx->current_tsc_ratio);
518	}	518	}
519		519
		520	void dump_vmcs(void);
		521
520	#endif /* __KVM_X86_VMX_H */	522	#endif /* __KVM_X86_VMX_H */

arch/x86/kvm/x86.c+31−33

 }
 EXPORT_SYMBOL_GPL(kvm_lmsw);
-static void kvm_load_guest_xcr0(struct kvm_vcpu *vcpu)
+void kvm_load_guest_xcr0(struct kvm_vcpu *vcpu)
 {
 	if (kvm_read_cr4_bits(vcpu, X86_CR4_OSXSAVE) &&
 			!vcpu->guest_xcr0_loaded) {
 		vcpu->guest_xcr0_loaded = 1;
 	}
 }
+EXPORT_SYMBOL_GPL(kvm_load_guest_xcr0);
-static void kvm_put_guest_xcr0(struct kvm_vcpu *vcpu)
+void kvm_put_guest_xcr0(struct kvm_vcpu *vcpu)
 {
 	if (vcpu->guest_xcr0_loaded) {
 		if (vcpu->arch.xcr0 != host_xcr0)
 		vcpu->guest_xcr0_loaded = 0;
 	}
 }
+EXPORT_SYMBOL_GPL(kvm_put_guest_xcr0);
 static int __kvm_set_xcr(struct kvm_vcpu *vcpu, u32 index, u64 xcr)
 {
 		break;
 	case KVM_CAP_NESTED_STATE:
 		r = kvm_x86_ops->get_nested_state ?
-			kvm_x86_ops->get_nested_state(NULL, 0, 0) : 0;
+			kvm_x86_ops->get_nested_state(NULL, NULL, 0) : 0;
 		break;
 	default:
 		break;
 	memset(&events->reserved, 0, sizeof(events->reserved));
 }
-static void kvm_set_hflags(struct kvm_vcpu *vcpu, unsigned emul_flags);
+static void kvm_smm_changed(struct kvm_vcpu *vcpu);
 static int kvm_vcpu_ioctl_x86_set_vcpu_events(struct kvm_vcpu *vcpu,
 					      struct kvm_vcpu_events *events)
 		vcpu->arch.apic->sipi_vector = events->sipi_vector;
 	if (events->flags & KVM_VCPUEVENT_VALID_SMM) {
-		u32 hflags = vcpu->arch.hflags;
+		if (!!(vcpu->arch.hflags & HF_SMM_MASK) != events->smi.smm) {
-		if (events->smi.smm)
+			if (events->smi.smm)
-			hflags |= HF_SMM_MASK;
+				vcpu->arch.hflags |= HF_SMM_MASK;
-		else
+			else
-			hflags &= ~HF_SMM_MASK;
+				vcpu->arch.hflags &= ~HF_SMM_MASK;
-		kvm_set_hflags(vcpu, hflags);
+			kvm_smm_changed(vcpu);
+		}
 		vcpu->arch.smi_pending = events->smi.pending;
 }
 static int kvm_vm_ioctl_set_nr_mmu_pages(struct kvm *kvm,
-					  u32 kvm_nr_mmu_pages)
+					 unsigned long kvm_nr_mmu_pages)
 {
 	if (kvm_nr_mmu_pages < KVM_MIN_ALLOC_MMU_PAGES)
 		return -EINVAL;
 	return 0;
 }
-static int kvm_vm_ioctl_get_nr_mmu_pages(struct kvm *kvm)
+static unsigned long kvm_vm_ioctl_get_nr_mmu_pages(struct kvm *kvm)
 {
 	return kvm->arch.n_max_mmu_pages;
 }
 static void emulator_set_hflags(struct x86_emulate_ctxt *ctxt, unsigned emul_flags)
 {
-	kvm_set_hflags(emul_to_vcpu(ctxt), emul_flags);
+	emul_to_vcpu(ctxt)->arch.hflags = emul_flags;
+}
+static int emulator_pre_leave_smm(struct x86_emulate_ctxt *ctxt,
+				  const char *smstate)
+{
+	return kvm_x86_ops->pre_leave_smm(emul_to_vcpu(ctxt), smstate);
 }
-static int emulator_pre_leave_smm(struct x86_emulate_ctxt *ctxt, u64 smbase)
+static void emulator_post_leave_smm(struct x86_emulate_ctxt *ctxt)
 {
-	return kvm_x86_ops->pre_leave_smm(emul_to_vcpu(ctxt), smbase);
+	kvm_smm_changed(emul_to_vcpu(ctxt));
 }
 static const struct x86_emulate_ops emulate_ops = {
 	.get_hflags          = emulator_get_hflags,
 	.set_hflags          = emulator_set_hflags,
 	.pre_leave_smm       = emulator_pre_leave_smm,
+	.post_leave_smm      = emulator_post_leave_smm,
 };
 static void toggle_interruptibility(struct kvm_vcpu *vcpu, u32 mask)
 	kvm_mmu_reset_context(vcpu);
 }
-static void kvm_set_hflags(struct kvm_vcpu *vcpu, unsigned emul_flags)
-{
-	unsigned changed = vcpu->arch.hflags ^ emul_flags;
-	vcpu->arch.hflags = emul_flags;
-	if (changed & HF_SMM_MASK)
-		kvm_smm_changed(vcpu);
-}
 static int kvm_vcpu_check_hw_bp(unsigned long addr, u32 type, u32 dr7,
 				unsigned long *db)
 {
 	put_smstate(u32, buf, 0x7ef8, vcpu->arch.smbase);
 }
+#ifdef CONFIG_X86_64
 static void enter_smm_save_state_64(struct kvm_vcpu *vcpu, char *buf)
 {
-#ifdef CONFIG_X86_64
 	struct desc_ptr dt;
 	struct kvm_segment seg;
 	unsigned long val;
 	for (i = 0; i < 6; i++)
 		enter_smm_save_seg_64(vcpu, buf, i);
-#else
-	WARN_ON_ONCE(1);
-#endif
 }
+#endif
 static void enter_smm(struct kvm_vcpu *vcpu)
 {
 	trace_kvm_enter_smm(vcpu->vcpu_id, vcpu->arch.smbase, true);
 	memset(buf, 0, 512);
+#ifdef CONFIG_X86_64
 	if (guest_cpuid_has(vcpu, X86_FEATURE_LM))
 		enter_smm_save_state_64(vcpu, buf);
 	else
+#endif
 		enter_smm_save_state_32(vcpu, buf);
 	/*
 	kvm_set_segment(vcpu, &ds, VCPU_SREG_GS);
 	kvm_set_segment(vcpu, &ds, VCPU_SREG_SS);
+#ifdef CONFIG_X86_64
 	if (guest_cpuid_has(vcpu, X86_FEATURE_LM))
 		kvm_x86_ops->set_efer(vcpu, 0);
+#endif
 	kvm_update_cpuid(vcpu);
 	kvm_mmu_reset_context(vcpu);
 		goto cancel_injection;
 	}
-	kvm_load_guest_xcr0(vcpu);
 	if (req_immediate_exit) {
 		kvm_make_request(KVM_REQ_EVENT, vcpu);
 		kvm_x86_ops->request_immediate_exit(vcpu);
 	vcpu->mode = OUTSIDE_GUEST_MODE;
 	smp_wmb();
-	kvm_put_guest_xcr0(vcpu);
 	kvm_before_interrupt(vcpu);
 	kvm_x86_ops->handle_external_intr(vcpu);
 	kvm_after_interrupt(vcpu);

arch/x86/kvm/x86.h+2−0

@@ -347,4 +347,6 @@ static inline void kvm_after_interrupt(struct kvm_vcpu *vcpu) · 346 unmodified lines
347	__this_cpu_write(current_vcpu, NULL);	347	__this_cpu_write(current_vcpu, NULL);
348	}	348	}
349		349
		350	void kvm_load_guest_xcr0(struct kvm_vcpu *vcpu);
		351	void kvm_put_guest_xcr0(struct kvm_vcpu *vcpu);
350	#endif	352	#endif

arch/x86/mm/dump_pagetables.c+2−1

@@ -259,7 +259,8 @@ static void note_wx(struct pg_state *st) · 258 unmodified lines
259	#endif	259	#endif
260	/* Account the WX pages */	260	/* Account the WX pages */
261	st->wx_pages += npages;	261	st->wx_pages += npages;
262	WARN_ONCE(1, "x86/mm: Found insecure W+X mapping at address %pS\n",	262	WARN_ONCE(__supported_pte_mask & _PAGE_NX,
		263	"x86/mm: Found insecure W+X mapping at address %pS\n",
263	(void *)st->start_address);	264	(void *)st->start_address);
264	}	265	}
265		266

arch/x86/mm/ioremap.c+1−1

@@ -825,7 +825,7 @@ void __init __early_set_fixmap(enum fixed_addresses idx, · 824 unmodified lines
825	pte = early_ioremap_pte(addr);	825	pte = early_ioremap_pte(addr);
826		826
827	/* Sanitize 'prot' against any unsupported bits: */	827	/* Sanitize 'prot' against any unsupported bits: */
828	pgprot_val(flags) &= __default_kernel_pte_mask;	828	pgprot_val(flags) &= __supported_pte_mask;
829		829
830	if (pgprot_val(flags))	830	if (pgprot_val(flags))
831	set_pte(pte, pfn_pte(phys >> PAGE_SHIFT, flags));	831	set_pte(pte, pfn_pte(phys >> PAGE_SHIFT, flags));

arch/x86/mm/kaslr.c+1−1

@@ -94,7 +94,7 @@ void __init kernel_randomize_memory(void) · 93 unmodified lines
94	if (!kaslr_memory_enabled())	94	if (!kaslr_memory_enabled())
95	return;	95	return;
96		96
97	kaslr_regions[0].size_tb = 1 << (__PHYSICAL_MASK_SHIFT - TB_SHIFT);	97	kaslr_regions[0].size_tb = 1 << (MAX_PHYSMEM_BITS - TB_SHIFT);
98	kaslr_regions[1].size_tb = VMALLOC_SIZE_TB;	98	kaslr_regions[1].size_tb = VMALLOC_SIZE_TB;
99		99
100	/*	100	/*

arch/x86/mm/tlb.c+1−1

@@ -728,7 +728,7 @@ void flush_tlb_mm_range(struct mm_struct *mm, unsigned long start, · 727 unmodified lines
728	{	728	{
729	int cpu;	729	int cpu;
730		730
731	struct flush_tlb_info info __aligned(SMP_CACHE_BYTES) = {	731	struct flush_tlb_info info = {
732	.mm = mm,	732	.mm = mm,
733	.stride_shift = stride_shift,	733	.stride_shift = stride_shift,
734	.freed_tables = freed_tables,	734	.freed_tables = freed_tables,

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+14−9

 	bfq_remove_request(q, rq);
 }
-static void __bfq_bfqq_expire(struct bfq_data *bfqd, struct bfq_queue *bfqq)
+static bool __bfq_bfqq_expire(struct bfq_data *bfqd, struct bfq_queue *bfqq)
 {
 	/*
 	 * If this bfqq is shared between multiple processes, check
 	/*
 	 * All in-service entities must have been properly deactivated
 	 * or requeued before executing the next function, which
-	 * resets all in-service entities as no more in service.
+	 * resets all in-service entities as no more in service. This
+	 * may cause bfqq to be freed. If this happens, the next
+	 * function returns true.
 	 */
-	__bfq_bfqd_reset_in_service(bfqd);
+	return __bfq_bfqd_reset_in_service(bfqd);
 }
 /**
 	bool slow;
 	unsigned long delta = 0;
 	struct bfq_entity *entity = &bfqq->entity;
-	int ref;
 	/*
 	 * Check whether the process is slow (see bfq_bfqq_is_slow).
 	 * reason.
 	 */
 	__bfq_bfqq_recalc_budget(bfqd, bfqq, reason);
-	ref = bfqq->ref;
+	if (__bfq_bfqq_expire(bfqd, bfqq))
-	__bfq_bfqq_expire(bfqd, bfqq);
+		/* bfqq is gone, no more actions on it */
-	if (ref == 1) /* bfqq is gone, no more actions on it */
 		return;
 	/* mark bfqq as waiting a request only if a bic still points to it */
 	return min_shallow;
 }
-static int bfq_init_hctx(struct blk_mq_hw_ctx *hctx, unsigned int index)
+static void bfq_depth_updated(struct blk_mq_hw_ctx *hctx)
 {
 	struct bfq_data *bfqd = hctx->queue->elevator->elevator_data;
 	struct blk_mq_tags *tags = hctx->sched_tags;
 	min_shallow = bfq_update_depths(bfqd, &tags->bitmap_tags);
 	sbitmap_queue_min_shallow_depth(&tags->bitmap_tags, min_shallow);
+}
+static int bfq_init_hctx(struct blk_mq_hw_ctx *hctx, unsigned int index)
+{
+	bfq_depth_updated(hctx);
 	return 0;
 }
 		.requests_merged	= bfq_requests_merged,
 		.request_merged		= bfq_request_merged,
 		.has_work		= bfq_has_work,
+		.depth_updated		= bfq_depth_updated,
 		.init_hctx		= bfq_init_hctx,
 		.init_sched		= bfq_init_queue,
 		.exit_sched		= bfq_exit_queue,

block/bfq-iosched.h+1−1

@@ -1014,7 +1014,7 @@ bool __bfq_deactivate_entity(struct bfq_entity *entity, · 1013 unmodified lines
1014	bool ins_into_idle_tree);	1014	bool ins_into_idle_tree);
1015	bool next_queue_may_preempt(struct bfq_data *bfqd);	1015	bool next_queue_may_preempt(struct bfq_data *bfqd);
1016	struct bfq_queue bfq_get_next_queue(struct bfq_data bfqd);	1016	struct bfq_queue bfq_get_next_queue(struct bfq_data bfqd);
1017	void __bfq_bfqd_reset_in_service(struct bfq_data *bfqd);	1017	bool __bfq_bfqd_reset_in_service(struct bfq_data *bfqd);
1018	void bfq_deactivate_bfqq(struct bfq_data bfqd, struct bfq_queue bfqq,	1018	void bfq_deactivate_bfqq(struct bfq_data bfqd, struct bfq_queue bfqq,
1019	bool ins_into_idle_tree, bool expiration);	1019	bool ins_into_idle_tree, bool expiration);
1020	void bfq_activate_bfqq(struct bfq_data bfqd, struct bfq_queue bfqq);	1020	void bfq_activate_bfqq(struct bfq_data bfqd, struct bfq_queue bfqq);

block/bfq-wf2q.c+15−2

 	return bfqq;
 }
-void __bfq_bfqd_reset_in_service(struct bfq_data *bfqd)
+/* returns true if the in-service queue gets freed */
+bool __bfq_bfqd_reset_in_service(struct bfq_data *bfqd)
 {
 	struct bfq_queue *in_serv_bfqq = bfqd->in_service_queue;
 	struct bfq_entity *in_serv_entity = &in_serv_bfqq->entity;
 	 * service tree either, then release the service reference to
 	 * the queue it represents (taken with bfq_get_entity).
 	 */
-	if (!in_serv_entity->on_st)
+	if (!in_serv_entity->on_st) {
+		/*
+		 * If no process is referencing in_serv_bfqq any
+		 * longer, then the service reference may be the only
+		 * reference to the queue. If this is the case, then
+		 * bfqq gets freed here.
+		 */
+		int ref = in_serv_bfqq->ref;
 		bfq_put_queue(in_serv_bfqq);
+		if (ref == 1)
+			return true;
+	}
+	return false;
 }
 void bfq_deactivate_bfqq(struct bfq_data *bfqd, struct bfq_queue *bfqq,

block/bio.c+4−1

 			}
 		}
-		if (bio_add_pc_page(q, bio, page, bytes, offset) < bytes)
+		if (bio_add_pc_page(q, bio, page, bytes, offset) < bytes) {
+			if (!map_data)
+				__free_page(page);
 			break;
+		}
 		len -= bytes;
 		offset = 0;

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+77−61

@@ -654,6 +654,13 @@ bool blk_mq_complete_request(struct request *rq) · 653 unmodified lines
654	}	654	}
655	EXPORT_SYMBOL(blk_mq_complete_request);	655	EXPORT_SYMBOL(blk_mq_complete_request);
656		656
		657	void blk_mq_complete_request_sync(struct request *rq)
		658	{
		659	WRITE_ONCE(rq->state, MQ_RQ_COMPLETE);
		660	rq->q->mq_ops->complete(rq);
		661	}
		662	EXPORT_SYMBOL_GPL(blk_mq_complete_request_sync);
		663
657	int blk_mq_request_started(struct request *rq)	664	int blk_mq_request_started(struct request *rq)
658	{	665	{
659	return blk_mq_rq_state(rq) != MQ_RQ_IDLE;	666	return blk_mq_rq_state(rq) != MQ_RQ_IDLE;
@@ -1711,11 +1718,12 @@ void blk_mq_flush_plug_list(struct blk_plug *plug, bool from_schedule) · 1051 unmodified lines
1711	unsigned int depth;	1718	unsigned int depth;
1712		1719
1713	list_splice_init(&plug->mq_list, &list);	1720	list_splice_init(&plug->mq_list, &list);
1714	plug->rq_count = 0;
1715		1721
1716	if (plug->rq_count > 2 && plug->multiple_queues)	1722	if (plug->rq_count > 2 && plug->multiple_queues)
1717	list_sort(NULL, &list, plug_rq_cmp);	1723	list_sort(NULL, &list, plug_rq_cmp);
1718		1724
		1725	plug->rq_count = 0;
		1726
1719	this_q = NULL;	1727	this_q = NULL;
1720	this_hctx = NULL;	1728	this_hctx = NULL;
1721	this_ctx = NULL;	1729	this_ctx = NULL;
@@ -1800,74 +1808,76 @@ static blk_status_t __blk_mq_issue_directly(struct blk_mq_hw_ctx *hctx, · 78 unmodified lines
1800	return ret;	1808	return ret;
1801	}	1809	}
1802		1810
1803	blk_status_t blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx,	1811	static blk_status_t __blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx,
1804	struct request *rq,	1812	struct request *rq,
1805	blk_qc_t *cookie,	1813	blk_qc_t *cookie,
1806	bool bypass, bool last)	1814	bool bypass_insert, bool last)
1807	{	1815	{
1808	struct request_queue *q = rq->q;	1816	struct request_queue *q = rq->q;
1809	bool run_queue = true;	1817	bool run_queue = true;
1810	blk_status_t ret = BLK_STS_RESOURCE;
1811	int srcu_idx;
1812	bool force = false;
1813		1818
1814	hctx_lock(hctx, &srcu_idx);
1815	/*	1819	/*
1816	* hctx_lock is needed before checking quiesced flag.	1820	* RCU or SRCU read lock is needed before checking quiesced flag.
1817	*	1821	*
1818	* When queue is stopped or quiesced, ignore 'bypass', insert	1822	* When queue is stopped or quiesced, ignore 'bypass_insert' from
1819	* and return BLK_STS_OK to caller, and avoid driver to try to	1823	* blk_mq_request_issue_directly(), and return BLK_STS_OK to caller,
1820	* dispatch again.	1824	* and avoid driver to try to dispatch again.
1821	*/	1825	*/
1822	if (unlikely(blk_mq_hctx_stopped(hctx) \|\| blk_queue_quiesced(q))) {	1826	if (blk_mq_hctx_stopped(hctx) \|\| blk_queue_quiesced(q)) {
1823	run_queue = false;	1827	run_queue = false;
1824	bypass = false;	1828	bypass_insert = false;
1825	goto out_unlock;	1829	goto insert;
1826	}	1830	}
1827		1831
1828	if (unlikely(q->elevator && !bypass))	1832	if (q->elevator && !bypass_insert)
1829	goto out_unlock;	1833	goto insert;
1830		1834
1831	if (!blk_mq_get_dispatch_budget(hctx))	1835	if (!blk_mq_get_dispatch_budget(hctx))
1832	goto out_unlock;	1836	goto insert;
1833		1837
1834	if (!blk_mq_get_driver_tag(rq)) {	1838	if (!blk_mq_get_driver_tag(rq)) {
1835	blk_mq_put_dispatch_budget(hctx);	1839	blk_mq_put_dispatch_budget(hctx);
1836	goto out_unlock;	1840	goto insert;
1837	}	1841	}
1838		1842
1839	/*	1843	return __blk_mq_issue_directly(hctx, rq, cookie, last);
1840	* Always add a request that has been through	1844	insert:
1841	*.queue_rq() to the hardware dispatch list.	1845	if (bypass_insert)
1842	*/	1846	return BLK_STS_RESOURCE;
1843	force = true;	1847
1844	ret = __blk_mq_issue_directly(hctx, rq, cookie, last);	1848	blk_mq_request_bypass_insert(rq, run_queue);
1845	out_unlock:	1849	return BLK_STS_OK;
		1850	}
		1851
		1852	static void blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx,
		1853	struct request rq, blk_qc_t cookie)
		1854	{
		1855	blk_status_t ret;
		1856	int srcu_idx;
		1857
		1858	might_sleep_if(hctx->flags & BLK_MQ_F_BLOCKING);
		1859
		1860	hctx_lock(hctx, &srcu_idx);
		1861
		1862	ret = __blk_mq_try_issue_directly(hctx, rq, cookie, false, true);
		1863	if (ret == BLK_STS_RESOURCE \|\| ret == BLK_STS_DEV_RESOURCE)
		1864	blk_mq_request_bypass_insert(rq, true);
		1865	else if (ret != BLK_STS_OK)
		1866	blk_mq_end_request(rq, ret);
		1867
		1868	hctx_unlock(hctx, srcu_idx);
		1869	}
		1870
		1871	blk_status_t blk_mq_request_issue_directly(struct request *rq, bool last)
		1872	{
		1873	blk_status_t ret;
		1874	int srcu_idx;
		1875	blk_qc_t unused_cookie;
		1876	struct blk_mq_hw_ctx *hctx = rq->mq_hctx;
		1877
		1878	hctx_lock(hctx, &srcu_idx);
		1879	ret = __blk_mq_try_issue_directly(hctx, rq, &unused_cookie, true, last);
1846	hctx_unlock(hctx, srcu_idx);	1880	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		1881
1872	return ret;	1882	return ret;
1873	}	1883	}
@@ -1875,20 +1885,22 @@ out_unlock: · 1 unmodified line
1875	void blk_mq_try_issue_list_directly(struct blk_mq_hw_ctx *hctx,	1885	void blk_mq_try_issue_list_directly(struct blk_mq_hw_ctx *hctx,
1876	struct list_head *list)	1886	struct list_head *list)
1877	{	1887	{
1878	blk_qc_t unused;
1879	blk_status_t ret = BLK_STS_OK;
1880
1881	while (!list_empty(list)) {	1888	while (!list_empty(list)) {
		1889	blk_status_t ret;
1882	struct request *rq = list_first_entry(list, struct request,	1890	struct request *rq = list_first_entry(list, struct request,
1883	queuelist);	1891	queuelist);
1884		1892
1885	list_del_init(&rq->queuelist);	1893	list_del_init(&rq->queuelist);
1886	if (ret == BLK_STS_OK)	1894	ret = blk_mq_request_issue_directly(rq, list_empty(list));
1887	ret = blk_mq_try_issue_directly(hctx, rq, &unused,	1895	if (ret != BLK_STS_OK) {
1888	false,	1896	if (ret == BLK_STS_RESOURCE \|\|
		1897	ret == BLK_STS_DEV_RESOURCE) {
		1898	blk_mq_request_bypass_insert(rq,
1889	list_empty(list));	1899	list_empty(list));
1890	else	1900	break;
1891	blk_mq_sched_insert_request(rq, false, true, false);	1901	}
		1902	blk_mq_end_request(rq, ret);
		1903	}
1892	}	1904	}
1893		1905
1894	/*	1906	/*
@@ -1896,7 +1908,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	1908	* the driver there was more coming, but that turned out to
1897	* be a lie.	1909	* be a lie.
1898	*/	1910	*/
1899	if (ret != BLK_STS_OK && hctx->queue->mq_ops->commit_rqs)	1911	if (!list_empty(list) && hctx->queue->mq_ops->commit_rqs)
1900	hctx->queue->mq_ops->commit_rqs(hctx);	1912	hctx->queue->mq_ops->commit_rqs(hctx);
1901	}	1913	}
1902		1914
@@ -2003,19 +2015,21 @@ static blk_qc_t blk_mq_make_request(struct request_queue q, struct bio bio) · 100 unmodified lines
2003	plug->rq_count--;	2015	plug->rq_count--;
2004	}	2016	}
2005	blk_add_rq_to_plug(plug, rq);	2017	blk_add_rq_to_plug(plug, rq);
		2018	trace_block_plug(q);
2006		2019
2007	blk_mq_put_ctx(data.ctx);	2020	blk_mq_put_ctx(data.ctx);
2008		2021
2009	if (same_queue_rq) {	2022	if (same_queue_rq) {
2010	data.hctx = same_queue_rq->mq_hctx;	2023	data.hctx = same_queue_rq->mq_hctx;
		2024	trace_block_unplug(q, 1, true);
2011	blk_mq_try_issue_directly(data.hctx, same_queue_rq,	2025	blk_mq_try_issue_directly(data.hctx, same_queue_rq,
2012	&cookie, false, true);	2026	&cookie);
2013	}	2027	}
2014	} else if ((q->nr_hw_queues > 1 && is_sync) \|\| (!q->elevator &&	2028	} else if ((q->nr_hw_queues > 1 && is_sync) \|\| (!q->elevator &&
2015	!data.hctx->dispatch_busy)) {	2029	!data.hctx->dispatch_busy)) {
2016	blk_mq_put_ctx(data.ctx);	2030	blk_mq_put_ctx(data.ctx);
2017	blk_mq_bio_to_request(rq, bio);	2031	blk_mq_bio_to_request(rq, bio);
2018	blk_mq_try_issue_directly(data.hctx, rq, &cookie, false, true);	2032	blk_mq_try_issue_directly(data.hctx, rq, &cookie);
2019	} else {	2033	} else {
2020	blk_mq_put_ctx(data.ctx);	2034	blk_mq_put_ctx(data.ctx);
2021	blk_mq_bio_to_request(rq, bio);	2035	blk_mq_bio_to_request(rq, bio);
@@ -2332,7 +2346,7 @@ static int blk_mq_init_hctx(struct request_queue *q, · 310 unmodified lines
2332	return 0;	2346	return 0;
2333		2347
2334	free_fq:	2348	free_fq:
2335	kfree(hctx->fq);	2349	blk_free_flush_queue(hctx->fq);
2336	exit_hctx:	2350	exit_hctx:
2337	if (set->ops->exit_hctx)	2351	if (set->ops->exit_hctx)
2338	set->ops->exit_hctx(hctx, hctx_idx);	2352	set->ops->exit_hctx(hctx, hctx_idx);
@@ -3121,6 +3135,8 @@ int blk_mq_update_nr_requests(struct request_queue *q, unsigned int nr) · 782 unmodified lines
3121	}	3135	}
3122	if (ret)	3136	if (ret)
3123	break;	3137	break;
		3138	if (q->elevator && q->elevator->type->ops.depth_updated)
		3139	q->elevator->type->ops.depth_updated(hctx);
3124	}	3140	}
3125		3141
3126	if (!ret)	3142	if (!ret)

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);

crypto/testmgr.h+43−1

@@ -5634,7 +5634,49 @@ static const struct hash_testvec poly1305_tv_template[] = { · 5633 unmodified lines
5634	.psize = 80,	5634	.psize = 80,
5635	.digest = "\x13\x00\x00\x00\x00\x00\x00\x00"	5635	.digest = "\x13\x00\x00\x00\x00\x00\x00\x00"
5636	"\x00\x00\x00\x00\x00\x00\x00\x00",	5636	"\x00\x00\x00\x00\x00\x00\x00\x00",
5637	},	5637	}, { /* Regression test for overflow in AVX2 implementation */
		5638	.plaintext = "\xff\xff\xff\xff\xff\xff\xff\xff"
		5639	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5640	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5641	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5642	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5643	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5644	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5645	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5646	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5647	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5648	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5649	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5650	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5651	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5652	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5653	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5654	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5655	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5656	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5657	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5658	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5659	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5660	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5661	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5662	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5663	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5664	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5665	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5666	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5667	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5668	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5669	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5670	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5671	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5672	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5673	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5674	"\xff\xff\xff\xff\xff\xff\xff\xff"
		5675	"\xff\xff\xff\xff",
		5676	.psize = 300,
		5677	.digest = "\xfb\x5e\x96\xd8\x61\xd5\xc7\xc8"
		5678	"\x78\xe5\x87\xcc\x2d\x5a\x22\xe1",
		5679	}
5638	};	5680	};
5639		5681
5640	/* NHPoly1305 test vectors from https://github.com/google/adiantum */	5682	/* NHPoly1305 test vectors from https://github.com/google/adiantum */

drivers/acpi/acpica/evgpe.c+5−1

 	ACPI_FUNCTION_TRACE(ev_enable_gpe);
-	/* Enable the requested GPE */
+	/* Clear the GPE status */
+	status = acpi_hw_clear_gpe(gpe_event_info);
+	if (ACPI_FAILURE(status))
+		return_ACPI_STATUS(status);
+	/* Enable the requested GPE */
 	status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_ENABLE);
 	return_ACPI_STATUS(status);
 }

drivers/acpi/acpica/nsobject.c+4−0

@@ -186,6 +186,10 @@ void acpi_ns_detach_object(struct acpi_namespace_node *node) · 185 unmodified lines
186	}	186	}
187	}	187	}
188		188
		189	if (obj_desc->common.type == ACPI_TYPE_REGION) {
		190	acpi_ut_remove_address_range(obj_desc->region.space_id, node);
		191	}
		192
189	/* Clear the Node entry in all cases */	193	/* Clear the Node entry in all cases */
190		194
191	node->object = NULL;	195	node->object = NULL;

drivers/acpi/nfit/core.c+6−6

 		goto out;
 	}
+	dev_dbg(dev, "%s cmd: %s output length: %d\n", dimm_name,
+			cmd_name, out_obj->buffer.length);
+	print_hex_dump_debug(cmd_name, DUMP_PREFIX_OFFSET, 4, 4,
+			out_obj->buffer.pointer,
+			min_t(u32, 128, out_obj->buffer.length), true);
 	if (call_pkg) {
 		call_pkg->nd_fw_size = out_obj->buffer.length;
 		memcpy(call_pkg->nd_payload + call_pkg->nd_size_in,
 		return 0;
 	}
-	dev_dbg(dev, "%s cmd: %s output length: %d\n", dimm_name,
-			cmd_name, out_obj->buffer.length);
-	print_hex_dump_debug(cmd_name, DUMP_PREFIX_OFFSET, 4, 4,
-			out_obj->buffer.pointer,
-			min_t(u32, 128, out_obj->buffer.length), true);
 	for (i = 0, offset = 0; i < desc->out_num; i++) {
 		u32 out_size = nd_cmd_out_size(nvdimm, cmd, desc, i, buf,
 				(u32 *) out_obj->buffer.pointer,

drivers/acpi/nfit/intel.c+4−6

 	if (!test_bit(cmd, &nfit_mem->dsm_mask))
 		return -ENOTTY;
-	if (old_data)
+	memcpy(nd_cmd.cmd.old_pass, old_data->data,
-		memcpy(nd_cmd.cmd.old_pass, old_data->data,
+			sizeof(nd_cmd.cmd.old_pass));
-				sizeof(nd_cmd.cmd.old_pass));
 	memcpy(nd_cmd.cmd.new_pass, new_data->data,
 			sizeof(nd_cmd.cmd.new_pass));
 	rc = nvdimm_ctl(nvdimm, ND_CMD_CALL, &nd_cmd, sizeof(nd_cmd), NULL);
 	/* flush all cache before we erase DIMM */
 	nvdimm_invalidate_cache();
-	if (nkey)
+	memcpy(nd_cmd.cmd.passphrase, nkey->data,
-		memcpy(nd_cmd.cmd.passphrase, nkey->data,
+			sizeof(nd_cmd.cmd.passphrase));
-				sizeof(nd_cmd.cmd.passphrase));
 	rc = nvdimm_ctl(nvdimm, ND_CMD_CALL, &nd_cmd, sizeof(nd_cmd), NULL);
 	if (rc < 0)
 		return rc;

drivers/base/memory.c+1−1

@@ -506,7 +506,7 @@ static ssize_t probe_store(struct device dev, struct device_attribute attr, · 505 unmodified lines
506		506
507	ret = lock_device_hotplug_sysfs();	507	ret = lock_device_hotplug_sysfs();
508	if (ret)	508	if (ret)
509	goto out;	509	return ret;
510		510
511	nid = memory_add_physaddr_to_nid(phys_addr);	511	nid = memory_add_physaddr_to_nid(phys_addr);
512	ret = __add_memory(nid, phys_addr,	512	ret = __add_memory(nid, phys_addr,

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/virtio_blk.c+2−0

@@ -513,6 +513,8 @@ static int init_vq(struct virtio_blk *vblk) · 512 unmodified lines
513	if (err)	513	if (err)
514	num_vqs = 1;	514	num_vqs = 1;
515		515
		516	num_vqs = min_t(unsigned int, nr_cpu_ids, num_vqs);
		517
516	vblk->vqs = kmalloc_array(num_vqs, sizeof(*vblk->vqs), GFP_KERNEL);	518	vblk->vqs = kmalloc_array(num_vqs, sizeof(*vblk->vqs), GFP_KERNEL);
517	if (!vblk->vqs)	519	if (!vblk->vqs)
518	return -ENOMEM;	520	return -ENOMEM;

drivers/block/xsysace.c+2−0

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

drivers/bluetooth/btusb.c+1−1

 		return 0;
 	}
+	irq_set_status_flags(irq, IRQ_NOAUTOEN);
 	ret = devm_request_irq(&hdev->dev, irq, btusb_oob_wake_handler,
 			       0, "OOB Wake-on-BT", data);
 	if (ret) {
 	}
 	data->oob_wake_irq = irq;
-	disable_irq(irq);
 	bt_dev_info(hdev, "OOB Wake-on-BT configured at IRQ %u", irq);
 	return 0;
 }

drivers/char/Kconfig+1−1

@@ -348,7 +348,7 @@ config XILINX_HWICAP · 347 unmodified lines
348		348
349	config R3964	349	config R3964
350	tristate "Siemens R3964 line discipline"	350	tristate "Siemens R3964 line discipline"
351	depends on TTY	351	depends on TTY && BROKEN
352	---help---	352	---help---
353	This driver allows synchronous communication with devices using the	353	This driver allows synchronous communication with devices using the
354	Siemens R3964 packet protocol. Unless you are dealing with special	354	Siemens R3964 packet protocol. Unless you are dealing with special

drivers/char/ipmi/ipmi_dmi.c+0−1

@@ -66,7 +66,6 @@ static void __init dmi_add_platform_ipmi(unsigned long base_addr, · 65 unmodified lines
66	return;	66	return;
67	}	67	}
68		68
69	memset(&p, 0, sizeof(p));
70	p.addr = base_addr;	69	p.addr = base_addr;
71	p.space = space;	70	p.space = space;
72	p.regspacing = offset;	71	p.regspacing = offset;

drivers/char/ipmi/ipmi_msghandler.c+17−2

@@ -214,6 +214,9 @@ struct ipmi_user { · 213 unmodified lines
214		214
215	/* Does this interface receive IPMI events? */	215	/* Does this interface receive IPMI events? */
216	bool gets_events;	216	bool gets_events;
		217
		218	/* Free must run in process context for RCU cleanup. */
		219	struct work_struct remove_work;
217	};	220	};
218		221
219	static struct ipmi_user acquire_ipmi_user(struct ipmi_user user, int *index)	222	static struct ipmi_user acquire_ipmi_user(struct ipmi_user user, int *index)
@@ -1157,6 +1160,15 @@ static int intf_err_seq(struct ipmi_smi *intf, · 937 unmodified lines
1157	return rv;	1160	return rv;
1158	}	1161	}
1159		1162
		1163	static void free_user_work(struct work_struct *work)
		1164	{
		1165	struct ipmi_user *user = container_of(work, struct ipmi_user,
		1166	remove_work);
		1167
		1168	cleanup_srcu_struct(&user->release_barrier);
		1169	kfree(user);
		1170	}
		1171
1160	int ipmi_create_user(unsigned int if_num,	1172	int ipmi_create_user(unsigned int if_num,
1161	const struct ipmi_user_hndl *handler,	1173	const struct ipmi_user_hndl *handler,
1162	void *handler_data,	1174	void *handler_data,
@@ -1200,6 +1212,8 @@ int ipmi_create_user(unsigned int if_num, · 37 unmodified lines
1200	goto out_kfree;	1212	goto out_kfree;
1201		1213
1202	found:	1214	found:
		1215	INIT_WORK(&new_user->remove_work, free_user_work);
		1216
1203	rv = init_srcu_struct(&new_user->release_barrier);	1217	rv = init_srcu_struct(&new_user->release_barrier);
1204	if (rv)	1218	if (rv)
1205	goto out_kfree;	1219	goto out_kfree;
@@ -1260,8 +1274,9 @@ EXPORT_SYMBOL(ipmi_get_smi_info); · 54 unmodified lines
1260	static void free_user(struct kref *ref)	1274	static void free_user(struct kref *ref)
1261	{	1275	{
1262	struct ipmi_user *user = container_of(ref, struct ipmi_user, refcount);	1276	struct ipmi_user *user = container_of(ref, struct ipmi_user, refcount);
1263	cleanup_srcu_struct(&user->release_barrier);	1277
1264	kfree(user);	1278	/* SRCU cleanup must happen in task context. */
		1279	schedule_work(&user->remove_work);
1265	}	1280	}
1266		1281
1267	static void _ipmi_destroy_user(struct ipmi_user *user)	1282	static void _ipmi_destroy_user(struct ipmi_user *user)

drivers/char/ipmi/ipmi_si_hardcode.c+2−0

@@ -118,6 +118,8 @@ void __init ipmi_hardcode_init(void) · 117 unmodified lines
118	char *str;	118	char *str;
119	char *si_type[SI_MAX_PARMS];	119	char *si_type[SI_MAX_PARMS];
120		120
		121	memset(si_type, 0, sizeof(si_type));
		122
121	/* Parse out the si_type string into its components. */	123	/* Parse out the si_type string into its components. */
122	str = si_type_str;	124	str = si_type_str;
123	if (*str != '\0') {	125	if (*str != '\0') {

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/clk/at91/clk-programmable.c+43−14

 #define PROG_ID_MAX		7
 #define PROG_STATUS_MASK(id)	(1 << ((id) + 8))
-#define PROG_PRES_MASK		0x7
+#define PROG_PRES(layout, pckr)	((pckr >> layout->pres_shift) & layout->pres_mask)
-#define PROG_PRES(layout, pckr)	((pckr >> layout->pres_shift) & PROG_PRES_MASK)
 #define PROG_MAX_RM9200_CSS	3
 struct clk_programmable {
 						  unsigned long parent_rate)
 {
 	struct clk_programmable *prog = to_clk_programmable(hw);
+	const struct clk_programmable_layout *layout = prog->layout;
 	unsigned int pckr;
+	unsigned long rate;
 	regmap_read(prog->regmap, AT91_PMC_PCKR(prog->id), &pckr);
-	return parent_rate >> PROG_PRES(prog->layout, pckr);
+	if (layout->is_pres_direct)
+		rate = parent_rate / (PROG_PRES(layout, pckr) + 1);
+	else
+		rate = parent_rate >> PROG_PRES(layout, pckr);
+	return rate;
 }
 static int clk_programmable_determine_rate(struct clk_hw *hw,
 					   struct clk_rate_request *req)
 {
+	struct clk_programmable *prog = to_clk_programmable(hw);
+	const struct clk_programmable_layout *layout = prog->layout;
 	struct clk_hw *parent;
 	long best_rate = -EINVAL;
 	unsigned long parent_rate;
-	unsigned long tmp_rate;
+	unsigned long tmp_rate = 0;
 	int shift;
 	int i;
 			continue;
 		parent_rate = clk_hw_get_rate(parent);
-		for (shift = 0; shift < PROG_PRES_MASK; shift++) {
+		if (layout->is_pres_direct) {
-			tmp_rate = parent_rate >> shift;
+			for (shift = 0; shift <= layout->pres_mask; shift++) {
-			if (tmp_rate <= req->rate)
+				tmp_rate = parent_rate / (shift + 1);
-				break;
+				if (tmp_rate <= req->rate)
+					break;
+			}
+		} else {
+			for (shift = 0; shift < layout->pres_mask; shift++) {
+				tmp_rate = parent_rate >> shift;
+				if (tmp_rate <= req->rate)
+					break;
+			}
 		}
 		if (tmp_rate > req->rate)
 	if (!div)
 		return -EINVAL;
-	shift = fls(div) - 1;
+	if (layout->is_pres_direct) {
+		shift = div - 1;
-	if (div != (1 << shift))
+		if (shift > layout->pres_mask)
-		return -EINVAL;
+			return -EINVAL;
+	} else {
+		shift = fls(div) - 1;
-	if (shift >= PROG_PRES_MASK)
+		if (div != (1 << shift))
-		return -EINVAL;
+			return -EINVAL;
+		if (shift >= layout->pres_mask)
+			return -EINVAL;
+	}
 	regmap_update_bits(prog->regmap, AT91_PMC_PCKR(prog->id),
-			   PROG_PRES_MASK << layout->pres_shift,
+			   layout->pres_mask << layout->pres_shift,
 			   shift << layout->pres_shift);
 	return 0;
 }
 const struct clk_programmable_layout at91rm9200_programmable_layout = {
+	.pres_mask = 0x7,
 	.pres_shift = 2,
 	.css_mask = 0x3,
 	.have_slck_mck = 0,
+	.is_pres_direct = 0,
 };
 const struct clk_programmable_layout at91sam9g45_programmable_layout = {
+	.pres_mask = 0x7,
 	.pres_shift = 2,
 	.css_mask = 0x3,
 	.have_slck_mck = 1,
+	.is_pres_direct = 0,
 };
 const struct clk_programmable_layout at91sam9x5_programmable_layout = {
+	.pres_mask = 0x7,
 	.pres_shift = 4,
 	.css_mask = 0x7,
 	.have_slck_mck = 0,
+	.is_pres_direct = 0,
 };

drivers/clk/at91/pmc.h+2−0

 };
 struct clk_programmable_layout {
+	u8 pres_mask;
 	u8 pres_shift;
 	u8 css_mask;
 	u8 have_slck_mck;
+	u8 is_pres_direct;
 };
 extern const struct clk_programmable_layout at91rm9200_programmable_layout;

drivers/clk/at91/sama5d2.c+9−1

 	  .pll = true },
 };
+static const struct clk_programmable_layout sama5d2_programmable_layout = {
+	.pres_mask = 0xff,
+	.pres_shift = 4,
+	.css_mask = 0x7,
+	.have_slck_mck = 0,
+	.is_pres_direct = 1,
+};
 static void __init sama5d2_pmc_setup(struct device_node *np)
 {
 	struct clk_range range = CLK_RANGE(0, 0);
 		hw = at91_clk_register_programmable(regmap, name,
 						    parent_names, 6, i,
-						    &at91sam9x5_programmable_layout);
+						    &sama5d2_programmable_layout);
 		if (IS_ERR(hw))
 			goto err_free;
 	}

drivers/clk/imx/clk-pll14xx.c+1−1

@@ -362,7 +362,7 @@ struct clk imx_clk_pll14xx(const char name, const char *parent_name, · 361 unmodified lines
362		362
363	switch (pll_clk->type) {	363	switch (pll_clk->type) {
364	case PLL_1416X:	364	case PLL_1416X:
365	if (!pll->rate_table)	365	if (!pll_clk->rate_table)
366	init.ops = &clk_pll1416x_min_ops;	366	init.ops = &clk_pll1416x_min_ops;
367	else	367	else
368	init.ops = &clk_pll1416x_ops;	368	init.ops = &clk_pll1416x_ops;

drivers/clk/mediatek/clk-gate.c+1−2

 		return ERR_PTR(-ENOMEM);
 	init.name = name;
-	init.flags = CLK_SET_RATE_PARENT;
+	init.flags = flags | CLK_SET_RATE_PARENT;
 	init.parent_names = parent_name ? &parent_name : NULL;
 	init.num_parents = parent_name ? 1 : 0;
 	init.ops = ops;
-	init.flags = flags;
 	cg->regmap = regmap;
 	cg->set_ofs = set_ofs;

drivers/clk/meson/clk-pll.c+1−1

@@ -120,7 +120,7 @@ static bool meson_clk_pll_is_better(unsigned long rate, · 119 unmodified lines
120	return true;	120	return true;
121	} else {	121	} else {
122	/* Round down */	122	/* Round down */
123	if (now < rate && best < now)	123	if (now <= rate && best < now)
124	return true;	124	return true;
125	}	125	}
126		126

drivers/clk/meson/g12a.c+3−3

@@ -960,14 +960,14 @@ static struct clk_regmap g12a_sd_emmc_c_clk0 = { · 959 unmodified lines
960	/* VPU Clock */	960	/* VPU Clock */
961		961
962	static const char * const g12a_vpu_parent_names[] = {	962	static const char * const g12a_vpu_parent_names[] = {
963	"fclk_div4", "fclk_div3", "fclk_div5", "fclk_div7",	963	"fclk_div3", "fclk_div4", "fclk_div5", "fclk_div7",
964	"mpll1", "vid_pll", "hifi_pll", "gp0_pll",	964	"mpll1", "vid_pll", "hifi_pll", "gp0_pll",
965	};	965	};
966		966
967	static struct clk_regmap g12a_vpu_0_sel = {	967	static struct clk_regmap g12a_vpu_0_sel = {
968	.data = &(struct clk_regmap_mux_data){	968	.data = &(struct clk_regmap_mux_data){
969	.offset = HHI_VPU_CLK_CNTL,	969	.offset = HHI_VPU_CLK_CNTL,
970	.mask = 0x3,	970	.mask = 0x7,
971	.shift = 9,	971	.shift = 9,
972	},	972	},
973	.hw.init = &(struct clk_init_data){	973	.hw.init = &(struct clk_init_data){
@@ -1011,7 +1011,7 @@ static struct clk_regmap g12a_vpu_0 = { · 37 unmodified lines
1011	static struct clk_regmap g12a_vpu_1_sel = {	1011	static struct clk_regmap g12a_vpu_1_sel = {
1012	.data = &(struct clk_regmap_mux_data){	1012	.data = &(struct clk_regmap_mux_data){
1013	.offset = HHI_VPU_CLK_CNTL,	1013	.offset = HHI_VPU_CLK_CNTL,
1014	.mask = 0x3,	1014	.mask = 0x7,
1015	.shift = 25,	1015	.shift = 25,
1016	},	1016	},
1017	.hw.init = &(struct clk_init_data){	1017	.hw.init = &(struct clk_init_data){

drivers/clk/meson/gxbb.c+2−0

 		.offset = HHI_VDEC_CLK_CNTL,
 		.shift = 0,
 		.width = 7,
+		.flags = CLK_DIVIDER_ROUND_CLOSEST,
 	},
 	.hw.init = &(struct clk_init_data){
 		.name = "vdec_1_div",
 		.offset = HHI_VDEC2_CLK_CNTL,
 		.shift = 16,
 		.width = 7,
+		.flags = CLK_DIVIDER_ROUND_CLOSEST,
 	},
 	.hw.init = &(struct clk_init_data){
 		.name = "vdec_hevc_div",

drivers/clk/meson/vid-pll-div.c+2−2

@@ -82,8 +82,8 @@ static unsigned long meson_vid_pll_div_recalc_rate(struct clk_hw *hw, · 81 unmodified lines
82	div = _get_table_val(meson_parm_read(clk->map, &pll_div->val),	82	div = _get_table_val(meson_parm_read(clk->map, &pll_div->val),
83	meson_parm_read(clk->map, &pll_div->sel));	83	meson_parm_read(clk->map, &pll_div->sel));
84	if (!div \|\| !div->divider) {	84	if (!div \|\| !div->divider) {
85	pr_info("%s: Invalid config value for vid_pll_div\n", __func__);	85	pr_debug("%s: Invalid config value for vid_pll_div\n", __func__);
86	return parent_rate;	86	return 0;
87	}	87	}
88		88
89	return DIV_ROUND_UP_ULL(parent_rate * div->multiplier, div->divider);	89	return DIV_ROUND_UP_ULL(parent_rate * div->multiplier, div->divider);

drivers/clk/x86/clk-pmc-atom.c+11−3

 };
 static struct clk_plt *plt_clk_register(struct platform_device *pdev, int id,
-					void __iomem *base,
+					const struct pmc_clk_data *pmc_data,
 					const char **parent_names,
 					int num_parents)
 {
 	init.num_parents = num_parents;
 	pclk->hw.init = &init;
-	pclk->reg = base + PMC_CLK_CTL_OFFSET + id * PMC_CLK_CTL_SIZE;
+	pclk->reg = pmc_data->base + PMC_CLK_CTL_OFFSET + id * PMC_CLK_CTL_SIZE;
 	spin_lock_init(&pclk->lock);
+	/*
+	 * On some systems, the pmc_plt_clocks already enabled by the
+	 * firmware are being marked as critical to avoid them being
+	 * gated by the clock framework.
+	 */
+	if (pmc_data->critical && plt_clk_is_enabled(&pclk->hw))
+		init.flags |= CLK_IS_CRITICAL;
 	ret = devm_clk_hw_register(&pdev->dev, &pclk->hw);
 	if (ret) {
 		pclk = ERR_PTR(ret);
 		return PTR_ERR(parent_names);
 	for (i = 0; i < PMC_CLK_NUM; i++) {
-		data->clks[i] = plt_clk_register(pdev, i, pmc_data->base,
+		data->clks[i] = plt_clk_register(pdev, i, pmc_data,
 						 parent_names, data->nparents);
 		if (IS_ERR(data->clks[i])) {
 			err = PTR_ERR(data->clks[i]);

drivers/clocksource/Kconfig+1−0

@@ -145,6 +145,7 @@ config VT8500_TIMER · 144 unmodified lines
145	config NPCM7XX_TIMER	145	config NPCM7XX_TIMER
146	bool "NPCM7xx timer driver" if COMPILE_TEST	146	bool "NPCM7xx timer driver" if COMPILE_TEST
147	depends on HAS_IOMEM	147	depends on HAS_IOMEM
		148	select TIMER_OF
148	select CLKSRC_MMIO	149	select CLKSRC_MMIO
149	help	150	help
150	Enable 24-bit TIMER0 and TIMER1 counters in the NPCM7xx architecture,	151	Enable 24-bit TIMER0 and TIMER1 counters in the NPCM7xx architecture,

drivers/clocksource/arm_arch_timer.c+1−4

  * published by the Free Software Foundation.
  */
-#define pr_fmt(fmt)	"arm_arch_timer: " fmt
+#define pr_fmt(fmt) 	"arch_timer: " fmt
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <clocksource/arm_arch_timer.h>
-#undef pr_fmt
-#define pr_fmt(fmt) "arch_timer: " fmt
 #define CNTTIDR		0x08
 #define CNTTIDR_VIRT(n)	(BIT(1) << ((n) * 4))

drivers/clocksource/timer-oxnas-rps.c+1−1

@@ -296,4 +296,4 @@ err_alloc: · 295 unmodified lines
296	TIMER_OF_DECLARE(ox810se_rps,	296	TIMER_OF_DECLARE(ox810se_rps,
297	"oxsemi,ox810se-rps-timer", oxnas_rps_timer_init);	297	"oxsemi,ox810se-rps-timer", oxnas_rps_timer_init);
298	TIMER_OF_DECLARE(ox820_rps,	298	TIMER_OF_DECLARE(ox820_rps,
299	"oxsemi,ox820se-rps-timer", oxnas_rps_timer_init);	299	"oxsemi,ox820-rps-timer", oxnas_rps_timer_init);

drivers/clocksource/timer-ti-dm.c+0−28

@@ -585,34 +585,6 @@ static int omap_dm_timer_set_load(struct omap_dm_timer *timer, int autoreload, · 584 unmodified lines
585	return 0;	585	return 0;
586	}	586	}
587		587
588	/* Optimized set_load which removes costly spin wait in timer_start */
589	static int omap_dm_timer_set_load_start(struct omap_dm_timer *timer,
590	int autoreload, unsigned int load)
591	{
592	u32 l;
593
594	if (unlikely(!timer))
595	return -EINVAL;
596
597	omap_dm_timer_enable(timer);
598
599	l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
600	if (autoreload) {
601	l \|= OMAP_TIMER_CTRL_AR;
602	omap_dm_timer_write_reg(timer, OMAP_TIMER_LOAD_REG, load);
603	} else {
604	l &= ~OMAP_TIMER_CTRL_AR;
605	}
606	l \|= OMAP_TIMER_CTRL_ST;
607
608	__omap_dm_timer_load_start(timer, l, load, timer->posted);
609
610	/* Save the context */
611	timer->context.tclr = l;
612	timer->context.tldr = load;
613	timer->context.tcrr = load;
614	return 0;
615	}
616	static int omap_dm_timer_set_match(struct omap_dm_timer *timer, int enable,	588	static int omap_dm_timer_set_match(struct omap_dm_timer *timer, int enable,
617	unsigned int match)	589	unsigned int match)
618	{	590	{

drivers/cpufreq/intel_pstate.c+4−1

 	const struct x86_cpu_id *id;
 	int rc;
+	if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL)
+		return -ENODEV;
 	if (no_load)
 		return -ENODEV;
 	} else {
 		id = x86_match_cpu(intel_pstate_cpu_ids);
 		if (!id) {
-			pr_info("CPU ID not supported\n");
+			pr_info("CPU model not supported\n");
 			return -ENODEV;
 		}

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/extcon/Kconfig+1−1

@@ -116,7 +116,7 @@ config EXTCON_PALMAS · 115 unmodified lines
116		116
117	config EXTCON_PTN5150	117	config EXTCON_PTN5150
118	tristate "NXP PTN5150 CC LOGIC USB EXTCON support"	118	tristate "NXP PTN5150 CC LOGIC USB EXTCON support"
119	depends on I2C && GPIOLIB \|\| COMPILE_TEST	119	depends on I2C && (GPIOLIB \|\| COMPILE_TEST)
120	select REGMAP_I2C	120	select REGMAP_I2C
121	help	121	help
122	Say Y here to enable support for USB peripheral and USB host	122	Say Y here to enable support for USB peripheral and USB host

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c+15−4

 		/* No need to recover an evicted BO */
 		if (shadow->tbo.mem.mem_type != TTM_PL_TT ||
+		    shadow->tbo.mem.start == AMDGPU_BO_INVALID_OFFSET ||
 		    shadow->parent->tbo.mem.mem_type != TTM_PL_VRAM)
 			continue;
 			break;
 		if (fence) {
-			r = dma_fence_wait_timeout(fence, false, tmo);
+			tmo = dma_fence_wait_timeout(fence, false, tmo);
 			dma_fence_put(fence);
 			fence = next;
-			if (r <= 0)
+			if (tmo == 0) {
+				r = -ETIMEDOUT;
 				break;
+			} else if (tmo < 0) {
+				r = tmo;
+				break;
+			}
 		} else {
 			fence = next;
 		}
 		tmo = dma_fence_wait_timeout(fence, false, tmo);
 	dma_fence_put(fence);
-	if (r <= 0 || tmo <= 0) {
+	if (r < 0 || tmo <= 0) {
-		DRM_ERROR("recover vram bo from shadow failed\n");
+		DRM_ERROR("recover vram bo from shadow failed, r is %ld, tmo is %ld\n", r, tmo);
 		return -EIO;
 	}
 	struct pci_dev *pdev = adev->pdev;
 	enum pci_bus_speed cur_speed;
 	enum pcie_link_width cur_width;
+	u32 ret = 1;
 	*speed = PCI_SPEED_UNKNOWN;
 	*width = PCIE_LNK_WIDTH_UNKNOWN;
 	while (pdev) {
 		cur_speed = pcie_get_speed_cap(pdev);
 		cur_width = pcie_get_width_cap(pdev);
+		ret = pcie_bandwidth_available(adev->pdev, NULL,
+						       NULL, &cur_width);
+		if (!ret)
+			cur_width = PCIE_LNK_WIDTH_RESRV;
 		if (cur_speed != PCI_SPEED_UNKNOWN) {
 			if (*speed == PCI_SPEED_UNKNOWN)

drivers/gpu/drm/amd/amdgpu/amdgpu_ib.c+3−0

 #include "amdgpu_trace.h"
 #define AMDGPU_IB_TEST_TIMEOUT	msecs_to_jiffies(1000)
+#define AMDGPU_IB_TEST_GFX_XGMI_TIMEOUT	msecs_to_jiffies(2000)
 /*
  * IB
 		 * cost waiting for it coming back under RUNTIME only
 		*/
 		tmo_gfx = 8 * AMDGPU_IB_TEST_TIMEOUT;
+	} else if (adev->gmc.xgmi.hive_id) {
+		tmo_gfx = AMDGPU_IB_TEST_GFX_XGMI_TIMEOUT;
 	}
 	for (i = 0; i < adev->num_rings; ++i) {

drivers/gpu/drm/amd/amdgpu/gfx_v9_0.c+0−2

@@ -2405,8 +2405,6 @@ static int gfx_v9_0_rlc_resume(struct amdgpu_device *adev) · 2404 unmodified lines
2405	/* disable CG */	2405	/* disable CG */
2406	WREG32_SOC15(GC, 0, mmRLC_CGCG_CGLS_CTRL, 0);	2406	WREG32_SOC15(GC, 0, mmRLC_CGCG_CGLS_CTRL, 0);
2407		2407
2408	adev->gfx.rlc.funcs->reset(adev);
2409
2410	gfx_v9_0_init_pg(adev);	2408	gfx_v9_0_init_pg(adev);
2411		2409
2412	if (adev->firmware.load_type != AMDGPU_FW_LOAD_PSP) {	2410	if (adev->firmware.load_type != AMDGPU_FW_LOAD_PSP) {

drivers/gpu/drm/amd/amdgpu/mmhub_v1_0.c+1−0

@@ -182,6 +182,7 @@ static void mmhub_v1_0_init_cache_regs(struct amdgpu_device *adev) · 181 unmodified lines
182	tmp = REG_SET_FIELD(tmp, VM_L2_CNTL3,	182	tmp = REG_SET_FIELD(tmp, VM_L2_CNTL3,
183	L2_CACHE_BIGK_FRAGMENT_SIZE, 6);	183	L2_CACHE_BIGK_FRAGMENT_SIZE, 6);
184	}	184	}
		185	WREG32_SOC15(MMHUB, 0, mmVM_L2_CNTL3, tmp);
185		186
186	tmp = mmVM_L2_CNTL4_DEFAULT;	187	tmp = mmVM_L2_CNTL4_DEFAULT;
187	tmp = REG_SET_FIELD(tmp, VM_L2_CNTL4, VMC_TAP_PDE_REQUEST_PHYSICAL, 0);	188	tmp = REG_SET_FIELD(tmp, VM_L2_CNTL4, VMC_TAP_PDE_REQUEST_PHYSICAL, 0);

drivers/gpu/drm/amd/amdkfd/kfd_device.c+1−0

@@ -320,6 +320,7 @@ static const struct kfd_deviceid supported_devices[] = { · 319 unmodified lines
320	{ 0x9876, &carrizo_device_info }, /* Carrizo */	320	{ 0x9876, &carrizo_device_info }, /* Carrizo */
321	{ 0x9877, &carrizo_device_info }, /* Carrizo */	321	{ 0x9877, &carrizo_device_info }, /* Carrizo */
322	{ 0x15DD, &raven_device_info }, /* Raven */	322	{ 0x15DD, &raven_device_info }, /* Raven */
		323	{ 0x15D8, &raven_device_info }, /* Raven */
323	#endif	324	#endif
324	{ 0x67A0, &hawaii_device_info }, /* Hawaii */	325	{ 0x67A0, &hawaii_device_info }, /* Hawaii */
325	{ 0x67A1, &hawaii_device_info }, /* Hawaii */	326	{ 0x67A1, &hawaii_device_info }, /* Hawaii */

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c+1−0

@@ -4533,6 +4533,7 @@ static void handle_cursor_update(struct drm_plane *plane, · 4532 unmodified lines
4533	amdgpu_crtc->cursor_width = plane->state->crtc_w;	4533	amdgpu_crtc->cursor_width = plane->state->crtc_w;
4534	amdgpu_crtc->cursor_height = plane->state->crtc_h;	4534	amdgpu_crtc->cursor_height = plane->state->crtc_h;
4535		4535
		4536	memset(&attributes, 0, sizeof(attributes));
4536	attributes.address.high_part = upper_32_bits(address);	4537	attributes.address.high_part = upper_32_bits(address);
4537	attributes.address.low_part = lower_32_bits(address);	4538	attributes.address.low_part = lower_32_bits(address);
4538	attributes.width = plane->state->crtc_w;	4539	attributes.width = plane->state->crtc_w;

drivers/gpu/drm/amd/display/dc/core/dc.c+19−0

@@ -1377,6 +1377,11 @@ static enum surface_update_type det_surface_update(const struct dc *dc, · 1376 unmodified lines
1377	return UPDATE_TYPE_FULL;	1377	return UPDATE_TYPE_FULL;
1378	}	1378	}
1379		1379
		1380	if (u->surface->force_full_update) {
		1381	update_flags->bits.full_update = 1;
		1382	return UPDATE_TYPE_FULL;
		1383	}
		1384
1380	type = get_plane_info_update_type(u);	1385	type = get_plane_info_update_type(u);
1381	elevate_update_type(&overall_type, type);	1386	elevate_update_type(&overall_type, type);
1382		1387
@@ -1802,6 +1807,14 @@ void dc_commit_updates_for_stream(struct dc *dc, · 419 unmodified lines
1802	}	1807	}
1803		1808
1804	dc_resource_state_copy_construct(state, context);	1809	dc_resource_state_copy_construct(state, context);
		1810
		1811	for (i = 0; i < dc->res_pool->pipe_count; i++) {
		1812	struct pipe_ctx *new_pipe = &context->res_ctx.pipe_ctx[i];
		1813	struct pipe_ctx *old_pipe = &dc->current_state->res_ctx.pipe_ctx[i];
		1814
		1815	if (new_pipe->plane_state && new_pipe->plane_state != old_pipe->plane_state)
		1816	new_pipe->plane_state->force_full_update = true;
		1817	}
1805	}	1818	}
1806		1819
1807		1820
@@ -1838,6 +1851,12 @@ void dc_commit_updates_for_stream(struct dc *dc, · 30 unmodified lines
1838	dc->current_state = context;	1851	dc->current_state = context;
1839	dc_release_state(old);	1852	dc_release_state(old);
1840		1853
		1854	for (i = 0; i < dc->res_pool->pipe_count; i++) {
		1855	struct pipe_ctx *pipe_ctx = &context->res_ctx.pipe_ctx[i];
		1856
		1857	if (pipe_ctx->plane_state && pipe_ctx->stream == stream)
		1858	pipe_ctx->plane_state->force_full_update = false;
		1859	}
1841	}	1860	}
1842	/let's use current_state to update watermark etc/	1861	/let's use current_state to update watermark etc/
1843	if (update_type >= UPDATE_TYPE_FULL)	1862	if (update_type >= UPDATE_TYPE_FULL)

drivers/gpu/drm/amd/display/dc/core/dc_link.c+6−0

 void core_link_disable_stream(struct pipe_ctx *pipe_ctx, int option)
 {
 	struct dc  *core_dc = pipe_ctx->stream->ctx->dc;
+	struct dc_stream_state *stream = pipe_ctx->stream;
 	core_dc->hwss.blank_stream(pipe_ctx);
 	if (pipe_ctx->stream->signal == SIGNAL_TYPE_DISPLAY_PORT_MST)
 		deallocate_mst_payload(pipe_ctx);
+	if (dc_is_hdmi_signal(pipe_ctx->stream->signal))
+		dal_ddc_service_write_scdc_data(
+			stream->link->ddc, 0,
+			stream->timing.flags.LTE_340MCSC_SCRAMBLE);
 	core_dc->hwss.disable_stream(pipe_ctx, option);
 	disable_link(pipe_ctx->stream->link, pipe_ctx->stream->signal);

drivers/gpu/drm/amd/display/dc/dc.h+3−0

@@ -503,6 +503,9 @@ struct dc_plane_state { · 502 unmodified lines
503	struct dc_plane_status status;	503	struct dc_plane_status status;
504	struct dc_context *ctx;	504	struct dc_context *ctx;
505		505
		506	/* HACK: Workaround for forcing full reprogramming under some conditions */
		507	bool force_full_update;
		508
506	/* private to dc_surface.c */	509	/* private to dc_surface.c */
507	enum dc_irq_source irq_source;	510	enum dc_irq_source irq_source;
508	struct kref refcount;	511	struct kref refcount;

drivers/gpu/drm/amd/display/dc/dce/dce_aux.c+6−3

 				1,
 				0);
 	}
+	REG_UPDATE(AUX_INTERRUPT_CONTROL, AUX_SW_DONE_ACK, 1);
+	REG_WAIT(AUX_SW_STATUS, AUX_SW_DONE, 0,
+				10, aux110->timeout_period/10);
 	/* set the delay and the number of bytes to write */
 	/* The length include
 		}
 	}
-	REG_UPDATE(AUX_INTERRUPT_CONTROL, AUX_SW_DONE_ACK, 1);
-	REG_WAIT(AUX_SW_STATUS, AUX_SW_DONE, 0,
-				10, aux110->timeout_period/10);
 	REG_UPDATE(AUX_SW_CONTROL, AUX_SW_GO, 1);
 }

drivers/gpu/drm/amd/display/dc/dce/dce_aux.h+3−3

@@ -71,11 +71,11 @@ enum { /* This is the timeout as defined in DP 1.2a, · 70 unmodified lines
71	* at most within ~240usec. That means,	71	* at most within ~240usec. That means,
72	* increasing this timeout will not affect normal operation,	72	* increasing this timeout will not affect normal operation,
73	* and we'll timeout after	73	* and we'll timeout after
74	* SW_AUX_TIMEOUT_PERIOD_MULTIPLIER * AUX_TIMEOUT_PERIOD = 1600usec.	74	* SW_AUX_TIMEOUT_PERIOD_MULTIPLIER * AUX_TIMEOUT_PERIOD = 2400usec.
75	* This timeout is especially important for	75	* This timeout is especially important for
76	* resume from S3 and CTS.	76	* converters, resume from S3, and CTS.
77	*/	77	*/
78	SW_AUX_TIMEOUT_PERIOD_MULTIPLIER = 4	78	SW_AUX_TIMEOUT_PERIOD_MULTIPLIER = 6
79	};	79	};
80		80
81	struct dce_aux {	81	struct dce_aux {

drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hubp.c+2−21

@@ -1150,28 +1150,9 @@ void hubp1_cursor_set_position( · 1149 unmodified lines
1150	REG_UPDATE(CURSOR_CONTROL,	1150	REG_UPDATE(CURSOR_CONTROL,
1151	CURSOR_ENABLE, cur_en);	1151	CURSOR_ENABLE, cur_en);
1152		1152
1153	//account for cases where we see negative offset relative to overlay plane	1153	REG_SET_2(CURSOR_POSITION, 0,
1154	if (src_x_offset < 0 && src_y_offset < 0) {
1155	REG_SET_2(CURSOR_POSITION, 0,
1156	CURSOR_X_POSITION, 0,
1157	CURSOR_Y_POSITION, 0);
1158	x_hotspot -= src_x_offset;
1159	y_hotspot -= src_y_offset;
1160	} else if (src_x_offset < 0) {
1161	REG_SET_2(CURSOR_POSITION, 0,
1162	CURSOR_X_POSITION, 0,
1163	CURSOR_Y_POSITION, pos->y);
1164	x_hotspot -= src_x_offset;
1165	} else if (src_y_offset < 0) {
1166	REG_SET_2(CURSOR_POSITION, 0,
1167	CURSOR_X_POSITION, pos->x,	1154	CURSOR_X_POSITION, pos->x,
1168	CURSOR_Y_POSITION, 0);	1155	CURSOR_Y_POSITION, pos->y);
1169	y_hotspot -= src_y_offset;
1170	} else {
1171	REG_SET_2(CURSOR_POSITION, 0,
1172	CURSOR_X_POSITION, pos->x,
1173	CURSOR_Y_POSITION, pos->y);
1174	}
1175		1156
1176	REG_SET_2(CURSOR_HOT_SPOT, 0,	1157	REG_SET_2(CURSOR_HOT_SPOT, 0,
1177	CURSOR_HOT_SPOT_X, x_hotspot,	1158	CURSOR_HOT_SPOT_X, x_hotspot,

drivers/gpu/drm/amd/powerplay/hwmgr/vega20_hwmgr.c+18−2

 	 *   MP0CLK DS
 	 */
 	data->registry_data.disallowed_features = 0xE0041C00;
+	/* ECC feature should be disabled on old SMUs */
+	smum_send_msg_to_smc(hwmgr, PPSMC_MSG_GetSmuVersion);
+	hwmgr->smu_version = smum_get_argument(hwmgr);
+	if (hwmgr->smu_version < 0x282100)
+		data->registry_data.disallowed_features |= FEATURE_ECC_MASK;
 	data->registry_data.od_state_in_dc_support = 0;
 	data->registry_data.thermal_support = 1;
 	data->registry_data.skip_baco_hardware = 0;
 	data->smu_features[GNLD_DS_MP1CLK].smu_feature_id = FEATURE_DS_MP1CLK_BIT;
 	data->smu_features[GNLD_DS_MP0CLK].smu_feature_id = FEATURE_DS_MP0CLK_BIT;
 	data->smu_features[GNLD_XGMI].smu_feature_id = FEATURE_XGMI_BIT;
+	data->smu_features[GNLD_ECC].smu_feature_id = FEATURE_ECC_BIT;
 	for (i = 0; i < GNLD_FEATURES_MAX; i++) {
 		data->smu_features[i].smu_feature_bitmap =
 				"FCLK_DS",
 				"MP1CLK_DS",
 				"MP0CLK_DS",
-				"XGMI"};
+				"XGMI",
+				"ECC"};
 	static const char *output_title[] = {
 				"FEATURES",
 				"BITMASK",
 	struct vega20_single_dpm_table *dpm_table;
 	bool vblank_too_short = false;
 	bool disable_mclk_switching;
+	bool disable_fclk_switching;
 	uint32_t i, latency;
 	disable_mclk_switching = ((1 < hwmgr->display_config->num_display) &&
 	if (hwmgr->display_config->nb_pstate_switch_disable)
 		dpm_table->dpm_state.hard_min_level = dpm_table->dpm_levels[dpm_table->count - 1].value;
+	if ((disable_mclk_switching &&
+	    (dpm_table->dpm_state.hard_min_level == dpm_table->dpm_levels[dpm_table->count - 1].value)) ||
+	     hwmgr->display_config->min_mem_set_clock / 100 >= dpm_table->dpm_levels[dpm_table->count - 1].value)
+		disable_fclk_switching = true;
+	else
+		disable_fclk_switching = false;
 	/* fclk */
 	dpm_table = &(data->dpm_table.fclk_table);
 	dpm_table->dpm_state.soft_min_level = dpm_table->dpm_levels[0].value;
 	dpm_table->dpm_state.soft_max_level = VG20_CLOCK_MAX_DEFAULT;
 	dpm_table->dpm_state.hard_min_level = dpm_table->dpm_levels[0].value;
 	dpm_table->dpm_state.hard_max_level = VG20_CLOCK_MAX_DEFAULT;
-	if (hwmgr->display_config->nb_pstate_switch_disable)
+	if (hwmgr->display_config->nb_pstate_switch_disable || disable_fclk_switching)
 		dpm_table->dpm_state.soft_min_level = dpm_table->dpm_levels[dpm_table->count - 1].value;
 	/* vclk */

drivers/gpu/drm/amd/powerplay/hwmgr/vega20_hwmgr.h+1−0

@@ -80,6 +80,7 @@ enum { · 79 unmodified lines
80	GNLD_DS_MP1CLK,	80	GNLD_DS_MP1CLK,
81	GNLD_DS_MP0CLK,	81	GNLD_DS_MP0CLK,
82	GNLD_XGMI,	82	GNLD_XGMI,
		83	GNLD_ECC,
83		84
84	GNLD_FEATURES_MAX	85	GNLD_FEATURES_MAX
85	};	86	};

drivers/gpu/drm/amd/powerplay/inc/smu11_driver_if.h+3−2

 #define FEATURE_DS_MP1CLK_BIT           30
 #define FEATURE_DS_MP0CLK_BIT           31
 #define FEATURE_XGMI_BIT                32
-#define FEATURE_SPARE_33_BIT            33
+#define FEATURE_ECC_BIT                 33
 #define FEATURE_SPARE_34_BIT            34
 #define FEATURE_SPARE_35_BIT            35
 #define FEATURE_SPARE_36_BIT            36
 #define FEATURE_DS_FCLK_MASK            (1 << FEATURE_DS_FCLK_BIT            )
 #define FEATURE_DS_MP1CLK_MASK          (1 << FEATURE_DS_MP1CLK_BIT          )
 #define FEATURE_DS_MP0CLK_MASK          (1 << FEATURE_DS_MP0CLK_BIT          )
-#define FEATURE_XGMI_MASK               (1 << FEATURE_XGMI_BIT               )
+#define FEATURE_XGMI_MASK               (1ULL << FEATURE_XGMI_BIT               )
+#define FEATURE_ECC_MASK                (1ULL << FEATURE_ECC_BIT                )
 #define DPM_OVERRIDE_DISABLE_SOCCLK_PID             0x00000001
 #define DPM_OVERRIDE_DISABLE_UCLK_PID               0x00000002

drivers/gpu/drm/bridge/synopsys/dw-hdmi.c+30−4

 }
 EXPORT_SYMBOL_GPL(dw_hdmi_phy_i2c_write);
+/* Filter out invalid setups to avoid configuring SCDC and scrambling */
+static bool dw_hdmi_support_scdc(struct dw_hdmi *hdmi)
+{
+	struct drm_display_info *display = &hdmi->connector.display_info;
+	/* Completely disable SCDC support for older controllers */
+	if (hdmi->version < 0x200a)
+		return false;
+	/* Disable if SCDC is not supported, or if an HF-VSDB block is absent */
+	if (!display->hdmi.scdc.supported ||
+	    !display->hdmi.scdc.scrambling.supported)
+		return false;
+	/*
+	 * Disable if display only support low TMDS rates and scrambling
+	 * for low rates is not supported either
+	 */
+	if (!display->hdmi.scdc.scrambling.low_rates &&
+	    display->max_tmds_clock <= 340000)
+		return false;
+	return true;
+}
 /*
  * HDMI2.0 Specifies the following procedure for High TMDS Bit Rates:
  * - The Source shall suspend transmission of the TMDS clock and data
 	unsigned long mtmdsclock = hdmi->hdmi_data.video_mode.mtmdsclock;
 	/* Control for TMDS Bit Period/TMDS Clock-Period Ratio */
-	if (hdmi->connector.display_info.hdmi.scdc.supported) {
+	if (dw_hdmi_support_scdc(hdmi)) {
 		if (mtmdsclock > HDMI14_MAX_TMDSCLK)
 			drm_scdc_set_high_tmds_clock_ratio(hdmi->ddc, 1);
 		else
 	/* Set up HDMI_FC_INVIDCONF */
 	inv_val = (hdmi->hdmi_data.hdcp_enable ||
-		   vmode->mtmdsclock > HDMI14_MAX_TMDSCLK ||
+		   (dw_hdmi_support_scdc(hdmi) &&
-		   hdmi_info->scdc.scrambling.low_rates ?
+		    (vmode->mtmdsclock > HDMI14_MAX_TMDSCLK ||
+		     hdmi_info->scdc.scrambling.low_rates)) ?
 		HDMI_FC_INVIDCONF_HDCP_KEEPOUT_ACTIVE :
 		HDMI_FC_INVIDCONF_HDCP_KEEPOUT_INACTIVE);
 	}
 	/* Scrambling Control */
-	if (hdmi_info->scdc.supported) {
+	if (dw_hdmi_support_scdc(hdmi)) {
 		if (vmode->mtmdsclock > HDMI14_MAX_TMDSCLK ||
 		    hdmi_info->scdc.scrambling.low_rates) {
 			/*

drivers/gpu/drm/drm_atomic_helper.c+2−3

@@ -1034,7 +1034,7 @@ disable_outputs(struct drm_device dev, struct drm_atomic_state old_state) · 1033 unmodified lines
1034	funcs->atomic_disable(crtc, old_crtc_state);	1034	funcs->atomic_disable(crtc, old_crtc_state);
1035	else if (funcs->disable)	1035	else if (funcs->disable)
1036	funcs->disable(crtc);	1036	funcs->disable(crtc);
1037	else	1037	else if (funcs->dpms)
1038	funcs->dpms(crtc, DRM_MODE_DPMS_OFF);	1038	funcs->dpms(crtc, DRM_MODE_DPMS_OFF);
1039		1039
1040	if (!(dev->irq_enabled && dev->num_crtcs))	1040	if (!(dev->irq_enabled && dev->num_crtcs))
@@ -1277,10 +1277,9 @@ void drm_atomic_helper_commit_modeset_enables(struct drm_device *dev, · 236 unmodified lines
1277	if (new_crtc_state->enable) {	1277	if (new_crtc_state->enable) {
1278	DRM_DEBUG_ATOMIC("enabling [CRTC:%d:%s]\n",	1278	DRM_DEBUG_ATOMIC("enabling [CRTC:%d:%s]\n",
1279	crtc->base.id, crtc->name);	1279	crtc->base.id, crtc->name);
1280
1281	if (funcs->atomic_enable)	1280	if (funcs->atomic_enable)
1282	funcs->atomic_enable(crtc, old_crtc_state);	1281	funcs->atomic_enable(crtc, old_crtc_state);
1283	else	1282	else if (funcs->commit)
1284	funcs->commit(crtc);	1283	funcs->commit(crtc);
1285	}	1284	}
1286	}	1285	}

drivers/gpu/drm/i915/gvt/display.c+1−1

@@ -448,7 +448,7 @@ void intel_gvt_emulate_vblank(struct intel_gvt *gvt) · 447 unmodified lines
448	/**	448	/**
449	* intel_vgpu_emulate_hotplug - trigger hotplug event for vGPU	449	* intel_vgpu_emulate_hotplug - trigger hotplug event for vGPU
450	* @vgpu: a vGPU	450	* @vgpu: a vGPU
451	* @conncted: link state	451	* @connected: link state
452	*	452	*
453	* This function is used to trigger hotplug interrupt for vGPU	453	* This function is used to trigger hotplug interrupt for vGPU
454	*	454	*

drivers/gpu/drm/i915/gvt/dmabuf.c+6−7

 	struct drm_i915_private *dev_priv = to_i915(dev);
 	struct intel_vgpu_primary_plane_format p;
 	struct intel_vgpu_cursor_plane_format c;
-	int ret;
+	int ret, tile_height = 1;
 	if (plane_id == DRM_PLANE_TYPE_PRIMARY) {
 		ret = intel_vgpu_decode_primary_plane(vgpu, &p);
 			break;
 		case PLANE_CTL_TILED_X:
 			info->drm_format_mod = I915_FORMAT_MOD_X_TILED;
+			tile_height = 8;
 			break;
 		case PLANE_CTL_TILED_Y:
 			info->drm_format_mod = I915_FORMAT_MOD_Y_TILED;
+			tile_height = 32;
 			break;
 		case PLANE_CTL_TILED_YF:
 			info->drm_format_mod = I915_FORMAT_MOD_Yf_TILED;
+			tile_height = 32;
 			break;
 		default:
 			gvt_vgpu_err("invalid tiling mode: %x\n", p.tiled);
 		}
-		info->size = (((p.stride * p.height * p.bpp) / 8) +
-			      (PAGE_SIZE - 1)) >> PAGE_SHIFT;
 	} else if (plane_id == DRM_PLANE_TYPE_CURSOR) {
 		ret = intel_vgpu_decode_cursor_plane(vgpu, &c);
 		if (ret)
 			info->x_hot = UINT_MAX;
 			info->y_hot = UINT_MAX;
 		}
-		info->size = (((info->stride * c.height * c.bpp) / 8)
-				+ (PAGE_SIZE - 1)) >> PAGE_SHIFT;
 	} else {
 		gvt_vgpu_err("invalid plane id:%d\n", plane_id);
 		return -EINVAL;
 	}
+	info->size = (info->stride * roundup(info->height, tile_height)
+		      + PAGE_SIZE - 1) >> PAGE_SHIFT;
 	if (info->size == 0) {
 		gvt_vgpu_err("fb size is zero\n");
 		return -EINVAL;

drivers/gpu/drm/i915/gvt/gtt.c+10−4

 static void ppgtt_free_all_spt(struct intel_vgpu *vgpu)
 {
-	struct intel_vgpu_ppgtt_spt *spt;
+	struct intel_vgpu_ppgtt_spt *spt, *spn;
 	struct radix_tree_iter iter;
-	void **slot;
+	LIST_HEAD(all_spt);
+	void __rcu **slot;
+	rcu_read_lock();
 	radix_tree_for_each_slot(slot, &vgpu->gtt.spt_tree, &iter, 0) {
 		spt = radix_tree_deref_slot(slot);
-		ppgtt_free_spt(spt);
+		list_move(&spt->post_shadow_list, &all_spt);
 	}
+	rcu_read_unlock();
+	list_for_each_entry_safe(spt, spn, &all_spt, post_shadow_list)
+		ppgtt_free_spt(spt);
 }
 static int ppgtt_handle_guest_write_page_table_bytes(
  */
 void intel_vgpu_unpin_mm(struct intel_vgpu_mm *mm)
 {
-	atomic_dec(&mm->pincount);
+	atomic_dec_if_positive(&mm->pincount);
 }
 /**

drivers/gpu/drm/i915/gvt/kvmgt.c+3−3

@@ -905,7 +905,7 @@ static inline bool intel_vgpu_in_aperture(struct intel_vgpu *vgpu, u64 off) · 904 unmodified lines
905	static int intel_vgpu_aperture_rw(struct intel_vgpu *vgpu, u64 off,	905	static int intel_vgpu_aperture_rw(struct intel_vgpu *vgpu, u64 off,
906	void *buf, unsigned long count, bool is_write)	906	void *buf, unsigned long count, bool is_write)
907	{	907	{
908	void *aperture_va;	908	void __iomem *aperture_va;
909		909
910	if (!intel_vgpu_in_aperture(vgpu, off) \|\|	910	if (!intel_vgpu_in_aperture(vgpu, off) \|\|
911	!intel_vgpu_in_aperture(vgpu, off + count)) {	911	!intel_vgpu_in_aperture(vgpu, off + count)) {
@@ -920,9 +920,9 @@ static int intel_vgpu_aperture_rw(struct intel_vgpu *vgpu, u64 off, · 8 unmodified lines
920	return -EIO;	920	return -EIO;
921		921
922	if (is_write)	922	if (is_write)
923	memcpy(aperture_va + offset_in_page(off), buf, count);	923	memcpy_toio(aperture_va + offset_in_page(off), buf, count);
924	else	924	else
925	memcpy(buf, aperture_va + offset_in_page(off), count);	925	memcpy_fromio(buf, aperture_va + offset_in_page(off), count);
926		926
927	io_mapping_unmap(aperture_va);	927	io_mapping_unmap(aperture_va);
928		928

drivers/gpu/drm/i915/gvt/scheduler.c+3−2

 		intel_runtime_pm_put_unchecked(dev_priv);
 	}
-	if (ret && (vgpu_is_vm_unhealthy(ret))) {
+	if (ret) {
-		enter_failsafe_mode(vgpu, GVT_FAILSAFE_GUEST_ERR);
+		if (vgpu_is_vm_unhealthy(ret))
+			enter_failsafe_mode(vgpu, GVT_FAILSAFE_GUEST_ERR);
 		intel_vgpu_destroy_workload(workload);
 		return ERR_PTR(ret);
 	}

drivers/gpu/drm/i915/i915_debugfs.c+4−1

 		ret = drm_modeset_lock(&dev->mode_config.connection_mutex,
 				       &ctx);
 		if (ret) {
-			ret = -EINTR;
+			if (ret == -EDEADLK && !drm_modeset_backoff(&ctx)) {
+				try_again = true;
+				continue;
+			}
 			break;
 		}
 		crtc = connector->state->crtc;

drivers/gpu/drm/i915/icl_dsi.c+27−21

 	}
 }
+static void get_dsi_io_power_domains(struct drm_i915_private *dev_priv,
+				     struct intel_dsi *intel_dsi)
+{
+	enum port port;
+	for_each_dsi_port(port, intel_dsi->ports) {
+		WARN_ON(intel_dsi->io_wakeref[port]);
+		intel_dsi->io_wakeref[port] =
+			intel_display_power_get(dev_priv,
+						port == PORT_A ?
+						POWER_DOMAIN_PORT_DDI_A_IO :
+						POWER_DOMAIN_PORT_DDI_B_IO);
+	}
+}
 static void gen11_dsi_enable_io_power(struct intel_encoder *encoder)
 {
 	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
 		I915_WRITE(ICL_DSI_IO_MODECTL(port), tmp);
 	}
-	for_each_dsi_port(port, intel_dsi->ports) {
+	get_dsi_io_power_domains(dev_priv, intel_dsi);
-		intel_dsi->io_wakeref[port] =
-			intel_display_power_get(dev_priv,
-						port == PORT_A ?
-						POWER_DOMAIN_PORT_DDI_A_IO :
-						POWER_DOMAIN_PORT_DDI_B_IO);
-	}
 }
 static void gen11_dsi_power_up_lanes(struct intel_encoder *encoder)
 		val |= DPCLKA_CFGCR0_DDI_CLK_SEL(pll->info->id, port);
 	}
 	I915_WRITE(DPCLKA_CFGCR0_ICL, val);
+	for_each_dsi_port(port, intel_dsi->ports) {
+		val &= ~DPCLKA_CFGCR0_DDI_CLK_OFF(port);
+	}
+	I915_WRITE(DPCLKA_CFGCR0_ICL, val);
 	POSTING_READ(DPCLKA_CFGCR0_ICL);
 	mutex_unlock(&dev_priv->dpll_lock);
 			DRM_ERROR("DDI port:%c buffer not idle\n",
 				  port_name(port));
 	}
-	gen11_dsi_ungate_clocks(encoder);
+	gen11_dsi_gate_clocks(encoder);
 }
 static void gen11_dsi_disable_io_power(struct intel_encoder *encoder)
 	return 0;
 }
-static u64 gen11_dsi_get_power_domains(struct intel_encoder *encoder,
+static void gen11_dsi_get_power_domains(struct intel_encoder *encoder,
-				       struct intel_crtc_state *crtc_state)
+					struct intel_crtc_state *crtc_state)
 {
-	struct intel_dsi *intel_dsi = enc_to_intel_dsi(&encoder->base);
+	get_dsi_io_power_domains(to_i915(encoder->base.dev),
-	u64 domains = 0;
+				 enc_to_intel_dsi(&encoder->base));
-	enum port port;
-	for_each_dsi_port(port, intel_dsi->ports)
-		if (port == PORT_A)
-			domains |= BIT_ULL(POWER_DOMAIN_PORT_DDI_A_IO);
-		else
-			domains |= BIT_ULL(POWER_DOMAIN_PORT_DDI_B_IO);
-	return domains;
 }
 static bool gen11_dsi_get_hw_state(struct intel_encoder *encoder,

drivers/gpu/drm/i915/intel_ddi.c+11−12

@@ -2075,12 +2075,11 @@ intel_ddi_main_link_aux_domain(struct intel_digital_port *dig_port) · 2074 unmodified lines
2075	intel_aux_power_domain(dig_port);	2075	intel_aux_power_domain(dig_port);
2076	}	2076	}
2077		2077
2078	static u64 intel_ddi_get_power_domains(struct intel_encoder *encoder,	2078	static void intel_ddi_get_power_domains(struct intel_encoder *encoder,
2079	struct intel_crtc_state *crtc_state)	2079	struct intel_crtc_state *crtc_state)
2080	{	2080	{
2081	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);	2081	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2082	struct intel_digital_port *dig_port;	2082	struct intel_digital_port *dig_port;
2083	u64 domains;
2084		2083
2085	/*	2084	/*
2086	* TODO: Add support for MST encoders. Atm, the following should never	2085	* TODO: Add support for MST encoders. Atm, the following should never
@@ -2088,10 +2087,10 @@ static u64 intel_ddi_get_power_domains(struct intel_encoder *encoder, · 1 unmodified line
2088	* hook.	2087	* hook.
2089	*/	2088	*/
2090	if (WARN_ON(intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST)))	2089	if (WARN_ON(intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST)))
2091	return 0;	2090	return;
2092		2091
2093	dig_port = enc_to_dig_port(&encoder->base);	2092	dig_port = enc_to_dig_port(&encoder->base);
2094	domains = BIT_ULL(dig_port->ddi_io_power_domain);	2093	intel_display_power_get(dev_priv, dig_port->ddi_io_power_domain);
2095		2094
2096	/*	2095	/*
2097	* AUX power is only needed for (e)DP mode, and for HDMI mode on TC	2096	* AUX power is only needed for (e)DP mode, and for HDMI mode on TC
@@ -2099,15 +2098,15 @@ static u64 intel_ddi_get_power_domains(struct intel_encoder *encoder, · 1 unmodified line
2099	*/	2098	*/
2100	if (intel_crtc_has_dp_encoder(crtc_state) \|\|	2099	if (intel_crtc_has_dp_encoder(crtc_state) \|\|
2101	intel_port_is_tc(dev_priv, encoder->port))	2100	intel_port_is_tc(dev_priv, encoder->port))
2102	domains \|= BIT_ULL(intel_ddi_main_link_aux_domain(dig_port));	2101	intel_display_power_get(dev_priv,
		2102	intel_ddi_main_link_aux_domain(dig_port));
2103		2103
2104	/*	2104	/*
2105	* VDSC power is needed when DSC is enabled	2105	* VDSC power is needed when DSC is enabled
2106	*/	2106	*/
2107	if (crtc_state->dsc_params.compression_enable)	2107	if (crtc_state->dsc_params.compression_enable)
2108	domains \|= BIT_ULL(intel_dsc_power_domain(crtc_state));	2108	intel_display_power_get(dev_priv,
2109		2109	intel_dsc_power_domain(crtc_state));
2110	return domains;
2111	}	2110	}
2112		2111
2113	void intel_ddi_enable_pipe_clock(const struct intel_crtc_state *crtc_state)	2112	void intel_ddi_enable_pipe_clock(const struct intel_crtc_state *crtc_state)
@@ -2825,10 +2824,10 @@ void icl_sanitize_encoder_pll_mapping(struct intel_encoder *encoder) · 711 unmodified lines
2825	return;	2824	return;
2826	}	2825	}
2827	/*	2826	/*
2828	* DSI ports should have their DDI clock ungated when disabled	2827	* For DSI we keep the ddi clocks gated
2829	* and gated when enabled.	2828	* except during enable/disable sequence.
2830	*/	2829	*/
2831	ddi_clk_needed = !encoder->base.crtc;	2830	ddi_clk_needed = false;
2832	}	2831	}
2833		2832
2834	val = I915_READ(DPCLKA_CFGCR0_ICL);	2833	val = I915_READ(DPCLKA_CFGCR0_ICL);

drivers/gpu/drm/i915/intel_display.c+1−5

 	struct intel_encoder *encoder;
 	for_each_intel_encoder(&dev_priv->drm, encoder) {
-		u64 get_domains;
-		enum intel_display_power_domain domain;
 		struct intel_crtc_state *crtc_state;
 		if (!encoder->get_power_domains)
 			continue;
 		crtc_state = to_intel_crtc_state(encoder->base.crtc->state);
-		get_domains = encoder->get_power_domains(encoder, crtc_state);
+		encoder->get_power_domains(encoder, crtc_state);
-		for_each_power_domain(domain, get_domains)
-			intel_display_power_get(dev_priv, domain);
 	}
 }

drivers/gpu/drm/i915/intel_dp.c+10−59

@@ -1859,42 +1859,6 @@ intel_dp_compute_link_config_wide(struct intel_dp *intel_dp, · 1858 unmodified lines
1859	return -EINVAL;	1859	return -EINVAL;
1860	}	1860	}
1861		1861
1862	/* Optimize link config in order: max bpp, min lanes, min clock */
1863	static int
1864	intel_dp_compute_link_config_fast(struct intel_dp *intel_dp,
1865	struct intel_crtc_state *pipe_config,
1866	const struct link_config_limits *limits)
1867	{
1868	struct drm_display_mode *adjusted_mode = &pipe_config->base.adjusted_mode;
1869	int bpp, clock, lane_count;
1870	int mode_rate, link_clock, link_avail;
1871
1872	for (bpp = limits->max_bpp; bpp >= limits->min_bpp; bpp -= 2 * 3) {
1873	mode_rate = intel_dp_link_required(adjusted_mode->crtc_clock,
1874	bpp);
1875
1876	for (lane_count = limits->min_lane_count;
1877	lane_count <= limits->max_lane_count;
1878	lane_count <<= 1) {
1879	for (clock = limits->min_clock; clock <= limits->max_clock; clock++) {
1880	link_clock = intel_dp->common_rates[clock];
1881	link_avail = intel_dp_max_data_rate(link_clock,
1882	lane_count);
1883
1884	if (mode_rate <= link_avail) {
1885	pipe_config->lane_count = lane_count;
1886	pipe_config->pipe_bpp = bpp;
1887	pipe_config->port_clock = link_clock;
1888
1889	return 0;
1890	}
1891	}
1892	}
1893	}
1894
1895	return -EINVAL;
1896	}
1897
1898	static int intel_dp_dsc_compute_bpp(struct intel_dp *intel_dp, u8 dsc_max_bpc)	1862	static int intel_dp_dsc_compute_bpp(struct intel_dp *intel_dp, u8 dsc_max_bpc)
1899	{	1863	{
1900	int i, num_bpc;	1864	int i, num_bpc;
@@ -2031,15 +1995,13 @@ intel_dp_compute_link_config(struct intel_encoder *encoder, · 130 unmodified lines
2031	limits.min_bpp = 6 * 3;	1995	limits.min_bpp = 6 * 3;
2032	limits.max_bpp = intel_dp_compute_bpp(intel_dp, pipe_config);	1996	limits.max_bpp = intel_dp_compute_bpp(intel_dp, pipe_config);
2033		1997
2034	if (intel_dp_is_edp(intel_dp) && intel_dp->edp_dpcd[0] < DP_EDP_14) {	1998	if (intel_dp_is_edp(intel_dp)) {
2035	/*	1999	/*
2036	* Use the maximum clock and number of lanes the eDP panel	2000	* Use the maximum clock and number of lanes the eDP panel
2037	* advertizes being capable of. The eDP 1.3 and earlier panels	2001	* advertizes being capable of. The panels are generally
2038	* are generally designed to support only a single clock and	2002	* designed to support only a single clock and lane
2039	* lane configuration, and typically these values correspond to	2003	* configuration, and typically these values correspond to the
2040	* the native resolution of the panel. With eDP 1.4 rate select	2004	* native resolution of the panel.
2041	* and DSC, this is decreasingly the case, and we need to be
2042	* able to select less than maximum link config.
2043	*/	2005	*/
2044	limits.min_lane_count = limits.max_lane_count;	2006	limits.min_lane_count = limits.max_lane_count;
2045	limits.min_clock = limits.max_clock;	2007	limits.min_clock = limits.max_clock;
@@ -2053,22 +2015,11 @@ intel_dp_compute_link_config(struct intel_encoder *encoder, · 7 unmodified lines
2053	intel_dp->common_rates[limits.max_clock],	2015	intel_dp->common_rates[limits.max_clock],
2054	limits.max_bpp, adjusted_mode->crtc_clock);	2016	limits.max_bpp, adjusted_mode->crtc_clock);
2055		2017
2056	if (intel_dp_is_edp(intel_dp))	2018	/*
2057	/*	2019	* Optimize for slow and wide. This is the place to add alternative
2058	* Optimize for fast and narrow. eDP 1.3 section 3.3 and eDP 1.4	2020	* optimization policy.
2059	* section A.1: "It is recommended that the minimum number of	2021	*/
2060	* lanes be used, using the minimum link rate allowed for that	2022	ret = intel_dp_compute_link_config_wide(intel_dp, pipe_config, &limits);
2061	* lane configuration."
2062	*
2063	* Note that we use the max clock and lane count for eDP 1.3 and
2064	* earlier, and fast vs. wide is irrelevant.
2065	*/
2066	ret = intel_dp_compute_link_config_fast(intel_dp, pipe_config,
2067	&limits);
2068	else
2069	/* Optimize for slow and wide. */
2070	ret = intel_dp_compute_link_config_wide(intel_dp, pipe_config,
2071	&limits);
2072		2023
2073	/* enable compression if the mode doesn't fit available BW */	2024	/* enable compression if the mode doesn't fit available BW */
2074	DRM_DEBUG_KMS("Force DSC en = %d\n", intel_dp->force_dsc_en);	2025	DRM_DEBUG_KMS("Force DSC en = %d\n", intel_dp->force_dsc_en);

drivers/gpu/drm/i915/intel_drv.h+6−4

 	 * be set correctly before calling this function. */
 	void (*get_config)(struct intel_encoder *,
 			   struct intel_crtc_state *pipe_config);
-	/* Returns a mask of power domains that need to be referenced as part
+	/*
-	 * of the hardware state readout code. */
+	 * Acquires the power domains needed for an active encoder during
-	u64 (*get_power_domains)(struct intel_encoder *encoder,
+	 * hardware state readout.
-				 struct intel_crtc_state *crtc_state);
+	 */
+	void (*get_power_domains)(struct intel_encoder *encoder,
+				  struct intel_crtc_state *crtc_state);
 	/*
 	 * Called during system suspend after all pending requests for the
 	 * encoder are flushed (for example for DP AUX transactions) and

drivers/gpu/drm/i915/vlv_dsi.c+24−0

@@ -256,6 +256,28 @@ static void band_gap_reset(struct drm_i915_private *dev_priv) · 255 unmodified lines
256	mutex_unlock(&dev_priv->sb_lock);	256	mutex_unlock(&dev_priv->sb_lock);
257	}	257	}
258		258
		259	static int bdw_get_pipemisc_bpp(struct intel_crtc *crtc)
		260	{
		261	struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
		262	u32 tmp;
		263
		264	tmp = I915_READ(PIPEMISC(crtc->pipe));
		265
		266	switch (tmp & PIPEMISC_DITHER_BPC_MASK) {
		267	case PIPEMISC_DITHER_6_BPC:
		268	return 18;
		269	case PIPEMISC_DITHER_8_BPC:
		270	return 24;
		271	case PIPEMISC_DITHER_10_BPC:
		272	return 30;
		273	case PIPEMISC_DITHER_12_BPC:
		274	return 36;
		275	default:
		276	MISSING_CASE(tmp);
		277	return 0;
		278	}
		279	}
		280
259	static int intel_dsi_compute_config(struct intel_encoder *encoder,	281	static int intel_dsi_compute_config(struct intel_encoder *encoder,
260	struct intel_crtc_state *pipe_config,	282	struct intel_crtc_state *pipe_config,
261	struct drm_connector_state *conn_state)	283	struct drm_connector_state *conn_state)
@@ -1071,6 +1093,8 @@ static void bxt_dsi_get_pipe_config(struct intel_encoder *encoder, · 809 unmodified lines
1071	bpp = mipi_dsi_pixel_format_to_bpp(	1093	bpp = mipi_dsi_pixel_format_to_bpp(
1072	pixel_format_from_register_bits(fmt));	1094	pixel_format_from_register_bits(fmt));
1073		1095
		1096	pipe_config->pipe_bpp = bdw_get_pipemisc_bpp(crtc);
		1097
1074	/* Enable Frame time stamo based scanline reporting */	1098	/* Enable Frame time stamo based scanline reporting */
1075	adjusted_mode->private_flags \|=	1099	adjusted_mode->private_flags \|=
1076	I915_MODE_FLAG_GET_SCANLINE_FROM_TIMESTAMP;	1100	I915_MODE_FLAG_GET_SCANLINE_FROM_TIMESTAMP;

drivers/gpu/drm/mediatek/mtk_dpi.c+3−5

 static unsigned int mt2701_calculate_factor(int clock)
 {
 	if (clock <= 64000)
-		return 16;
-	else if (clock <= 128000)
-		return 8;
-	else if (clock <= 256000)
 		return 4;
-	else
+	else if (clock <= 128000)
 		return 2;
+	else
+		return 1;
 }
 static const struct mtk_dpi_conf mt8173_conf = {

drivers/gpu/drm/mediatek/mtk_drm_drv.c+7−0

 #include <drm/drmP.h>
 #include <drm/drm_atomic.h>
 #include <drm/drm_atomic_helper.h>
+#include <drm/drm_fb_helper.h>
 #include <drm/drm_gem.h>
 #include <drm/drm_gem_cma_helper.h>
 #include <drm/drm_of.h>
 	.gem_prime_get_sg_table = mtk_gem_prime_get_sg_table,
 	.gem_prime_import_sg_table = mtk_gem_prime_import_sg_table,
 	.gem_prime_mmap = mtk_drm_gem_mmap_buf,
+	.gem_prime_vmap = mtk_drm_gem_prime_vmap,
+	.gem_prime_vunmap = mtk_drm_gem_prime_vunmap,
 	.fops = &mtk_drm_fops,
 	.name = DRIVER_NAME,
 	if (ret < 0)
 		goto err_deinit;
+	ret = drm_fbdev_generic_setup(drm, 32);
+	if (ret)
+		DRM_ERROR("Failed to initialize fbdev: %d\n", ret);
 	return 0;
 err_deinit:

drivers/gpu/drm/mediatek/mtk_drm_gem.c+46−0

@@ -241,3 +241,49 @@ err_gem_free: · 240 unmodified lines
241	kfree(mtk_gem);	241	kfree(mtk_gem);
242	return ERR_PTR(ret);	242	return ERR_PTR(ret);
243	}	243	}
		244
		245	void mtk_drm_gem_prime_vmap(struct drm_gem_object obj)
		246	{
		247	struct mtk_drm_gem_obj *mtk_gem = to_mtk_gem_obj(obj);
		248	struct sg_table *sgt;
		249	struct sg_page_iter iter;
		250	unsigned int npages;
		251	unsigned int i = 0;
		252
		253	if (mtk_gem->kvaddr)
		254	return mtk_gem->kvaddr;
		255
		256	sgt = mtk_gem_prime_get_sg_table(obj);
		257	if (IS_ERR(sgt))
		258	return NULL;
		259
		260	npages = obj->size >> PAGE_SHIFT;
		261	mtk_gem->pages = kcalloc(npages, sizeof(*mtk_gem->pages), GFP_KERNEL);
		262	if (!mtk_gem->pages)
		263	goto out;
		264
		265	for_each_sg_page(sgt->sgl, &iter, sgt->orig_nents, 0) {
		266	mtk_gem->pages[i++] = sg_page_iter_page(&iter);
		267	if (i > npages)
		268	break;
		269	}
		270	mtk_gem->kvaddr = vmap(mtk_gem->pages, npages, VM_MAP,
		271	pgprot_writecombine(PAGE_KERNEL));
		272
		273	out:
		274	kfree((void *)sgt);
		275
		276	return mtk_gem->kvaddr;
		277	}
		278
		279	void mtk_drm_gem_prime_vunmap(struct drm_gem_object obj, void vaddr)
		280	{
		281	struct mtk_drm_gem_obj *mtk_gem = to_mtk_gem_obj(obj);
		282
		283	if (!mtk_gem->pages)
		284	return;
		285
		286	vunmap(vaddr);
		287	mtk_gem->kvaddr = 0;
		288	kfree((void *)mtk_gem->pages);
		289	}

drivers/gpu/drm/mediatek/mtk_drm_gem.h+3−0

 	dma_addr_t		dma_addr;
 	unsigned long		dma_attrs;
 	struct sg_table		*sg;
+	struct page		**pages;
 };
 #define to_mtk_gem_obj(x)	container_of(x, struct mtk_drm_gem_obj, base)
 struct sg_table *mtk_gem_prime_get_sg_table(struct drm_gem_object *obj);
 struct drm_gem_object *mtk_gem_prime_import_sg_table(struct drm_device *dev,
 			struct dma_buf_attachment *attach, struct sg_table *sg);
+void *mtk_drm_gem_prime_vmap(struct drm_gem_object *obj);
+void mtk_drm_gem_prime_vunmap(struct drm_gem_object *obj, void *vaddr);
 #endif

drivers/gpu/drm/mediatek/mtk_hdmi.c+1−1

 	if (IS_ERR(regmap))
 		ret = PTR_ERR(regmap);
 	if (ret) {
-		ret = PTR_ERR(regmap);
 		dev_err(dev,
 			"Failed to get system configuration registers: %d\n",
 			ret);
 	of_node_put(remote);
 	hdmi->ddc_adpt = of_find_i2c_adapter_by_node(i2c_np);
+	of_node_put(i2c_np);
 	if (!hdmi->ddc_adpt) {
 		dev_err(dev, "Failed to get ddc i2c adapter by node\n");
 		return -EINVAL;

drivers/gpu/drm/mediatek/mtk_hdmi_phy.c+5−30

 	.owner = THIS_MODULE,
 };
-long mtk_hdmi_pll_round_rate(struct clk_hw *hw, unsigned long rate,
-			     unsigned long *parent_rate)
-{
-	struct mtk_hdmi_phy *hdmi_phy = to_mtk_hdmi_phy(hw);
-	hdmi_phy->pll_rate = rate;
-	if (rate <= 74250000)
-		*parent_rate = rate;
-	else
-		*parent_rate = rate / 2;
-	return rate;
-}
-unsigned long mtk_hdmi_pll_recalc_rate(struct clk_hw *hw,
-				       unsigned long parent_rate)
-{
-	struct mtk_hdmi_phy *hdmi_phy = to_mtk_hdmi_phy(hw);
-	return hdmi_phy->pll_rate;
-}
 void mtk_hdmi_phy_clear_bits(struct mtk_hdmi_phy *hdmi_phy, u32 offset,
 			     u32 bits)
 {
 		return NULL;
 }
-static void mtk_hdmi_phy_clk_get_ops(struct mtk_hdmi_phy *hdmi_phy,
+static void mtk_hdmi_phy_clk_get_data(struct mtk_hdmi_phy *hdmi_phy,
-				     const struct clk_ops **ops)
+				      struct clk_init_data *clk_init)
 {
-	if (hdmi_phy && hdmi_phy->conf && hdmi_phy->conf->hdmi_phy_clk_ops)
+	clk_init->flags = hdmi_phy->conf->flags;
-		*ops = hdmi_phy->conf->hdmi_phy_clk_ops;
+	clk_init->ops = hdmi_phy->conf->hdmi_phy_clk_ops;
-	else
-		dev_err(hdmi_phy->dev, "Failed to get clk ops of phy\n");
 }
 static int mtk_hdmi_phy_probe(struct platform_device *pdev)
 	struct clk_init_data clk_init = {
 		.num_parents = 1,
 		.parent_names = (const char * const *)&ref_clk_name,
-		.flags = CLK_SET_RATE_PARENT | CLK_SET_RATE_GATE,
 	};
 	struct phy *phy;
 	hdmi_phy->dev = dev;
 	hdmi_phy->conf =
 		(struct mtk_hdmi_phy_conf *)of_device_get_match_data(dev);
-	mtk_hdmi_phy_clk_get_ops(hdmi_phy, &clk_init.ops);
+	mtk_hdmi_phy_clk_get_data(hdmi_phy, &clk_init);
 	hdmi_phy->pll_hw.init = &clk_init;
 	hdmi_phy->pll = devm_clk_register(dev, &hdmi_phy->pll_hw);
 	if (IS_ERR(hdmi_phy->pll)) {

drivers/gpu/drm/mediatek/mtk_hdmi_phy.h+1−4

 struct mtk_hdmi_phy_conf {
 	bool tz_disabled;
+	unsigned long flags;
 	const struct clk_ops *hdmi_phy_clk_ops;
 	void (*hdmi_phy_enable_tmds)(struct mtk_hdmi_phy *hdmi_phy);
 	void (*hdmi_phy_disable_tmds)(struct mtk_hdmi_phy *hdmi_phy);
 void mtk_hdmi_phy_mask(struct mtk_hdmi_phy *hdmi_phy, u32 offset,
 		       u32 val, u32 mask);
 struct mtk_hdmi_phy *to_mtk_hdmi_phy(struct clk_hw *hw);
-long mtk_hdmi_pll_round_rate(struct clk_hw *hw, unsigned long rate,
-			     unsigned long *parent_rate);
-unsigned long mtk_hdmi_pll_recalc_rate(struct clk_hw *hw,
-				       unsigned long parent_rate);
 extern struct platform_driver mtk_hdmi_phy_driver;
 extern struct mtk_hdmi_phy_conf mtk_hdmi_phy_8173_conf;

drivers/gpu/drm/mediatek/mtk_mt2701_hdmi_phy.c+43−6

 	mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_SLDO_MASK);
 	usleep_range(80, 100);
 	mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON2, RG_HDMITX_MBIAS_LPF_EN);
-	mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON2, RG_HDMITX_EN_TX_POSDIV);
 	mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_SER_MASK);
 	mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_PRED_MASK);
 	mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_DRV_MASK);
 	mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_DRV_MASK);
 	mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_PRED_MASK);
 	mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_SER_MASK);
-	mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON2, RG_HDMITX_EN_TX_POSDIV);
 	mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON2, RG_HDMITX_MBIAS_LPF_EN);
 	usleep_range(80, 100);
 	mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_SLDO_MASK);
 	usleep_range(80, 100);
 }
+static long mtk_hdmi_pll_round_rate(struct clk_hw *hw, unsigned long rate,
+				    unsigned long *parent_rate)
+{
+	return rate;
+}
 static int mtk_hdmi_pll_set_rate(struct clk_hw *hw, unsigned long rate,
 				 unsigned long parent_rate)
 {
 	if (rate <= 64000000)
 		pos_div = 3;
-	else if (rate <= 12800000)
+	else if (rate <= 128000000)
-		pos_div = 1;
+		pos_div = 2;
 	else
 		pos_div = 1;
 	mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON6, RG_HTPLL_PREDIV_MASK);
 	mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON6, RG_HTPLL_POSDIV_MASK);
+	mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON2, RG_HDMITX_EN_TX_POSDIV);
 	mtk_hdmi_phy_mask(hdmi_phy, HDMI_CON6, (0x1 << RG_HTPLL_IC),
 			  RG_HTPLL_IC_MASK);
 	mtk_hdmi_phy_mask(hdmi_phy, HDMI_CON6, (0x1 << RG_HTPLL_IR),
 	return 0;
 }
+static unsigned long mtk_hdmi_pll_recalc_rate(struct clk_hw *hw,
+					      unsigned long parent_rate)
+{
+	struct mtk_hdmi_phy *hdmi_phy = to_mtk_hdmi_phy(hw);
+	unsigned long out_rate, val;
+	val = (readl(hdmi_phy->regs + HDMI_CON6)
+	       & RG_HTPLL_PREDIV_MASK) >> RG_HTPLL_PREDIV;
+	switch (val) {
+	case 0x00:
+		out_rate = parent_rate;
+		break;
+	case 0x01:
+		out_rate = parent_rate / 2;
+		break;
+	default:
+		out_rate = parent_rate / 4;
+		break;
+	}
+	val = (readl(hdmi_phy->regs + HDMI_CON6)
+	       & RG_HTPLL_FBKDIV_MASK) >> RG_HTPLL_FBKDIV;
+	out_rate *= (val + 1) * 2;
+	val = (readl(hdmi_phy->regs + HDMI_CON2)
+	       & RG_HDMITX_TX_POSDIV_MASK);
+	out_rate >>= (val >> RG_HDMITX_TX_POSDIV);
+	if (readl(hdmi_phy->regs + HDMI_CON2) & RG_HDMITX_EN_TX_POSDIV)
+		out_rate /= 5;
+	return out_rate;
+}
 static const struct clk_ops mtk_hdmi_phy_pll_ops = {
 	.prepare = mtk_hdmi_pll_prepare,
 	.unprepare = mtk_hdmi_pll_unprepare,
 	mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_SLDO_MASK);
 	usleep_range(80, 100);
 	mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON2, RG_HDMITX_MBIAS_LPF_EN);
-	mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON2, RG_HDMITX_EN_TX_POSDIV);
 	mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_SER_MASK);
 	mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_PRED_MASK);
 	mtk_hdmi_phy_set_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_DRV_MASK);
 	mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_DRV_MASK);
 	mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_PRED_MASK);
 	mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_SER_MASK);
-	mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON2, RG_HDMITX_EN_TX_POSDIV);
 	mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON2, RG_HDMITX_MBIAS_LPF_EN);
 	usleep_range(80, 100);
 	mtk_hdmi_phy_clear_bits(hdmi_phy, HDMI_CON0, RG_HDMITX_EN_SLDO_MASK);
 struct mtk_hdmi_phy_conf mtk_hdmi_phy_2701_conf = {
 	.tz_disabled = true,
+	.flags = CLK_SET_RATE_GATE,
 	.hdmi_phy_clk_ops = &mtk_hdmi_phy_pll_ops,
 	.hdmi_phy_enable_tmds = mtk_hdmi_phy_enable_tmds,
 	.hdmi_phy_disable_tmds = mtk_hdmi_phy_disable_tmds,

drivers/gpu/drm/mediatek/mtk_mt8173_hdmi_phy.c+23−0

@@ -199,6 +199,20 @@ static void mtk_hdmi_pll_unprepare(struct clk_hw *hw) · 198 unmodified lines
199	usleep_range(100, 150);	199	usleep_range(100, 150);
200	}	200	}
201		201
		202	static long mtk_hdmi_pll_round_rate(struct clk_hw *hw, unsigned long rate,
		203	unsigned long *parent_rate)
		204	{
		205	struct mtk_hdmi_phy *hdmi_phy = to_mtk_hdmi_phy(hw);
		206
		207	hdmi_phy->pll_rate = rate;
		208	if (rate <= 74250000)
		209	*parent_rate = rate;
		210	else
		211	*parent_rate = rate / 2;
		212
		213	return rate;
		214	}
		215
202	static int mtk_hdmi_pll_set_rate(struct clk_hw *hw, unsigned long rate,	216	static int mtk_hdmi_pll_set_rate(struct clk_hw *hw, unsigned long rate,
203	unsigned long parent_rate)	217	unsigned long parent_rate)
204	{	218	{
@@ -285,6 +299,14 @@ static int mtk_hdmi_pll_set_rate(struct clk_hw *hw, unsigned long rate, · 80 unmodified lines
285	return 0;	299	return 0;
286	}	300	}
287		301
		302	static unsigned long mtk_hdmi_pll_recalc_rate(struct clk_hw *hw,
		303	unsigned long parent_rate)
		304	{
		305	struct mtk_hdmi_phy *hdmi_phy = to_mtk_hdmi_phy(hw);
		306
		307	return hdmi_phy->pll_rate;
		308	}
		309
288	static const struct clk_ops mtk_hdmi_phy_pll_ops = {	310	static const struct clk_ops mtk_hdmi_phy_pll_ops = {
289	.prepare = mtk_hdmi_pll_prepare,	311	.prepare = mtk_hdmi_pll_prepare,
290	.unprepare = mtk_hdmi_pll_unprepare,	312	.unprepare = mtk_hdmi_pll_unprepare,
@@ -309,6 +331,7 @@ static void mtk_hdmi_phy_disable_tmds(struct mtk_hdmi_phy *hdmi_phy) · 18 unmodified lines
309	}	331	}
310		332
311	struct mtk_hdmi_phy_conf mtk_hdmi_phy_8173_conf = {	333	struct mtk_hdmi_phy_conf mtk_hdmi_phy_8173_conf = {
		334	.flags = CLK_SET_RATE_PARENT \| CLK_SET_RATE_GATE,
312	.hdmi_phy_clk_ops = &mtk_hdmi_phy_pll_ops,	335	.hdmi_phy_clk_ops = &mtk_hdmi_phy_pll_ops,
313	.hdmi_phy_enable_tmds = mtk_hdmi_phy_enable_tmds,	336	.hdmi_phy_enable_tmds = mtk_hdmi_phy_enable_tmds,
314	.hdmi_phy_disable_tmds = mtk_hdmi_phy_disable_tmds,	337	.hdmi_phy_disable_tmds = mtk_hdmi_phy_disable_tmds,

drivers/gpu/drm/omapdrm/dss/hdmi4_cec.c+19−7

 		REG_FLD_MOD(core->base, HDMI_CORE_SYS_INTR_UNMASK4, 0, 3, 3);
 		hdmi_wp_clear_irqenable(core->wp, HDMI_IRQ_CORE);
 		hdmi_wp_set_irqstatus(core->wp, HDMI_IRQ_CORE);
+		REG_FLD_MOD(core->wp->base, HDMI_WP_CLK, 0, 5, 0);
 		hdmi4_core_disable(core);
 		return 0;
 	}
 	if (err)
 		return err;
+	/*
+	 * Initialize CEC clock divider: CEC needs 2MHz clock hence
+	 * set the divider to 24 to get 48/24=2MHz clock
+	 */
+	REG_FLD_MOD(core->wp->base, HDMI_WP_CLK, 0x18, 5, 0);
 	/* Clear TX FIFO */
 	if (!hdmi_cec_clear_tx_fifo(adap)) {
 		pr_err("cec-%s: could not clear TX FIFO\n", adap->name);
-		return -EIO;
+		err = -EIO;
+		goto err_disable_clk;
 	}
 	/* Clear RX FIFO */
 	if (!hdmi_cec_clear_rx_fifo(adap)) {
 		pr_err("cec-%s: could not clear RX FIFO\n", adap->name);
-		return -EIO;
+		err = -EIO;
+		goto err_disable_clk;
 	}
 	/* Clear CEC interrupts */
 		hdmi_write_reg(core->base, HDMI_CEC_INT_STATUS_1, temp);
 	}
 	return 0;
+err_disable_clk:
+	REG_FLD_MOD(core->wp->base, HDMI_WP_CLK, 0, 5, 0);
+	hdmi4_core_disable(core);
+	return err;
 }
 static int hdmi_cec_adap_log_addr(struct cec_adapter *adap, u8 log_addr)
 		return ret;
 	core->wp = wp;
-	/*
+	/* Disable clock initially, hdmi_cec_adap_enable() manages it */
-	 * Initialize CEC clock divider: CEC needs 2MHz clock hence
+	REG_FLD_MOD(core->wp->base, HDMI_WP_CLK, 0, 5, 0);
-	 * set the devider to 24 to get 48/24=2MHz clock
-	 */
-	REG_FLD_MOD(core->wp->base, HDMI_WP_CLK, 0x18, 5, 0);
 	ret = cec_register_adapter(core->adap, &pdev->dev);
 	if (ret < 0) {

drivers/gpu/drm/omapdrm/dss/hdmi4_core.c+1−1

@@ -708,7 +708,7 @@ int hdmi4_audio_config(struct hdmi_core_data core, struct hdmi_wp_data wp, · 707 unmodified lines
708	else	708	else
709	acore.i2s_cfg.justification = HDMI_AUDIO_JUSTIFY_RIGHT;	709	acore.i2s_cfg.justification = HDMI_AUDIO_JUSTIFY_RIGHT;
710	/*	710	/*
711	* The I2S input word length is twice the lenght given in the IEC-60958	711	* The I2S input word length is twice the length given in the IEC-60958
712	* status word. If the word size is greater than	712	* status word. If the word size is greater than
713	* 20 bits, increment by one.	713	* 20 bits, increment by one.
714	*/	714	*/

drivers/gpu/drm/sun4i/sun8i_dw_hdmi.c+7−2

 sun8i_dw_hdmi_mode_valid_h6(struct drm_connector *connector,
 			    const struct drm_display_mode *mode)
 {
-	/* This is max for HDMI 2.0b (4K@60Hz) */
+	/*
-	if (mode->clock > 594000)
+	 * Controller support maximum of 594 MHz, which correlates to
+	 * 4K@60Hz 4:4:4 or RGB. However, for frequencies greater than
+	 * 340 MHz scrambling has to be enabled. Because scrambling is
+	 * not yet implemented, just limit to 340 MHz for now.
+	 */
+	if (mode->clock > 340000)
 		return MODE_CLOCK_HIGH;
 	return MODE_OK;

drivers/gpu/drm/sun4i/sun8i_tcon_top.c+3−2

 err_unregister_gates:
 	for (i = 0; i < CLK_NUM; i++)
-		if (clk_data->hws[i])
+		if (!IS_ERR_OR_NULL(clk_data->hws[i]))
 			clk_hw_unregister_gate(clk_data->hws[i]);
 	clk_disable_unprepare(tcon_top->bus);
 err_assert_reset:
 	of_clk_del_provider(dev->of_node);
 	for (i = 0; i < CLK_NUM; i++)
-		clk_hw_unregister_gate(clk_data->hws[i]);
+		if (clk_data->hws[i])
+			clk_hw_unregister_gate(clk_data->hws[i]);
 	clk_disable_unprepare(tcon_top->bus);
 	reset_control_assert(tcon_top->rst);

drivers/gpu/drm/tegra/hdmi.c+9−3

 	hdmi->dvi = !tegra_output_is_hdmi(output);
 	if (!hdmi->dvi) {
-		err = tegra_hdmi_setup_audio(hdmi);
+		/*
-		if (err < 0)
+		 * Make sure that the audio format has been configured before
-			hdmi->dvi = true;
+		 * enabling audio, otherwise we may try to divide by zero.
+		*/
+		if (hdmi->format.sample_rate > 0) {
+			err = tegra_hdmi_setup_audio(hdmi);
+			if (err < 0)
+				hdmi->dvi = true;
+		}
 	}
 	if (hdmi->config->has_hda)

drivers/gpu/drm/ttm/ttm_bo.c+3−1

 		reservation_object_add_shared_fence(bo->resv, fence);
 		ret = reservation_object_reserve_shared(bo->resv, 1);
-		if (unlikely(ret))
+		if (unlikely(ret)) {
+			dma_fence_put(fence);
 			return ret;
+		}
 		dma_fence_put(bo->moving);
 		bo->moving = fence;

drivers/gpu/drm/ttm/ttm_page_alloc.c+7−6

 			}
 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
-			if (!(flags & TTM_PAGE_FLAG_DMA32)) {
+			if (!(flags & TTM_PAGE_FLAG_DMA32) &&
-				for (j = 0; j < HPAGE_PMD_NR; ++j)
+			    (npages - i) >= HPAGE_PMD_NR) {
-					if (p++ != pages[i + j])
+				for (j = 1; j < HPAGE_PMD_NR; ++j)
+					if (++p != pages[i + j])
 					    break;
 				if (j == HPAGE_PMD_NR)
 		unsigned max_size, n2free;
 		spin_lock_irqsave(&huge->lock, irq_flags);
-		while (i < npages) {
+		while ((npages - i) >= HPAGE_PMD_NR) {
 			struct page *p = pages[i];
 			unsigned j;
 			if (!p)
 				break;
-			for (j = 0; j < HPAGE_PMD_NR; ++j)
+			for (j = 1; j < HPAGE_PMD_NR; ++j)
-				if (p++ != pages[i + j])
+				if (++p != pages[i + j])
 				    break;
 			if (j != HPAGE_PMD_NR)

drivers/gpu/drm/udl/udl_drv.c+1−0

@@ -52,6 +52,7 @@ static struct drm_driver driver = { · 51 unmodified lines
52	.driver_features = DRIVER_MODESET \| DRIVER_GEM \| DRIVER_PRIME,	52	.driver_features = DRIVER_MODESET \| DRIVER_GEM \| DRIVER_PRIME,
53	.load = udl_driver_load,	53	.load = udl_driver_load,
54	.unload = udl_driver_unload,	54	.unload = udl_driver_unload,
		55	.release = udl_driver_release,
55		56
56	/* gem hooks */	57	/* gem hooks */
57	.gem_free_object_unlocked = udl_gem_free_object,	58	.gem_free_object_unlocked = udl_gem_free_object,

drivers/gpu/drm/udl/udl_drv.h+1−0

@@ -104,6 +104,7 @@ void udl_urb_completion(struct urb *urb); · 103 unmodified lines
104		104
105	int udl_driver_load(struct drm_device *dev, unsigned long flags);	105	int udl_driver_load(struct drm_device *dev, unsigned long flags);
106	void udl_driver_unload(struct drm_device *dev);	106	void udl_driver_unload(struct drm_device *dev);
		107	void udl_driver_release(struct drm_device *dev);
107		108
108	int udl_fbdev_init(struct drm_device *dev);	109	int udl_fbdev_init(struct drm_device *dev);
109	void udl_fbdev_cleanup(struct drm_device *dev);	110	void udl_fbdev_cleanup(struct drm_device *dev);

drivers/gpu/drm/udl/udl_main.c+7−1

@@ -379,6 +379,12 @@ void udl_driver_unload(struct drm_device *dev) · 378 unmodified lines
379	udl_free_urb_list(dev);	379	udl_free_urb_list(dev);
380		380
381	udl_fbdev_cleanup(dev);	381	udl_fbdev_cleanup(dev);
382	udl_modeset_cleanup(dev);
383	kfree(udl);	382	kfree(udl);
384	}	383	}
		384
		385	void udl_driver_release(struct drm_device *dev)
		386	{
		387	udl_modeset_cleanup(dev);
		388	drm_dev_fini(dev);
		389	kfree(dev);
		390	}

drivers/gpu/host1x/hw/channel_hw.c+5−1

 static void host1x_channel_set_streamid(struct host1x_channel *channel)
 {
 #if HOST1X_HW >= 6
+	u32 sid = 0x7f;
+#ifdef CONFIG_IOMMU_API
 	struct iommu_fwspec *spec = dev_iommu_fwspec_get(channel->dev->parent);
-	u32 sid = spec ? spec->ids[0] & 0xffff : 0x7f;
+	if (spec)
+		sid = spec->ids[0] & 0xffff;
+#endif
 	host1x_ch_writel(channel, sid, HOST1X_CHANNEL_SMMU_STREAMID);
 #endif

drivers/hid/Kconfig+1−0

@@ -150,6 +150,7 @@ config HID_ASUS · 149 unmodified lines
150	tristate "Asus"	150	tristate "Asus"
151	depends on LEDS_CLASS	151	depends on LEDS_CLASS
152	depends on ASUS_WMI \|\| ASUS_WMI=n	152	depends on ASUS_WMI \|\| ASUS_WMI=n
		153	select POWER_SUPPLY
153	---help---	154	---help---
154	Support for Asus notebook built-in keyboard and touchpad via i2c, and	155	Support for Asus notebook built-in keyboard and touchpad via i2c, and
155	the Asus Republic of Gamers laptop keyboard special keys.	156	the Asus Republic of Gamers laptop keyboard special keys.

drivers/hid/hid-core.c+3−3

@@ -1301,10 +1301,10 @@ static u32 __extract(u8 *report, unsigned offset, int n) · 1300 unmodified lines
1301	u32 hid_field_extract(const struct hid_device hid, u8 report,	1301	u32 hid_field_extract(const struct hid_device hid, u8 report,
1302	unsigned offset, unsigned n)	1302	unsigned offset, unsigned n)
1303	{	1303	{
1304	if (n > 32) {	1304	if (n > 256) {
1305	hid_warn(hid, "hid_field_extract() called with n (%d) > 32! (%s)\n",	1305	hid_warn(hid, "hid_field_extract() called with n (%d) > 256! (%s)\n",
1306	n, current->comm);	1306	n, current->comm);
1307	n = 32;	1307	n = 256;
1308	}	1308	}
1309		1309
1310	return __extract(report, offset, n);	1310	return __extract(report, offset, n);

drivers/hid/hid-debug.c+5−0

 	seq_printf(f, "\n\n");
 	/* dump parsed data and input mappings */
+	if (down_interruptible(&hdev->driver_input_lock))
+		return 0;
 	hid_dump_device(hdev, f);
 	seq_printf(f, "\n");
 	hid_dump_input_mapping(hdev, f);
+	up(&hdev->driver_input_lock);
 	return 0;
 }

drivers/hid/hid-ids.h+1−0

@@ -1083,6 +1083,7 @@ · 1082 unmodified lines
1083	#define USB_DEVICE_ID_SYNAPTICS_HD 0x0ac3	1083	#define USB_DEVICE_ID_SYNAPTICS_HD 0x0ac3
1084	#define USB_DEVICE_ID_SYNAPTICS_QUAD_HD 0x1ac3	1084	#define USB_DEVICE_ID_SYNAPTICS_QUAD_HD 0x1ac3
1085	#define USB_DEVICE_ID_SYNAPTICS_TP_V103 0x5710	1085	#define USB_DEVICE_ID_SYNAPTICS_TP_V103 0x5710
		1086	#define I2C_DEVICE_ID_SYNAPTICS_7E7E 0x7e7e
1086		1087
1087	#define USB_VENDOR_ID_TEXAS_INSTRUMENTS 0x2047	1088	#define USB_VENDOR_ID_TEXAS_INSTRUMENTS 0x2047
1088	#define USB_DEVICE_ID_TEXAS_INSTRUMENTS_LENOVO_YOGA 0x0855	1089	#define USB_DEVICE_ID_TEXAS_INSTRUMENTS_LENOVO_YOGA 0x0855

drivers/hid/hid-input.c+17−1

 			break;
 		}
+		if ((usage->hid & 0xf0) == 0xb0) {	/* SC - Display */
+			switch (usage->hid & 0xf) {
+			case 0x05: map_key_clear(KEY_SWITCHVIDEOMODE); break;
+			default: goto ignore;
+			}
+			break;
+		}
 		/*
 		 * Some lazy vendors declare 255 usages for System Control,
 		 * leading to the creation of ABS_X|Y axis and too many others.
 		case 0x06a: map_key_clear(KEY_GREEN);		break;
 		case 0x06b: map_key_clear(KEY_BLUE);		break;
 		case 0x06c: map_key_clear(KEY_YELLOW);		break;
-		case 0x06d: map_key_clear(KEY_ZOOM);		break;
+		case 0x06d: map_key_clear(KEY_ASPECT_RATIO);	break;
 		case 0x06f: map_key_clear(KEY_BRIGHTNESSUP);		break;
 		case 0x070: map_key_clear(KEY_BRIGHTNESSDOWN);		break;
 		case 0x074: map_key_clear(KEY_BRIGHTNESS_MAX);		break;
 		case 0x075: map_key_clear(KEY_BRIGHTNESS_AUTO);		break;
+		case 0x079: map_key_clear(KEY_KBDILLUMUP);	break;
+		case 0x07a: map_key_clear(KEY_KBDILLUMDOWN);	break;
+		case 0x07c: map_key_clear(KEY_KBDILLUMTOGGLE);	break;
 		case 0x082: map_key_clear(KEY_VIDEO_NEXT);	break;
 		case 0x083: map_key_clear(KEY_LAST);		break;
 		case 0x084: map_key_clear(KEY_ENTER);		break;
 		case 0x1b8: map_key_clear(KEY_VIDEO);		break;
 		case 0x1bc: map_key_clear(KEY_MESSENGER);	break;
 		case 0x1bd: map_key_clear(KEY_INFO);		break;
+		case 0x1cb: map_key_clear(KEY_ASSISTANT);	break;
 		case 0x201: map_key_clear(KEY_NEW);		break;
 		case 0x202: map_key_clear(KEY_OPEN);		break;
 		case 0x203: map_key_clear(KEY_CLOSE);		break;
 		case 0x22d: map_key_clear(KEY_ZOOMIN);		break;
 		case 0x22e: map_key_clear(KEY_ZOOMOUT);		break;
 		case 0x22f: map_key_clear(KEY_ZOOMRESET);	break;
+		case 0x232: map_key_clear(KEY_FULL_SCREEN);	break;
 		case 0x233: map_key_clear(KEY_SCROLLUP);	break;
 		case 0x234: map_key_clear(KEY_SCROLLDOWN);	break;
 		case 0x238: /* AC Pan */
 		case 0x2cb: map_key_clear(KEY_KBDINPUTASSIST_ACCEPT);	break;
 		case 0x2cc: map_key_clear(KEY_KBDINPUTASSIST_CANCEL);	break;
+		case 0x29f: map_key_clear(KEY_SCALE);		break;
 		default: map_key_clear(KEY_UNKNOWN);
 		}
 		break;

drivers/hid/hid-logitech-hidpp.c+10−3

 		kfree(data);
 		return -ENOMEM;
 	}
+	data->wq = create_singlethread_workqueue("hidpp-ff-sendqueue");
+	if (!data->wq) {
+		kfree(data->effect_ids);
+		kfree(data);
+		return -ENOMEM;
+	}
 	data->hidpp = hidpp;
 	data->feature_index = feature_index;
 	data->version = version;
 	/* ignore boost value at response.fap.params[2] */
 	/* init the hardware command queue */
-	data->wq = create_singlethread_workqueue("hidpp-ff-sendqueue");
 	atomic_set(&data->workqueue_size, 0);
 	/* initialize with zero autocenter to get wheel in usable state */
 		input_report_rel(mydata->input, REL_Y, v);
 		v = hid_snto32(data[6], 8);
-		hidpp_scroll_counter_handle_scroll(
+		if (v != 0)
-				&hidpp->vertical_wheel_counter, v);
+			hidpp_scroll_counter_handle_scroll(
+					&hidpp->vertical_wheel_counter, v);
 		input_sync(mydata->input);
 	}

drivers/hid/hid-quirks.c+7−4

 	{ HID_USB_DEVICE(USB_VENDOR_ID_DEALEXTREAME, USB_DEVICE_ID_DEALEXTREAME_RADIO_SI4701) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EARTHMATE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EM_LT20) },
-	{ HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, 0x0400) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC5UH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC4UM) },
 	{ }
 };
-/**
+/*
  * hid_mouse_ignore_list - mouse devices which should not be handled by the hid layer
  *
  * There are composite devices for which we want to ignore only a certain
 		if (hdev->product == 0x0401 &&
 		    strncmp(hdev->name, "ELAN0800", 8) != 0)
 			return true;
+		/* Same with product id 0x0400 */
+		if (hdev->product == 0x0400 &&
+		    strncmp(hdev->name, "QTEC0001", 8) != 0)
+			return true;
 		break;
 	}
 	}
 	if (bl_entry != NULL)
-		dbg_hid("Found dynamic quirk 0x%lx for HID device 0x%hx:0x%hx\n",
+		dbg_hid("Found dynamic quirk 0x%lx for HID device 0x%04x:0x%04x\n",
 			bl_entry->driver_data, bl_entry->vendor,
 			bl_entry->product);
 		quirks |= bl_entry->driver_data;
 	if (quirks)
-		dbg_hid("Found squirk 0x%lx for HID device 0x%hx:0x%hx\n",
+		dbg_hid("Found squirk 0x%lx for HID device 0x%04x:0x%04x\n",
 			quirks, hdev->vendor, hdev->product);
 	return quirks;
 }

drivers/hid/hid-steam.c+19−7

 static int steam_register(struct steam_device *steam)
 {
 	int ret;
+	bool client_opened;
 	/*
 	 * This function can be called several times in a row with the
 		 * Unlikely, but getting the serial could fail, and it is not so
 		 * important, so make up a serial number and go on.
 		 */
+		mutex_lock(&steam->mutex);
 		if (steam_get_serial(steam) < 0)
 			strlcpy(steam->serial_no, "XXXXXXXXXX",
 					sizeof(steam->serial_no));
+		mutex_unlock(&steam->mutex);
 		hid_info(steam->hdev, "Steam Controller '%s' connected",
 				steam->serial_no);
 	}
 	mutex_lock(&steam->mutex);
-	if (!steam->client_opened) {
+	client_opened = steam->client_opened;
+	if (!client_opened)
 		steam_set_lizard_mode(steam, lizard_mode);
+	mutex_unlock(&steam->mutex);
+	if (!client_opened)
 		ret = steam_input_register(steam);
-	} else {
+	else
 		ret = 0;
-	}
-	mutex_unlock(&steam->mutex);
 	return ret;
 }
 {
 	struct steam_device *steam = hdev->driver_data;
+	unsigned long flags;
+	bool connected;
+	spin_lock_irqsave(&steam->lock, flags);
+	connected = steam->connected;
+	spin_unlock_irqrestore(&steam->lock, flags);
 	mutex_lock(&steam->mutex);
 	steam->client_opened = false;
+	if (connected)
+		steam_set_lizard_mode(steam, lizard_mode);
 	mutex_unlock(&steam->mutex);
-	if (steam->connected) {
+	if (connected)
-		steam_set_lizard_mode(steam, lizard_mode);
 		steam_input_register(steam);
-	}
 }
 static int steam_client_ll_raw_request(struct hid_device *hdev,

drivers/hid/hid-uclogic-params.c+0−4

 		goto cleanup;
 	}
 	rc = usb_string(udev, 201, ver_ptr, ver_len);
-	if (ver_ptr == NULL) {
-		rc = -ENOMEM;
-		goto cleanup;
-	}
 	if (rc == -EPIPE) {
 		*ver_ptr = '\0';
 	} else if (rc < 0) {

drivers/hid/i2c-hid/i2c-hid-core.c+2−0

@@ -184,6 +184,8 @@ static const struct i2c_hid_quirks { · 183 unmodified lines
184	I2C_HID_QUIRK_NO_RUNTIME_PM },	184	I2C_HID_QUIRK_NO_RUNTIME_PM },
185	{ USB_VENDOR_ID_ELAN, HID_ANY_ID,	185	{ USB_VENDOR_ID_ELAN, HID_ANY_ID,
186	I2C_HID_QUIRK_BOGUS_IRQ },	186	I2C_HID_QUIRK_BOGUS_IRQ },
		187	{ USB_VENDOR_ID_SYNAPTICS, I2C_DEVICE_ID_SYNAPTICS_7E7E,
		188	I2C_HID_QUIRK_NO_RUNTIME_PM },
187	{ 0, 0 }	189	{ 0, 0 }
188	};	190	};
189		191

drivers/hwmon/Kconfig+1−0

@@ -1759,6 +1759,7 @@ config SENSORS_VT8231 · 1758 unmodified lines
1759	config SENSORS_W83773G	1759	config SENSORS_W83773G
1760	tristate "Nuvoton W83773G"	1760	tristate "Nuvoton W83773G"
1761	depends on I2C	1761	depends on I2C
		1762	select REGMAP_I2C
1762	help	1763	help
1763	If you say yes here you get support for the Nuvoton W83773G hardware	1764	If you say yes here you get support for the Nuvoton W83773G hardware
1764	monitoring chip.	1765	monitoring chip.

drivers/hwmon/ntc_thermistor.c+1−1

@@ -640,7 +640,7 @@ static const struct hwmon_channel_info ntc_chip = { · 639 unmodified lines
640	};	640	};
641		641
642	static const u32 ntc_temp_config[] = {	642	static const u32 ntc_temp_config[] = {
643	HWMON_T_INPUT, HWMON_T_TYPE,	643	HWMON_T_INPUT \| HWMON_T_TYPE,
644	0	644	0
645	};	645	};
646		646

drivers/hwmon/occ/common.c+4−2

 				s++;
 			}
 		}
+		s = (sensors->power.num_sensors * 4) + 1;
 	} else {
 		for (i = 0; i < sensors->power.num_sensors; ++i) {
 			s = i + 1;
 						     show_power, NULL, 3, i);
 			attr++;
 		}
-	}
-	if (sensors->caps.num_sensors >= 1) {
 		s = sensors->power.num_sensors + 1;
+	}
+	if (sensors->caps.num_sensors >= 1) {
 		snprintf(attr->name, sizeof(attr->name), "power%d_label", s);
 		attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
 					     0, 0);

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/i3c/master.c+2−3

 {
 	struct i3c_dev_boardinfo *boardinfo;
 	struct device *dev = &master->dev;
-	struct i3c_device_info info = { };
 	enum i3c_addr_slot_status addrstatus;
 	u32 init_dyn_addr = 0;
 	boardinfo->pid = ((u64)reg[1] << 32) | reg[2];
-	if ((info.pid & GENMASK_ULL(63, 48)) ||
+	if ((boardinfo->pid & GENMASK_ULL(63, 48)) ||
-	    I3C_PID_RND_LOWER_32BITS(info.pid))
+	    I3C_PID_RND_LOWER_32BITS(boardinfo->pid))
 		return -EINVAL;
 	boardinfo->init_dyn_addr = init_dyn_addr;

drivers/i3c/master/dw-i3c-master.c+1−1

@@ -300,7 +300,7 @@ to_dw_i3c_master(struct i3c_master_controller *master) · 299 unmodified lines
300		300
301	static void dw_i3c_master_disable(struct dw_i3c_master *master)	301	static void dw_i3c_master_disable(struct dw_i3c_master *master)
302	{	302	{
303	writel(readl(master->regs + DEVICE_CTRL) & DEV_CTRL_ENABLE,	303	writel(readl(master->regs + DEVICE_CTRL) & ~DEV_CTRL_ENABLE,
304	master->regs + DEVICE_CTRL);	304	master->regs + DEVICE_CTRL);
305	}	305	}
306		306

drivers/iio/accel/kxcjk-1013.c+2−0

@@ -1437,6 +1437,8 @@ static int kxcjk1013_resume(struct device *dev) · 1436 unmodified lines
1437		1437
1438	mutex_lock(&data->mutex);	1438	mutex_lock(&data->mutex);
1439	ret = kxcjk1013_set_mode(data, OPERATION);	1439	ret = kxcjk1013_set_mode(data, OPERATION);
		1440	if (ret == 0)
		1441	ret = kxcjk1013_set_range(data, data->range);
1440	mutex_unlock(&data->mutex);	1442	mutex_unlock(&data->mutex);
1441		1443
1442	return ret;	1444	return ret;

drivers/iio/adc/ad_sigma_delta.c+1−0

@@ -121,6 +121,7 @@ static int ad_sd_read_reg_raw(struct ad_sigma_delta *sigma_delta, · 120 unmodified lines
121	if (sigma_delta->info->has_registers) {	121	if (sigma_delta->info->has_registers) {
122	data[0] = reg << sigma_delta->info->addr_shift;	122	data[0] = reg << sigma_delta->info->addr_shift;
123	data[0] \|= sigma_delta->info->read_mask;	123	data[0] \|= sigma_delta->info->read_mask;
		124	data[0] \|= sigma_delta->comm;
124	spi_message_add_tail(&t[0], &m);	125	spi_message_add_tail(&t[0], &m);
125	}	126	}
126	spi_message_add_tail(&t[1], &m);	127	spi_message_add_tail(&t[1], &m);

drivers/iio/adc/at91_adc.c+17−11

 		ret = wait_event_interruptible_timeout(st->wq_data_avail,
 						       st->done,
 						       msecs_to_jiffies(1000));
-		if (ret == 0)
-			ret = -ETIMEDOUT;
-		if (ret < 0) {
-			mutex_unlock(&st->lock);
-			return ret;
-		}
-		*val = st->last_value;
+		/* Disable interrupts, regardless if adc conversion was
+		 * successful or not
+		 */
 		at91_adc_writel(st, AT91_ADC_CHDR,
 				AT91_ADC_CH(chan->channel));
 		at91_adc_writel(st, AT91_ADC_IDR, BIT(chan->channel));
-		st->last_value = 0;
+		if (ret > 0) {
-		st->done = false;
+			/* a valid conversion took place */
+			*val = st->last_value;
+			st->last_value = 0;
+			st->done = false;
+			ret = IIO_VAL_INT;
+		} else if (ret == 0) {
+			/* conversion timeout */
+			dev_err(&idev->dev, "ADC Channel %d timeout.\n",
+				chan->channel);
+			ret = -ETIMEDOUT;
+		}
 		mutex_unlock(&st->lock);
-		return IIO_VAL_INT;
+		return ret;
 	case IIO_CHAN_INFO_SCALE:
 		*val = st->vref_mv;

drivers/iio/adc/xilinx-xadc-core.c+2−1

 err_free_irq:
 	free_irq(xadc->irq, indio_dev);
+	cancel_delayed_work_sync(&xadc->zynq_unmask_work);
 err_clk_disable_unprepare:
 	clk_disable_unprepare(xadc->clk);
 err_free_samplerate_trigger:
 		iio_triggered_buffer_cleanup(indio_dev);
 	}
 	free_irq(xadc->irq, indio_dev);
+	cancel_delayed_work_sync(&xadc->zynq_unmask_work);
 	clk_disable_unprepare(xadc->clk);
-	cancel_delayed_work(&xadc->zynq_unmask_work);
 	kfree(xadc->data);
 	kfree(indio_dev->channels);

drivers/iio/chemical/Kconfig+14−0

@@ -64,6 +64,7 @@ config IAQCORE · 63 unmodified lines
64	config PMS7003	64	config PMS7003
65	tristate "Plantower PMS7003 particulate matter sensor"	65	tristate "Plantower PMS7003 particulate matter sensor"
66	depends on SERIAL_DEV_BUS	66	depends on SERIAL_DEV_BUS
		67	select IIO_TRIGGERED_BUFFER
67	help	68	help
68	Say Y here to build support for the Plantower PMS7003 particulate	69	Say Y here to build support for the Plantower PMS7003 particulate
69	matter sensor.	70	matter sensor.
@@ -71,6 +72,19 @@ config PMS7003 · 1 unmodified line
71	To compile this driver as a module, choose M here: the module will	72	To compile this driver as a module, choose M here: the module will
72	be called pms7003.	73	be called pms7003.
73		74
		75	config SENSIRION_SGP30
		76	tristate "Sensirion SGPxx gas sensors"
		77	depends on I2C
		78	select CRC8
		79	help
		80	Say Y here to build I2C interface support for the following
		81	Sensirion SGP gas sensors:
		82	* SGP30 gas sensor
		83	* SGPC3 low power gas sensor
		84
		85	To compile this driver as module, choose M here: the
		86	module will be called sgp30.
		87
74	config SPS30	88	config SPS30
75	tristate "SPS30 particulate matter sensor"	89	tristate "SPS30 particulate matter sensor"
76	depends on I2C	90	depends on I2C

drivers/iio/chemical/bme680.h+2−4

 #ifndef BME680_H_
 #define BME680_H_
-#define BME680_REG_CHIP_I2C_ID			0xD0
+#define BME680_REG_CHIP_ID			0xD0
-#define BME680_REG_CHIP_SPI_ID			0x50
 #define   BME680_CHIP_ID_VAL			0x61
-#define BME680_REG_SOFT_RESET_I2C		0xE0
+#define BME680_REG_SOFT_RESET			0xE0
-#define BME680_REG_SOFT_RESET_SPI		0x60
 #define   BME680_CMD_SOFTRESET			0xB6
 #define BME680_REG_STATUS			0x73
 #define   BME680_SPI_MEM_PAGE_BIT		BIT(4)

drivers/iio/chemical/bme680_core.c+45−9

 	s32 t_fine;
 };
+static const struct regmap_range bme680_volatile_ranges[] = {
+	regmap_reg_range(BME680_REG_MEAS_STAT_0, BME680_REG_GAS_R_LSB),
+	regmap_reg_range(BME680_REG_STATUS, BME680_REG_STATUS),
+	regmap_reg_range(BME680_T2_LSB_REG, BME680_GH3_REG),
+};
+static const struct regmap_access_table bme680_volatile_table = {
+	.yes_ranges	= bme680_volatile_ranges,
+	.n_yes_ranges	= ARRAY_SIZE(bme680_volatile_ranges),
+};
 const struct regmap_config bme680_regmap_config = {
 	.reg_bits = 8,
 	.val_bits = 8,
+	.max_register = 0xef,
+	.volatile_table = &bme680_volatile_table,
+	.cache_type = REGCACHE_RBTREE,
 };
 EXPORT_SYMBOL(bme680_regmap_config);
 	s64 var1, var2, var3;
 	s16 calc_temp;
+	/* If the calibration is invalid, attempt to reload it */
+	if (!calib->par_t2)
+		bme680_read_calib(data, calib);
 	var1 = (adc_temp >> 3) - (calib->par_t1 << 1);
 	var2 = (var1 * calib->par_t2) >> 11;
 	var3 = ((var1 >> 1) * (var1 >> 1)) >> 12;
 	return ret;
 }
-static int bme680_read_temp(struct bme680_data *data,
+static int bme680_read_temp(struct bme680_data *data, int *val)
-			    int *val, int *val2)
 {
 	struct device *dev = regmap_get_device(data->regmap);
 	int ret;
 	 * compensate_press/compensate_humid to get compensated
 	 * pressure/humidity readings.
 	 */
-	if (val && val2) {
+	if (val) {
-		*val = comp_temp;
+		*val = comp_temp * 10; /* Centidegrees to millidegrees */
-		*val2 = 100;
+		return IIO_VAL_INT;
-		return IIO_VAL_FRACTIONAL;
 	}
 	return ret;
 	s32 adc_press;
 	/* Read and compensate temperature to get a reading of t_fine */
-	ret = bme680_read_temp(data, NULL, NULL);
+	ret = bme680_read_temp(data, NULL);
 	if (ret < 0)
 		return ret;
 	u32 comp_humidity;
 	/* Read and compensate temperature to get a reading of t_fine */
-	ret = bme680_read_temp(data, NULL, NULL);
+	ret = bme680_read_temp(data, NULL);
 	if (ret < 0)
 		return ret;
 	case IIO_CHAN_INFO_PROCESSED:
 		switch (chan->type) {
 		case IIO_TEMP:
-			return bme680_read_temp(data, val, val2);
+			return bme680_read_temp(data, val);
 		case IIO_PRESSURE:
 			return bme680_read_press(data, val, val2);
 		case IIO_HUMIDITYRELATIVE:
 {
 	struct iio_dev *indio_dev;
 	struct bme680_data *data;
+	unsigned int val;
 	int ret;
+	ret = regmap_write(regmap, BME680_REG_SOFT_RESET,
+			   BME680_CMD_SOFTRESET);
+	if (ret < 0) {
+		dev_err(dev, "Failed to reset chip\n");
+		return ret;
+	}
+	ret = regmap_read(regmap, BME680_REG_CHIP_ID, &val);
+	if (ret < 0) {
+		dev_err(dev, "Error reading chip ID\n");
+		return ret;
+	}
+	if (val != BME680_CHIP_ID_VAL) {
+		dev_err(dev, "Wrong chip ID, got %x expected %x\n",
+				val, BME680_CHIP_ID_VAL);
+		return -ENODEV;
+	}
 	indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
 	if (!indio_dev)
 		return -ENOMEM;

drivers/iio/chemical/bme680_i2c.c+0−21

@@ -23,8 +23,6 @@ static int bme680_i2c_probe(struct i2c_client *client, · 22 unmodified lines
23	{	23	{
24	struct regmap *regmap;	24	struct regmap *regmap;
25	const char *name = NULL;	25	const char *name = NULL;
26	unsigned int val;
27	int ret;
28		26
29	regmap = devm_regmap_init_i2c(client, &bme680_regmap_config);	27	regmap = devm_regmap_init_i2c(client, &bme680_regmap_config);
30	if (IS_ERR(regmap)) {	28	if (IS_ERR(regmap)) {
@@ -33,25 +31,6 @@ static int bme680_i2c_probe(struct i2c_client *client, · 2 unmodified lines
33	return PTR_ERR(regmap);	31	return PTR_ERR(regmap);
34	}	32	}
35		33
36	ret = regmap_write(regmap, BME680_REG_SOFT_RESET_I2C,
37	BME680_CMD_SOFTRESET);
38	if (ret < 0) {
39	dev_err(&client->dev, "Failed to reset chip\n");
40	return ret;
41	}
42
43	ret = regmap_read(regmap, BME680_REG_CHIP_I2C_ID, &val);
44	if (ret < 0) {
45	dev_err(&client->dev, "Error reading I2C chip ID\n");
46	return ret;
47	}
48
49	if (val != BME680_CHIP_ID_VAL) {
50	dev_err(&client->dev, "Wrong chip ID, got %x expected %x\n",
51	val, BME680_CHIP_ID_VAL);
52	return -ENODEV;
53	}
54
55	if (id)	34	if (id)
56	name = id->name;	35	name = id->name;
57		36

drivers/iio/chemical/bme680_spi.c+78−37

 #include "bme680.h"
+struct bme680_spi_bus_context {
+	struct spi_device *spi;
+	u8 current_page;
+};
+/*
+ * In SPI mode there are only 7 address bits, a "page" register determines
+ * which part of the 8-bit range is active. This function looks at the address
+ * and writes the page selection bit if needed
+ */
+static int bme680_regmap_spi_select_page(
+	struct bme680_spi_bus_context *ctx, u8 reg)
+{
+	struct spi_device *spi = ctx->spi;
+	int ret;
+	u8 buf[2];
+	u8 page = (reg & 0x80) ? 0 : 1; /* Page "1" is low range */
+	if (page == ctx->current_page)
+		return 0;
+	/*
+	 * Data sheet claims we're only allowed to change bit 4, so we must do
+	 * a read-modify-write on each and every page select
+	 */
+	buf[0] = BME680_REG_STATUS;
+	ret = spi_write_then_read(spi, buf, 1, buf + 1, 1);
+	if (ret < 0) {
+		dev_err(&spi->dev, "failed to set page %u\n", page);
+		return ret;
+	}
+	buf[0] = BME680_REG_STATUS;
+	if (page)
+		buf[1] |= BME680_SPI_MEM_PAGE_BIT;
+	else
+		buf[1] &= ~BME680_SPI_MEM_PAGE_BIT;
+	ret = spi_write(spi, buf, 2);
+	if (ret < 0) {
+		dev_err(&spi->dev, "failed to set page %u\n", page);
+		return ret;
+	}
+	ctx->current_page = page;
+	return 0;
+}
 static int bme680_regmap_spi_write(void *context, const void *data,
 				   size_t count)
 {
-	struct spi_device *spi = context;
+	struct bme680_spi_bus_context *ctx = context;
+	struct spi_device *spi = ctx->spi;
+	int ret;
 	u8 buf[2];
 	memcpy(buf, data, 2);
+	ret = bme680_regmap_spi_select_page(ctx, buf[0]);
+	if (ret)
+		return ret;
 	/*
 	 * The SPI register address (= full register address without bit 7)
 	 * and the write command (bit7 = RW = '0')
 	 */
 	buf[0] &= ~0x80;
-	return spi_write_then_read(spi, buf, 2, NULL, 0);
+	return spi_write(spi, buf, 2);
 }
 static int bme680_regmap_spi_read(void *context, const void *reg,
 				  size_t reg_size, void *val, size_t val_size)
 {
-	struct spi_device *spi = context;
+	struct bme680_spi_bus_context *ctx = context;
+	struct spi_device *spi = ctx->spi;
+	int ret;
+	u8 addr = *(const u8 *)reg;
+	ret = bme680_regmap_spi_select_page(ctx, addr);
+	if (ret)
+		return ret;
-	return spi_write_then_read(spi, reg, reg_size, val, val_size);
+	addr |= 0x80; /* bit7 = RW = '1' */
+	return spi_write_then_read(spi, &addr, 1, val, val_size);
 }
 static struct regmap_bus bme680_regmap_bus = {
 static int bme680_spi_probe(struct spi_device *spi)
 {
 	const struct spi_device_id *id = spi_get_device_id(spi);
+	struct bme680_spi_bus_context *bus_context;
 	struct regmap *regmap;
-	unsigned int val;
 	int ret;
 	spi->bits_per_word = 8;
 		return ret;
 	}
+	bus_context = devm_kzalloc(&spi->dev, sizeof(*bus_context), GFP_KERNEL);
+	if (!bus_context)
+		return -ENOMEM;
+	bus_context->spi = spi;
+	bus_context->current_page = 0xff; /* Undefined on warm boot */
 	regmap = devm_regmap_init(&spi->dev, &bme680_regmap_bus,
-				  &spi->dev, &bme680_regmap_config);
+				  bus_context, &bme680_regmap_config);
 	if (IS_ERR(regmap)) {
 		dev_err(&spi->dev, "Failed to register spi regmap %d\n",
 				(int)PTR_ERR(regmap));
 		return PTR_ERR(regmap);
 	}
-	ret = regmap_write(regmap, BME680_REG_SOFT_RESET_SPI,
-			   BME680_CMD_SOFTRESET);
-	if (ret < 0) {
-		dev_err(&spi->dev, "Failed to reset chip\n");
-		return ret;
-	}
-	/* after power-on reset, Page 0(0x80-0xFF) of spi_mem_page is active */
-	ret = regmap_read(regmap, BME680_REG_CHIP_SPI_ID, &val);
-	if (ret < 0) {
-		dev_err(&spi->dev, "Error reading SPI chip ID\n");
-		return ret;
-	}
-	if (val != BME680_CHIP_ID_VAL) {
-		dev_err(&spi->dev, "Wrong chip ID, got %x expected %x\n",
-				val, BME680_CHIP_ID_VAL);
-		return -ENODEV;
-	}
-	/*
-	 * select Page 1 of spi_mem_page to enable access to
-	 * to registers from address 0x00 to 0x7F.
-	 */
-	ret = regmap_write_bits(regmap, BME680_REG_STATUS,
-				BME680_SPI_MEM_PAGE_BIT,
-				BME680_SPI_MEM_PAGE_1_VAL);
-	if (ret < 0) {
-		dev_err(&spi->dev, "failed to set page 1 of spi_mem_page\n");
-		return ret;
-	}
 	return bme680_core_probe(&spi->dev, regmap, id->name);
 }

drivers/iio/common/cros_ec_sensors/cros_ec_sensors.c+4−3

 			 * Do not use IIO_DEGREE_TO_RAD to avoid precision
 			 * loss. Round to the nearest integer.
 			 */
-			*val = div_s64(val64 * 314159 + 9000000ULL, 1000);
+			*val = 0;
-			*val2 = 18000 << (CROS_EC_SENSOR_BITS - 1);
+			*val2 = div_s64(val64 * 3141592653ULL,
-			ret = IIO_VAL_FRACTIONAL;
+					180 << (CROS_EC_SENSOR_BITS - 1));
+			ret = IIO_VAL_INT_PLUS_NANO;
 			break;
 		case MOTIONSENSE_TYPE_MAG:
 			/*

drivers/iio/dac/mcp4725.c+1−0

@@ -92,6 +92,7 @@ static ssize_t mcp4725_store_eeprom(struct device *dev, · 91 unmodified lines
92		92
93	inoutbuf[0] = 0x60; /* write EEPROM */	93	inoutbuf[0] = 0x60; /* write EEPROM */
94	inoutbuf[0] \|= data->ref_mode << 3;	94	inoutbuf[0] \|= data->ref_mode << 3;
		95	inoutbuf[0] \|= data->powerdown ? ((data->powerdown_mode + 1) << 1) : 0;
95	inoutbuf[1] = data->dac_value >> 4;	96	inoutbuf[1] = data->dac_value >> 4;
96	inoutbuf[2] = (data->dac_value & 0xf) << 4;	97	inoutbuf[2] = (data->dac_value & 0xf) << 4;
97		98

drivers/iio/gyro/bmg160_core.c+3−3

 	case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
 		return bmg160_get_filter(data, val);
 	case IIO_CHAN_INFO_SCALE:
-		*val = 0;
 		switch (chan->type) {
 		case IIO_TEMP:
-			*val2 = 500000;
+			*val = 500;
-			return IIO_VAL_INT_PLUS_MICRO;
+			return IIO_VAL_INT;
 		case IIO_ANGL_VEL:
 		{
 			int i;
 			for (i = 0; i < ARRAY_SIZE(bmg160_scale_table); ++i) {
 				if (bmg160_scale_table[i].dps_range ==
 							data->dps_range) {
+					*val = 0;
 					*val2 = bmg160_scale_table[i].scale;
 					return IIO_VAL_INT_PLUS_MICRO;
 				}

drivers/iio/gyro/mpu3050-core.c+5−3

 #include "mpu3050.h"
-#define MPU3050_CHIP_ID		0x69
+#define MPU3050_CHIP_ID		0x68
+#define MPU3050_CHIP_ID_MASK	0x7E
 /*
  * Register map: anything suffixed *_H is a big-endian high byte and always
 		goto err_power_down;
 	}
-	if (val != MPU3050_CHIP_ID) {
+	if ((val & MPU3050_CHIP_ID_MASK) != MPU3050_CHIP_ID) {
-		dev_err(dev, "unsupported chip id %02x\n", (u8)val);
+		dev_err(dev, "unsupported chip id %02x\n",
+				(u8)(val & MPU3050_CHIP_ID_MASK));
 		ret = -ENODEV;
 		goto err_power_down;
 	}

drivers/iio/industrialio-buffer.c+2−3

 	const unsigned long *mask;
 	unsigned long *trialmask;
-	trialmask = kmalloc_array(BITS_TO_LONGS(indio_dev->masklength),
+	trialmask = kcalloc(BITS_TO_LONGS(indio_dev->masklength),
-				  sizeof(*trialmask),
+			    sizeof(*trialmask), GFP_KERNEL);
-				  GFP_KERNEL);
 	if (trialmask == NULL)
 		return -ENOMEM;
 	if (!indio_dev->masklength) {

drivers/iio/industrialio-core.c+2−2

  **/
 void iio_device_unregister(struct iio_dev *indio_dev)
 {
-	mutex_lock(&indio_dev->info_exist_lock);
 	cdev_device_del(&indio_dev->chrdev, &indio_dev->dev);
+	mutex_lock(&indio_dev->info_exist_lock);
 	iio_device_unregister_debugfs(indio_dev);
 	iio_disable_all_buffers(indio_dev);

drivers/infiniband/core/uverbs_main.c+3−0

 		 * will only be one mm, so no big deal.
 		 */
 		down_write(&mm->mmap_sem);
+		if (!mmget_still_valid(mm))
+			goto skip_mm;
 		mutex_lock(&ufile->umap_lock);
 		list_for_each_entry_safe (priv, next_priv, &ufile->umaps,
 					  list) {
 			vma->vm_flags &= ~(VM_SHARED | VM_MAYSHARE);
 		}
 		mutex_unlock(&ufile->umap_lock);
+	skip_mm:
 		up_write(&mm->mmap_sem);
 		mmput(mm);
 	}

drivers/infiniband/hw/hfi1/chip.c+19−7

 	int total_contexts;
 	int ret;
 	unsigned ngroups;
-	int qos_rmt_count;
+	int rmt_count;
 	int user_rmt_reduced;
 	u32 n_usr_ctxts;
 	u32 send_contexts = chip_send_contexts(dd);
 		n_usr_ctxts = rcv_contexts - total_contexts;
 	}
-	/* each user context requires an entry in the RMT */
+	/*
-	qos_rmt_count = qos_rmt_entries(dd, NULL, NULL);
+	 * The RMT entries are currently allocated as shown below:
-	if (qos_rmt_count + n_usr_ctxts > NUM_MAP_ENTRIES) {
+	 * 1. QOS (0 to 128 entries);
-		user_rmt_reduced = NUM_MAP_ENTRIES - qos_rmt_count;
+	 * 2. FECN for PSM (num_user_contexts + num_vnic_contexts);
+	 * 3. VNIC (num_vnic_contexts).
+	 * It should be noted that PSM FECN oversubscribe num_vnic_contexts
+	 * entries of RMT because both VNIC and PSM could allocate any receive
+	 * context between dd->first_dyn_alloc_text and dd->num_rcv_contexts,
+	 * and PSM FECN must reserve an RMT entry for each possible PSM receive
+	 * context.
+	 */
+	rmt_count = qos_rmt_entries(dd, NULL, NULL) + (num_vnic_contexts * 2);
+	if (rmt_count + n_usr_ctxts > NUM_MAP_ENTRIES) {
+		user_rmt_reduced = NUM_MAP_ENTRIES - rmt_count;
 		dd_dev_err(dd,
 			   "RMT size is reducing the number of user receive contexts from %u to %d\n",
 			   n_usr_ctxts,
 	u64 reg;
 	int i, idx, regoff, regidx;
 	u8 offset;
+	u32 total_cnt;
 	/* there needs to be enough room in the map table */
-	if (rmt->used + dd->num_user_contexts >= NUM_MAP_ENTRIES) {
+	total_cnt = dd->num_rcv_contexts - dd->first_dyn_alloc_ctxt;
+	if (rmt->used + total_cnt >= NUM_MAP_ENTRIES) {
 		dd_dev_err(dd, "User FECN handling disabled - too many user contexts allocated\n");
 		return;
 	}
 	/* add rule 1 */
 	add_rsm_rule(dd, RSM_INS_FECN, &rrd);
-	rmt->used += dd->num_user_contexts;
+	rmt->used += total_cnt;
 }
 /* Initialize RSM for VNIC */

drivers/infiniband/hw/hfi1/qp.c+3−1

 		if (!list_empty(&priv->s_iowait.list) &&
 		    !(qp->s_flags & RVT_S_BUSY) &&
 		    !(priv->s_flags & RVT_S_BUSY)) {
-			qp->s_flags &= ~RVT_S_ANY_WAIT_IO;
+			qp->s_flags &= ~HFI1_S_ANY_WAIT_IO;
+			iowait_clear_flag(&priv->s_iowait, IOWAIT_PENDING_IB);
+			iowait_clear_flag(&priv->s_iowait, IOWAIT_PENDING_TID);
 			list_del_init(&priv->s_iowait.list);
 			priv->s_iowait.lock = NULL;
 			rvt_put_qp(qp);

drivers/infiniband/hw/hfi1/rc.c+2−2

@@ -3088,7 +3088,7 @@ send_last: · 3087 unmodified lines
3088	update_ack_queue(qp, next);	3088	update_ack_queue(qp, next);
3089	}	3089	}
3090	e = &qp->s_ack_queue[qp->r_head_ack_queue];	3090	e = &qp->s_ack_queue[qp->r_head_ack_queue];
3091	if (e->opcode == OP(RDMA_READ_REQUEST) && e->rdma_sge.mr) {	3091	if (e->rdma_sge.mr) {
3092	rvt_put_mr(e->rdma_sge.mr);	3092	rvt_put_mr(e->rdma_sge.mr);
3093	e->rdma_sge.mr = NULL;	3093	e->rdma_sge.mr = NULL;
3094	}	3094	}
@@ -3166,7 +3166,7 @@ send_last: · 71 unmodified lines
3166	update_ack_queue(qp, next);	3166	update_ack_queue(qp, next);
3167	}	3167	}
3168	e = &qp->s_ack_queue[qp->r_head_ack_queue];	3168	e = &qp->s_ack_queue[qp->r_head_ack_queue];
3169	if (e->opcode == OP(RDMA_READ_REQUEST) && e->rdma_sge.mr) {	3169	if (e->rdma_sge.mr) {
3170	rvt_put_mr(e->rdma_sge.mr);	3170	rvt_put_mr(e->rdma_sge.mr);
3171	e->rdma_sge.mr = NULL;	3171	e->rdma_sge.mr = NULL;
3172	}	3172	}

drivers/infiniband/hw/hfi1/tid_rdma.c+8−23

 	    make_tid_rdma_ack(qp, ohdr, ps))
 		return 1;
-	if (!(ib_rvt_state_ops[qp->state] & RVT_PROCESS_SEND_OK)) {
+	/*
-		if (!(ib_rvt_state_ops[qp->state] & RVT_FLUSH_SEND))
+	 * Bail out if we can't send data.
-			goto bail;
+	 * Be reminded that this check must been done after the call to
-		/* We are in the error state, flush the work request. */
+	 * make_tid_rdma_ack() because the responding QP could be in
-		if (qp->s_last == READ_ONCE(qp->s_head))
+	 * RTR state where it can send TID RDMA ACK, not TID RDMA WRITE DATA.
-			goto bail;
+	 */
-		/* If DMAs are in progress, we can't flush immediately. */
+	if (!(ib_rvt_state_ops[qp->state] & RVT_PROCESS_SEND_OK))
-		if (iowait_sdma_pending(&priv->s_iowait)) {
+		goto bail;
-			qp->s_flags |= RVT_S_WAIT_DMA;
-			goto bail;
-		}
-		clear_ahg(qp);
-		wqe = rvt_get_swqe_ptr(qp, qp->s_last);
-		hfi1_trdma_send_complete(qp, wqe, qp->s_last != qp->s_acked ?
-					 IB_WC_SUCCESS : IB_WC_WR_FLUSH_ERR);
-		/* will get called again */
-		goto done_free_tx;
-	}
 	if (priv->s_flags & RVT_S_WAIT_ACK)
 		goto bail;
 	hfi1_make_ruc_header(qp, ohdr, (opcode << 24), bth1, bth2,
 			     middle, ps);
 	return 1;
-done_free_tx:
-	hfi1_put_txreq(ps->s_txreq);
-	ps->s_txreq = NULL;
-	return 1;
 bail:
 	hfi1_put_txreq(ps->s_txreq);
 bail_no_tx:

drivers/infiniband/hw/hns/hns_roce_hem.c+4−2

 		idx_offset = (obj & (table->num_obj - 1)) % obj_per_chunk;
 		dma_offset = offset = idx_offset * table->obj_size;
 	} else {
+		u32 seg_size = 64; /* 8 bytes per BA and 8 BA per segment */
 		hns_roce_calc_hem_mhop(hr_dev, table, &mhop_obj, &mhop);
 		/* mtt mhop */
 		i = mhop.l0_idx;
 			hem_idx = i;
 		hem = table->hem[hem_idx];
-		dma_offset = offset = (obj & (table->num_obj - 1)) *
+		dma_offset = offset = (obj & (table->num_obj - 1)) * seg_size %
-				       table->obj_size % mhop.bt_chunk_size;
+				       mhop.bt_chunk_size;
 		if (mhop.hop_num == 2)
 			dma_offset = offset = 0;
 	}

drivers/infiniband/hw/hns/hns_roce_mr.c+2−2

 	struct hns_roce_hem_table *table;
 	dma_addr_t dma_handle;
 	__le64 *mtts;
-	u32 s = start_index * sizeof(u64);
 	u32 bt_page_size;
 	u32 i;
 		return -EINVAL;
 	mtts = hns_roce_table_find(hr_dev, table,
-				mtt->first_seg + s / hr_dev->caps.mtt_entry_sz,
+				mtt->first_seg +
+				start_index / HNS_ROCE_MTT_ENTRY_PER_SEG,
 				&dma_handle);
 	if (!mtts)
 		return -ENOMEM;

drivers/infiniband/hw/hns/hns_roce_qp.c+0−3

 	wait_for_completion(&hr_qp->free);
 	if ((hr_qp->ibqp.qp_type) != IB_QPT_GSI) {
-		if (hr_dev->caps.sccc_entry_sz)
-			hns_roce_table_put(hr_dev, &qp_table->sccc_table,
-					   hr_qp->qpn);
 		if (hr_dev->caps.trrl_entry_sz)
 			hns_roce_table_put(hr_dev, &qp_table->trrl_table,
 					   hr_qp->qpn);

drivers/infiniband/hw/mlx5/odp.c+2−1

 	struct ib_umem_odp *odp_mr = to_ib_umem_odp(mr->umem);
 	bool downgrade = flags & MLX5_PF_FLAGS_DOWNGRADE;
 	bool prefetch = flags & MLX5_PF_FLAGS_PREFETCH;
-	u64 access_mask = ODP_READ_ALLOWED_BIT;
+	u64 access_mask;
 	u64 start_idx, page_mask;
 	struct ib_umem_odp *odp;
 	size_t size;
 	page_shift = mr->umem->page_shift;
 	page_mask = ~(BIT(page_shift) - 1);
 	start_idx = (io_virt - (mr->mmkey.iova & page_mask)) >> page_shift;
+	access_mask = ODP_READ_ALLOWED_BIT;
 	if (prefetch && !downgrade && !mr->umem->writable) {
 		/* prefetch with write-access must

drivers/infiniband/hw/vmw_pvrdma/pvrdma_main.c+2−0

@@ -1131,6 +1131,8 @@ static void pvrdma_pci_remove(struct pci_dev *pdev) · 1130 unmodified lines
1131	pvrdma_page_dir_cleanup(dev, &dev->cq_pdir);	1131	pvrdma_page_dir_cleanup(dev, &dev->cq_pdir);
1132	pvrdma_page_dir_cleanup(dev, &dev->async_pdir);	1132	pvrdma_page_dir_cleanup(dev, &dev->async_pdir);
1133	pvrdma_free_slots(dev);	1133	pvrdma_free_slots(dev);
		1134	dma_free_coherent(&pdev->dev, sizeof(*dev->dsr), dev->dsr,
		1135	dev->dsrbase);
1134		1136
1135	iounmap(dev->regs);	1137	iounmap(dev->regs);
1136	kfree(dev->sgid_tbl);	1138	kfree(dev->sgid_tbl);

drivers/input/keyboard/snvs_pwrkey.c+3−3

 		return error;
 	}
+	pdata->input = input;
+	platform_set_drvdata(pdev, pdata);
 	error = devm_request_irq(&pdev->dev, pdata->irq,
 			       imx_snvs_pwrkey_interrupt,
 			       0, pdev->name, pdev);
 		return error;
 	}
-	pdata->input = input;
-	platform_set_drvdata(pdev, pdata);
 	device_init_wakeup(&pdev->dev, pdata->wakeup);
 	return 0;

drivers/input/mouse/elan_i2c_core.c+25−0

@@ -1339,21 +1339,46 @@ static const struct acpi_device_id elan_acpi_id[] = { · 1338 unmodified lines
1339	{ "ELAN0600", 0 },	1339	{ "ELAN0600", 0 },
1340	{ "ELAN0601", 0 },	1340	{ "ELAN0601", 0 },
1341	{ "ELAN0602", 0 },	1341	{ "ELAN0602", 0 },
		1342	{ "ELAN0603", 0 },
		1343	{ "ELAN0604", 0 },
1342	{ "ELAN0605", 0 },	1344	{ "ELAN0605", 0 },
		1345	{ "ELAN0606", 0 },
		1346	{ "ELAN0607", 0 },
1343	{ "ELAN0608", 0 },	1347	{ "ELAN0608", 0 },
1344	{ "ELAN0609", 0 },	1348	{ "ELAN0609", 0 },
1345	{ "ELAN060B", 0 },	1349	{ "ELAN060B", 0 },
1346	{ "ELAN060C", 0 },	1350	{ "ELAN060C", 0 },
		1351	{ "ELAN060F", 0 },
		1352	{ "ELAN0610", 0 },
1347	{ "ELAN0611", 0 },	1353	{ "ELAN0611", 0 },
1348	{ "ELAN0612", 0 },	1354	{ "ELAN0612", 0 },
		1355	{ "ELAN0615", 0 },
		1356	{ "ELAN0616", 0 },
1349	{ "ELAN0617", 0 },	1357	{ "ELAN0617", 0 },
1350	{ "ELAN0618", 0 },	1358	{ "ELAN0618", 0 },
		1359	{ "ELAN0619", 0 },
		1360	{ "ELAN061A", 0 },
		1361	{ "ELAN061B", 0 },
1351	{ "ELAN061C", 0 },	1362	{ "ELAN061C", 0 },
1352	{ "ELAN061D", 0 },	1363	{ "ELAN061D", 0 },
1353	{ "ELAN061E", 0 },	1364	{ "ELAN061E", 0 },
		1365	{ "ELAN061F", 0 },
1354	{ "ELAN0620", 0 },	1366	{ "ELAN0620", 0 },
1355	{ "ELAN0621", 0 },	1367	{ "ELAN0621", 0 },
1356	{ "ELAN0622", 0 },	1368	{ "ELAN0622", 0 },
		1369	{ "ELAN0623", 0 },
		1370	{ "ELAN0624", 0 },
		1371	{ "ELAN0625", 0 },
		1372	{ "ELAN0626", 0 },
		1373	{ "ELAN0627", 0 },
		1374	{ "ELAN0628", 0 },
		1375	{ "ELAN0629", 0 },
		1376	{ "ELAN062A", 0 },
		1377	{ "ELAN062B", 0 },
		1378	{ "ELAN062C", 0 },
		1379	{ "ELAN062D", 0 },
		1380	{ "ELAN0631", 0 },
		1381	{ "ELAN0632", 0 },
1357	{ "ELAN1000", 0 },	1382	{ "ELAN1000", 0 },
1358	{ }	1383	{ }
1359	};	1384	};

drivers/iommu/amd_iommu_init.c+1−1

@@ -359,7 +359,7 @@ static void iommu_write_l2(struct amd_iommu *iommu, u8 address, u32 val) · 358 unmodified lines
359	static void iommu_set_exclusion_range(struct amd_iommu *iommu)	359	static void iommu_set_exclusion_range(struct amd_iommu *iommu)
360	{	360	{
361	u64 start = iommu->exclusion_start & PAGE_MASK;	361	u64 start = iommu->exclusion_start & PAGE_MASK;
362	u64 limit = (start + iommu->exclusion_length) & PAGE_MASK;	362	u64 limit = (start + iommu->exclusion_length - 1) & PAGE_MASK;
363	u64 entry;	363	u64 entry;
364		364
365	if (!iommu->exclusion_start)	365	if (!iommu->exclusion_start)

drivers/irqchip/irq-ls1x.c+1−0

@@ -130,6 +130,7 @@ static int __init ls1x_intc_of_init(struct device_node *node, · 129 unmodified lines
130	NULL);	130	NULL);
131	if (!priv->domain) {	131	if (!priv->domain) {
132	pr_err("ls1x-irq: cannot add IRQ domain\n");	132	pr_err("ls1x-irq: cannot add IRQ domain\n");
		133	err = -ENOMEM;
133	goto out_iounmap;	134	goto out_iounmap;
134	}	135	}
135		136

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

@@ -710,10 +710,10 @@ base_sock_bind(struct socket sock, struct sockaddr addr, int addr_len) · 709 unmodified lines
710	struct sock *sk = sock->sk;	710	struct sock *sk = sock->sk;
711	int err = 0;	711	int err = 0;
712		712
713	if (!maddr \|\| maddr->family != AF_ISDN)	713	if (addr_len < sizeof(struct sockaddr_mISDN))
714	return -EINVAL;	714	return -EINVAL;
715		715
716	if (addr_len < sizeof(struct sockaddr_mISDN))	716	if (!maddr \|\| maddr->family != AF_ISDN)
717	return -EINVAL;	717	return -EINVAL;
718		718
719	lock_sock(sk);	719	lock_sock(sk);

drivers/lightnvm/pblk-read.c+28−22

@@ -231,14 +231,14 @@ static void pblk_end_partial_read(struct nvm_rq *rqd) · 230 unmodified lines
231	struct pblk_sec_meta *meta;	231	struct pblk_sec_meta *meta;
232	struct bio *new_bio = rqd->bio;	232	struct bio *new_bio = rqd->bio;
233	struct bio *bio = pr_ctx->orig_bio;	233	struct bio *bio = pr_ctx->orig_bio;
234	struct bio_vec src_bv, dst_bv;
235	void *meta_list = rqd->meta_list;	234	void *meta_list = rqd->meta_list;
236	int bio_init_idx = pr_ctx->bio_init_idx;
237	unsigned long *read_bitmap = pr_ctx->bitmap;	235	unsigned long *read_bitmap = pr_ctx->bitmap;
		236	struct bvec_iter orig_iter = BVEC_ITER_ALL_INIT;
		237	struct bvec_iter new_iter = BVEC_ITER_ALL_INIT;
238	int nr_secs = pr_ctx->orig_nr_secs;	238	int nr_secs = pr_ctx->orig_nr_secs;
239	int nr_holes = nr_secs - bitmap_weight(read_bitmap, nr_secs);	239	int nr_holes = nr_secs - bitmap_weight(read_bitmap, nr_secs);
240	void src_p, dst_p;	240	void src_p, dst_p;
241	int hole, i;	241	int bit, i;
242		242
243	if (unlikely(nr_holes == 1)) {	243	if (unlikely(nr_holes == 1)) {
244	struct ppa_addr ppa;	244	struct ppa_addr ppa;
@@ -257,33 +257,39 @@ static void pblk_end_partial_read(struct nvm_rq *rqd) · 12 unmodified lines
257		257
258	/* Fill the holes in the original bio */	258	/* Fill the holes in the original bio */
259	i = 0;	259	i = 0;
260	hole = find_first_zero_bit(read_bitmap, nr_secs);	260	for (bit = 0; bit < nr_secs; bit++) {
261	do {	261	if (!test_bit(bit, read_bitmap)) {
262	struct pblk_line *line;	262	struct bio_vec dst_bv, src_bv;
		263	struct pblk_line *line;
263		264
264	line = pblk_ppa_to_line(pblk, rqd->ppa_list[i]);	265	line = pblk_ppa_to_line(pblk, rqd->ppa_list[i]);
265	kref_put(&line->ref, pblk_line_put);	266	kref_put(&line->ref, pblk_line_put);
266		267
267	meta = pblk_get_meta(pblk, meta_list, hole);	268	meta = pblk_get_meta(pblk, meta_list, bit);
268	meta->lba = cpu_to_le64(pr_ctx->lba_list_media[i]);	269	meta->lba = cpu_to_le64(pr_ctx->lba_list_media[i]);
269		270
270	src_bv = new_bio->bi_io_vec[i++];	271	dst_bv = bio_iter_iovec(bio, orig_iter);
271	dst_bv = bio->bi_io_vec[bio_init_idx + hole];	272	src_bv = bio_iter_iovec(new_bio, new_iter);
272		273
273	src_p = kmap_atomic(src_bv.bv_page);	274	src_p = kmap_atomic(src_bv.bv_page);
274	dst_p = kmap_atomic(dst_bv.bv_page);	275	dst_p = kmap_atomic(dst_bv.bv_page);
275		276
276	memcpy(dst_p + dst_bv.bv_offset,	277	memcpy(dst_p + dst_bv.bv_offset,
277	src_p + src_bv.bv_offset,	278	src_p + src_bv.bv_offset,
278	PBLK_EXPOSED_PAGE_SIZE);	279	PBLK_EXPOSED_PAGE_SIZE);
279		280
280	kunmap_atomic(src_p);	281	kunmap_atomic(src_p);
281	kunmap_atomic(dst_p);	282	kunmap_atomic(dst_p);
282		283
283	mempool_free(src_bv.bv_page, &pblk->page_bio_pool);	284	flush_dcache_page(dst_bv.bv_page);
		285	mempool_free(src_bv.bv_page, &pblk->page_bio_pool);
284		286
285	hole = find_next_zero_bit(read_bitmap, nr_secs, hole + 1);	287	bio_advance_iter(new_bio, &new_iter,
286	} while (hole < nr_secs);	288	PBLK_EXPOSED_PAGE_SIZE);
		289	i++;
		290	}
		291	bio_advance_iter(bio, &orig_iter, PBLK_EXPOSED_PAGE_SIZE);
		292	}
287		293
288	bio_put(new_bio);	294	bio_put(new_bio);
289	kfree(pr_ctx);	295	kfree(pr_ctx);

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/mfd/Kconfig+1−1

@@ -1246,7 +1246,7 @@ config MFD_STA2X11 · 1245 unmodified lines
1246		1246
1247	config MFD_SUN6I_PRCM	1247	config MFD_SUN6I_PRCM
1248	bool "Allwinner A31 PRCM controller"	1248	bool "Allwinner A31 PRCM controller"
1249	depends on ARCH_SUNXI	1249	depends on ARCH_SUNXI \|\| COMPILE_TEST
1250	select MFD_CORE	1250	select MFD_CORE
1251	help	1251	help
1252	Support for the PRCM (Power/Reset/Clock Management) unit available	1252	Support for the PRCM (Power/Reset/Clock Management) unit available

drivers/mfd/sprd-sc27xx-spi.c+21−21

@@ -53,67 +53,67 @@ static const struct sprd_pmic_data sc2731_data = { · 52 unmodified lines
53	static const struct mfd_cell sprd_pmic_devs[] = {	53	static const struct mfd_cell sprd_pmic_devs[] = {
54	{	54	{
55	.name = "sc27xx-wdt",	55	.name = "sc27xx-wdt",
56	.of_compatible = "sprd,sc27xx-wdt",	56	.of_compatible = "sprd,sc2731-wdt",
57	}, {	57	}, {
58	.name = "sc27xx-rtc",	58	.name = "sc27xx-rtc",
59	.of_compatible = "sprd,sc27xx-rtc",	59	.of_compatible = "sprd,sc2731-rtc",
60	}, {	60	}, {
61	.name = "sc27xx-charger",	61	.name = "sc27xx-charger",
62	.of_compatible = "sprd,sc27xx-charger",	62	.of_compatible = "sprd,sc2731-charger",
63	}, {	63	}, {
64	.name = "sc27xx-chg-timer",	64	.name = "sc27xx-chg-timer",
65	.of_compatible = "sprd,sc27xx-chg-timer",	65	.of_compatible = "sprd,sc2731-chg-timer",
66	}, {	66	}, {
67	.name = "sc27xx-fast-chg",	67	.name = "sc27xx-fast-chg",
68	.of_compatible = "sprd,sc27xx-fast-chg",	68	.of_compatible = "sprd,sc2731-fast-chg",
69	}, {	69	}, {
70	.name = "sc27xx-chg-wdt",	70	.name = "sc27xx-chg-wdt",
71	.of_compatible = "sprd,sc27xx-chg-wdt",	71	.of_compatible = "sprd,sc2731-chg-wdt",
72	}, {	72	}, {
73	.name = "sc27xx-typec",	73	.name = "sc27xx-typec",
74	.of_compatible = "sprd,sc27xx-typec",	74	.of_compatible = "sprd,sc2731-typec",
75	}, {	75	}, {
76	.name = "sc27xx-flash",	76	.name = "sc27xx-flash",
77	.of_compatible = "sprd,sc27xx-flash",	77	.of_compatible = "sprd,sc2731-flash",
78	}, {	78	}, {
79	.name = "sc27xx-eic",	79	.name = "sc27xx-eic",
80	.of_compatible = "sprd,sc27xx-eic",	80	.of_compatible = "sprd,sc2731-eic",
81	}, {	81	}, {
82	.name = "sc27xx-efuse",	82	.name = "sc27xx-efuse",
83	.of_compatible = "sprd,sc27xx-efuse",	83	.of_compatible = "sprd,sc2731-efuse",
84	}, {	84	}, {
85	.name = "sc27xx-thermal",	85	.name = "sc27xx-thermal",
86	.of_compatible = "sprd,sc27xx-thermal",	86	.of_compatible = "sprd,sc2731-thermal",
87	}, {	87	}, {
88	.name = "sc27xx-adc",	88	.name = "sc27xx-adc",
89	.of_compatible = "sprd,sc27xx-adc",	89	.of_compatible = "sprd,sc2731-adc",
90	}, {	90	}, {
91	.name = "sc27xx-audio-codec",	91	.name = "sc27xx-audio-codec",
92	.of_compatible = "sprd,sc27xx-audio-codec",	92	.of_compatible = "sprd,sc2731-audio-codec",
93	}, {	93	}, {
94	.name = "sc27xx-regulator",	94	.name = "sc27xx-regulator",
95	.of_compatible = "sprd,sc27xx-regulator",	95	.of_compatible = "sprd,sc2731-regulator",
96	}, {	96	}, {
97	.name = "sc27xx-vibrator",	97	.name = "sc27xx-vibrator",
98	.of_compatible = "sprd,sc27xx-vibrator",	98	.of_compatible = "sprd,sc2731-vibrator",
99	}, {	99	}, {
100	.name = "sc27xx-keypad-led",	100	.name = "sc27xx-keypad-led",
101	.of_compatible = "sprd,sc27xx-keypad-led",	101	.of_compatible = "sprd,sc2731-keypad-led",
102	}, {	102	}, {
103	.name = "sc27xx-bltc",	103	.name = "sc27xx-bltc",
104	.of_compatible = "sprd,sc27xx-bltc",	104	.of_compatible = "sprd,sc2731-bltc",
105	}, {	105	}, {
106	.name = "sc27xx-fgu",	106	.name = "sc27xx-fgu",
107	.of_compatible = "sprd,sc27xx-fgu",	107	.of_compatible = "sprd,sc2731-fgu",
108	}, {	108	}, {
109	.name = "sc27xx-7sreset",	109	.name = "sc27xx-7sreset",
110	.of_compatible = "sprd,sc27xx-7sreset",	110	.of_compatible = "sprd,sc2731-7sreset",
111	}, {	111	}, {
112	.name = "sc27xx-poweroff",	112	.name = "sc27xx-poweroff",
113	.of_compatible = "sprd,sc27xx-poweroff",	113	.of_compatible = "sprd,sc2731-poweroff",
114	}, {	114	}, {
115	.name = "sc27xx-syscon",	115	.name = "sc27xx-syscon",
116	.of_compatible = "sprd,sc27xx-syscon",	116	.of_compatible = "sprd,sc2731-syscon",
117	},	117	},
118	};	118	};
119		119

drivers/mfd/twl-core.c+23−0

@@ -1245,6 +1245,28 @@ free: · 1244 unmodified lines
1245	return status;	1245	return status;
1246	}	1246	}
1247		1247
		1248	static int __maybe_unused twl_suspend(struct device *dev)
		1249	{
		1250	struct i2c_client *client = to_i2c_client(dev);
		1251
		1252	if (client->irq)
		1253	disable_irq(client->irq);
		1254
		1255	return 0;
		1256	}
		1257
		1258	static int __maybe_unused twl_resume(struct device *dev)
		1259	{
		1260	struct i2c_client *client = to_i2c_client(dev);
		1261
		1262	if (client->irq)
		1263	enable_irq(client->irq);
		1264
		1265	return 0;
		1266	}
		1267
		1268	static SIMPLE_DEV_PM_OPS(twl_dev_pm_ops, twl_suspend, twl_resume);
		1269
1248	static const struct i2c_device_id twl_ids[] = {	1270	static const struct i2c_device_id twl_ids[] = {
1249	{ "twl4030", TWL4030_VAUX2 }, /* "Triton 2" */	1271	{ "twl4030", TWL4030_VAUX2 }, /* "Triton 2" */
1250	{ "twl5030", 0 }, /* T2 updated */	1272	{ "twl5030", 0 }, /* T2 updated */
@@ -1262,6 +1284,7 @@ static const struct i2c_device_id twl_ids[] = { · 11 unmodified lines
1262	/* One Client Driver , 4 Clients */	1284	/* One Client Driver , 4 Clients */
1263	static struct i2c_driver twl_driver = {	1285	static struct i2c_driver twl_driver = {
1264	.driver.name = DRIVER_NAME,	1286	.driver.name = DRIVER_NAME,
		1287	.driver.pm = &twl_dev_pm_ops,
1265	.id_table = twl_ids,	1288	.id_table = twl_ids,
1266	.probe = twl_probe,	1289	.probe = twl_probe,
1267	.remove = twl_remove,	1290	.remove = twl_remove,

drivers/misc/fastrpc.c+6−1

 	struct fastrpc_session_ctx *sess;
 	struct device *dev = &pdev->dev;
 	int i, sessions = 0;
+	int rc;
 	cctx = dev_get_drvdata(dev->parent);
 	if (!cctx)
 	}
 	cctx->sesscount++;
 	spin_unlock(&cctx->lock);
-	dma_set_mask(dev, DMA_BIT_MASK(32));
+	rc = dma_set_mask(dev, DMA_BIT_MASK(32));
+	if (rc) {
+		dev_err(dev, "32-bit DMA enable failed\n");
+		return rc;
+	}
 	return 0;
 }

drivers/misc/habanalabs/goya/goya.c+4−5

 	/*
 	 * Workaround for H2 #HW-23 bug
-	 * Set DMA max outstanding read requests to 240 on DMA CH 1. Set it
+	 * Set DMA max outstanding read requests to 240 on DMA CH 1.
-	 * to 16 on KMD DMA
+	 * This limitation is still large enough to not affect Gen4 bandwidth.
-	 * We need to limit only these DMAs because the user can only read
+	 * We need to only limit that DMA channel because the user can only read
 	 * from Host using DMA CH 1
 	 */
-	WREG32(mmDMA_CH_0_CFG0, 0x0fff0010);
 	WREG32(mmDMA_CH_1_CFG0, 0x0fff00F0);
 	goya->hw_cap_initialized |= HW_CAP_GOLDEN;
 	 * WA for HW-23.
 	 * We can't allow user to read from Host using QMANs other than 1.
 	 */
-	if (parser->hw_queue_id > GOYA_QUEUE_ID_DMA_1 &&
+	if (parser->hw_queue_id != GOYA_QUEUE_ID_DMA_1 &&
 		hl_mem_area_inside_range(le64_to_cpu(user_dma_pkt->src_addr),
 				le32_to_cpu(user_dma_pkt->tsize),
 				hdev->asic_prop.va_space_host_start_address,

drivers/mmc/host/alcor.c+13−21

 	struct mmc_command *cmd;
 	struct mmc_data *data;
 	unsigned int dma_on:1;
-	unsigned int early_data:1;
 	struct mutex cmd_mutex;
 	host->sg_count--;
 }
-static void alcor_trigger_data_transfer(struct alcor_sdmmc_host *host,
+static void alcor_trigger_data_transfer(struct alcor_sdmmc_host *host)
-					bool early)
 {
 	struct alcor_pci_priv *priv = host->alcor_pci;
 	struct mmc_data *data = host->data;
 		ctrl |= AU6601_DATA_WRITE;
 	if (data->host_cookie == COOKIE_MAPPED) {
-		if (host->early_data) {
-			host->early_data = false;
-			return;
-		}
-		host->early_data = early;
 		alcor_data_set_dma(host);
 		ctrl |= AU6601_DATA_DMA_MODE;
 		host->dma_on = 1;
 static void alcor_prepare_data(struct alcor_sdmmc_host *host,
 			       struct mmc_command *cmd)
 {
+	struct alcor_pci_priv *priv = host->alcor_pci;
 	struct mmc_data *data = cmd->data;
 	if (!data)
 	if (data->host_cookie != COOKIE_MAPPED)
 		alcor_prepare_sg_miter(host);
-	alcor_trigger_data_transfer(host, true);
+	alcor_write8(priv, 0, AU6601_DATA_XFER_CTRL);
 }
 static void alcor_send_cmd(struct alcor_sdmmc_host *host,
 	if (!host->data)
 		return false;
-	alcor_trigger_data_transfer(host, false);
+	alcor_trigger_data_transfer(host);
 	host->cmd = NULL;
 	return true;
 }
 	if (!host->data)
 		alcor_request_complete(host, 1);
 	else
-		alcor_trigger_data_transfer(host, false);
+		alcor_trigger_data_transfer(host);
 	host->cmd = NULL;
 }
 		break;
 	case AU6601_INT_READ_BUF_RDY:
 		alcor_trf_block_pio(host, true);
-		if (!host->blocks)
-			break;
-		alcor_trigger_data_transfer(host, false);
 		return 1;
 	case AU6601_INT_WRITE_BUF_RDY:
 		alcor_trf_block_pio(host, false);
-		if (!host->blocks)
-			break;
-		alcor_trigger_data_transfer(host, false);
 		return 1;
 	case AU6601_INT_DMA_END:
 		if (!host->sg_count)
 		break;
 	}
-	if (intmask & AU6601_INT_DATA_END)
+	if (intmask & AU6601_INT_DATA_END) {
-		return 0;
+		if (!host->dma_on && host->blocks) {
+			alcor_trigger_data_transfer(host);
+			return 1;
+		} else {
+			return 0;
+		}
+	}
 	return 1;
 }

drivers/mmc/host/sdhci-omap.c+38−0

@@ -797,6 +797,43 @@ void sdhci_omap_reset(struct sdhci_host *host, u8 mask) · 796 unmodified lines
797	sdhci_reset(host, mask);	797	sdhci_reset(host, mask);
798	}	798	}
799		799
		800	#define CMD_ERR_MASK (SDHCI_INT_CRC \| SDHCI_INT_END_BIT \| SDHCI_INT_INDEX \|\
		801	SDHCI_INT_TIMEOUT)
		802	#define CMD_MASK (CMD_ERR_MASK \| SDHCI_INT_RESPONSE)
		803
		804	static u32 sdhci_omap_irq(struct sdhci_host *host, u32 intmask)
		805	{
		806	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
		807	struct sdhci_omap_host *omap_host = sdhci_pltfm_priv(pltfm_host);
		808
		809	if (omap_host->is_tuning && host->cmd && !host->data_early &&
		810	(intmask & CMD_ERR_MASK)) {
		811
		812	/*
		813	* Since we are not resetting data lines during tuning
		814	* operation, data error or data complete interrupts
		815	* might still arrive. Mark this request as a failure
		816	* but still wait for the data interrupt
		817	*/
		818	if (intmask & SDHCI_INT_TIMEOUT)
		819	host->cmd->error = -ETIMEDOUT;
		820	else
		821	host->cmd->error = -EILSEQ;
		822
		823	host->cmd = NULL;
		824
		825	/*
		826	* Sometimes command error interrupts and command complete
		827	* interrupt will arrive together. Clear all command related
		828	* interrupts here.
		829	*/
		830	sdhci_writel(host, intmask & CMD_MASK, SDHCI_INT_STATUS);
		831	intmask &= ~CMD_MASK;
		832	}
		833
		834	return intmask;
		835	}
		836
800	static struct sdhci_ops sdhci_omap_ops = {	837	static struct sdhci_ops sdhci_omap_ops = {
801	.set_clock = sdhci_omap_set_clock,	838	.set_clock = sdhci_omap_set_clock,
802	.set_power = sdhci_omap_set_power,	839	.set_power = sdhci_omap_set_power,
@@ -807,6 +844,7 @@ static struct sdhci_ops sdhci_omap_ops = { · 4 unmodified lines
807	.platform_send_init_74_clocks = sdhci_omap_init_74_clocks,	844	.platform_send_init_74_clocks = sdhci_omap_init_74_clocks,
808	.reset = sdhci_omap_reset,	845	.reset = sdhci_omap_reset,
809	.set_uhs_signaling = sdhci_omap_set_uhs_signaling,	846	.set_uhs_signaling = sdhci_omap_set_uhs_signaling,
		847	.irq = sdhci_omap_irq,
810	};	848	};
811		849
812	static int sdhci_omap_set_capabilities(struct sdhci_omap_host *omap_host)	850	static int sdhci_omap_set_capabilities(struct sdhci_omap_host *omap_host)

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/bonding/bond_main.c+5−1

 		return NOTIFY_DONE;
 	if (event_dev->flags & IFF_MASTER) {
+		int ret;
 		netdev_dbg(event_dev, "IFF_MASTER\n");
-		return bond_master_netdev_event(event, event_dev);
+		ret = bond_master_netdev_event(event, event_dev);
+		if (ret != NOTIFY_DONE)
+			return ret;
 	}
 	if (event_dev->flags & IFF_SLAVE) {

drivers/net/bonding/bond_sysfs_slave.c+3−1

@@ -55,7 +55,9 @@ static SLAVE_ATTR_RO(link_failure_count); · 54 unmodified lines
55		55
56	static ssize_t perm_hwaddr_show(struct slave slave, char buf)	56	static ssize_t perm_hwaddr_show(struct slave slave, char buf)
57	{	57	{
58	return sprintf(buf, "%pM\n", slave->perm_hwaddr);	58	return sprintf(buf, "%*phC\n",
		59	slave->dev->addr_len,
		60	slave->perm_hwaddr);
59	}	61	}
60	static SLAVE_ATTR_RO(perm_hwaddr);	62	static SLAVE_ATTR_RO(perm_hwaddr);
61		63

drivers/net/dsa/mv88e6xxx/port.c+16−8

 		return 0;
 	lane = mv88e6390x_serdes_get_lane(chip, port);
-	if (lane < 0)
+	if (lane < 0 && lane != -ENODEV)
 		return lane;
-	if (chip->ports[port].serdes_irq) {
+	if (lane >= 0) {
-		err = mv88e6390_serdes_irq_disable(chip, port, lane);
+		if (chip->ports[port].serdes_irq) {
+			err = mv88e6390_serdes_irq_disable(chip, port, lane);
+			if (err)
+				return err;
+		}
+		err = mv88e6390x_serdes_power(chip, port, false);
 		if (err)
 			return err;
 	}
-	err = mv88e6390x_serdes_power(chip, port, false);
+	chip->ports[port].cmode = 0;
-	if (err)
-		return err;
 	if (cmode) {
 		err = mv88e6xxx_port_read(chip, port, MV88E6XXX_PORT_STS, &reg);
 		if (err)
 			return err;
+		chip->ports[port].cmode = cmode;
+		lane = mv88e6390x_serdes_get_lane(chip, port);
+		if (lane < 0)
+			return lane;
 		err = mv88e6390x_serdes_power(chip, port, true);
 		if (err)
 			return err;
 		}
 	}
-	chip->ports[port].cmode = cmode;
 	return 0;
 }

drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c+1−1

@@ -957,7 +957,7 @@ int bnx2x_vfpf_update_vlan(struct bnx2x *bp, u16 vid, u8 vf_qid, bool add) · 956 unmodified lines
957	bnx2x_sample_bulletin(bp);	957	bnx2x_sample_bulletin(bp);
958		958
959	if (bp->shadow_bulletin.content.valid_bitmap & 1 << VLAN_VALID) {	959	if (bp->shadow_bulletin.content.valid_bitmap & 1 << VLAN_VALID) {
960	BNX2X_ERR("Hypervisor will dicline the request, avoiding\n");	960	BNX2X_ERR("Hypervisor will decline the request, avoiding\n");
961	rc = -EINVAL;	961	rc = -EINVAL;
962	goto out;	962	goto out;
963	}	963	}

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/cavium/thunder/nicvf_main.c+32−10

 #define DRV_NAME	"nicvf"
 #define DRV_VERSION	"1.0"
+/* NOTE: Packets bigger than 1530 are split across multiple pages and XDP needs
+ * the buffer to be contiguous. Allow XDP to be set up only if we don't exceed
+ * this value, keeping headroom for the 14 byte Ethernet header and two
+ * VLAN tags (for QinQ)
+ */
+#define MAX_XDP_MTU	(1530 - ETH_HLEN - VLAN_HLEN * 2)
 /* Supported devices */
 static const struct pci_device_id nicvf_id_table[] = {
 	{ PCI_DEVICE_SUB(PCI_VENDOR_ID_CAVIUM,
 	struct nicvf_cq_poll *cq_poll = NULL;
 	union nic_mbx mbx = {};
-	cancel_delayed_work_sync(&nic->link_change_work);
 	/* wait till all queued set_rx_mode tasks completes */
-	drain_workqueue(nic->nicvf_rx_mode_wq);
+	if (nic->nicvf_rx_mode_wq) {
+		cancel_delayed_work_sync(&nic->link_change_work);
+		drain_workqueue(nic->nicvf_rx_mode_wq);
+	}
 	mbx.msg.msg = NIC_MBOX_MSG_SHUTDOWN;
 	nicvf_send_msg_to_pf(nic, &mbx);
 	struct nicvf_cq_poll *cq_poll = NULL;
 	/* wait till all queued set_rx_mode tasks completes if any */
-	drain_workqueue(nic->nicvf_rx_mode_wq);
+	if (nic->nicvf_rx_mode_wq)
+		drain_workqueue(nic->nicvf_rx_mode_wq);
 	netif_carrier_off(netdev);
 	/* Send VF config done msg to PF */
 	nicvf_send_cfg_done(nic);
-	INIT_DELAYED_WORK(&nic->link_change_work,
+	if (nic->nicvf_rx_mode_wq) {
-			  nicvf_link_status_check_task);
+		INIT_DELAYED_WORK(&nic->link_change_work,
-	queue_delayed_work(nic->nicvf_rx_mode_wq,
+				  nicvf_link_status_check_task);
-			   &nic->link_change_work, 0);
+		queue_delayed_work(nic->nicvf_rx_mode_wq,
+				   &nic->link_change_work, 0);
+	}
 	return 0;
 cleanup:
 	struct nicvf *nic = netdev_priv(netdev);
 	int orig_mtu = netdev->mtu;
+	/* For now just support only the usual MTU sized frames,
+	 * plus some headroom for VLAN, QinQ.
+	 */
+	if (nic->xdp_prog && new_mtu > MAX_XDP_MTU) {
+		netdev_warn(netdev, "Jumbo frames not yet supported with XDP, current MTU %d.\n",
+			    netdev->mtu);
+		return -EINVAL;
+	}
 	netdev->mtu = new_mtu;
 	if (!netif_running(netdev))
 	bool bpf_attached = false;
 	int ret = 0;
-	/* For now just support only the usual MTU sized frames */
+	/* For now just support only the usual MTU sized frames,
-	if (prog && (dev->mtu > 1500)) {
+	 * plus some headroom for VLAN, QinQ.
+	 */
+	if (prog && dev->mtu > MAX_XDP_MTU) {
 		netdev_warn(dev, "Jumbo frames not yet supported with XDP, current MTU %d.\n",
 			    dev->mtu);
 		return -EOPNOTSUPP;

drivers/net/ethernet/cavium/thunder/nicvf_queues.c+14−16

@@ -105,20 +105,19 @@ static inline struct pgcache nicvf_alloc_page(struct nicvf nic, · 104 unmodified lines
105	/* Check if page can be recycled */	105	/* Check if page can be recycled */
106	if (page) {	106	if (page) {
107	ref_count = page_ref_count(page);	107	ref_count = page_ref_count(page);
108	/* Check if this page has been used once i.e 'put_page'	108	/* This page can be recycled if internal ref_count and page's
109	* called after packet transmission i.e internal ref_count	109	* ref_count are equal, indicating that the page has been used
110	* and page's ref_count are equal i.e page can be recycled.	110	* once for packet transmission. For non-XDP mode, internal
		111	* ref_count is always '1'.
111	*/	112	*/
112	if (rbdr->is_xdp && (ref_count == pgcache->ref_count))	113	if (rbdr->is_xdp) {
113	pgcache->ref_count--;	114	if (ref_count == pgcache->ref_count)
114	else	115	pgcache->ref_count--;
115	page = NULL;	116	else
116		117	page = NULL;
117	/* In non-XDP mode, page's ref_count needs to be '1' for it	118	} else if (ref_count != 1) {
118	* to be recycled.
119	*/
120	if (!rbdr->is_xdp && (ref_count != 1))
121	page = NULL;	119	page = NULL;
		120	}
122	}	121	}
123		122
124	if (!page) {	123	if (!page) {
@@ -365,11 +364,10 @@ static void nicvf_free_rbdr(struct nicvf nic, struct rbdr rbdr) · 240 unmodified lines
365	while (head < rbdr->pgcnt) {	364	while (head < rbdr->pgcnt) {
366	pgcache = &rbdr->pgcache[head];	365	pgcache = &rbdr->pgcache[head];
367	if (pgcache->page && page_ref_count(pgcache->page) != 0) {	366	if (pgcache->page && page_ref_count(pgcache->page) != 0) {
368	if (!rbdr->is_xdp) {	367	if (rbdr->is_xdp) {
369	put_page(pgcache->page);	368	page_ref_sub(pgcache->page,
370	continue;	369	pgcache->ref_count - 1);
371	}	370	}
372	page_ref_sub(pgcache->page, pgcache->ref_count - 1);
373	put_page(pgcache->page);	371	put_page(pgcache->page);
374	}	372	}
375	head++;	373	head++;

drivers/net/ethernet/chelsio/libcxgb/libcxgb_ppm.c+8−1

 		ppmax = max;
 	/* pool size must be multiple of unsigned long */
-	bmap = BITS_TO_LONGS(ppmax);
+	bmap = ppmax / BITS_PER_TYPE(unsigned long);
+	if (!bmap)
+		return NULL;
 	ppmax = (bmap * sizeof(unsigned long)) << 3;
 	alloc_sz = sizeof(*pools) + sizeof(unsigned long) * bmap;
 	if (reserve_factor) {
 		ppmax_pool = ppmax / reserve_factor;
 		pool = ppm_alloc_cpu_pool(&ppmax_pool, &pool_index_max);
+		if (!pool) {
+			ppmax_pool = 0;
+			reserve_factor = 0;
+		}
 		pr_debug("%s: ppmax %u, cpu total %u, per cpu %u.\n",
 			 ndev->name, ppmax, ppmax_pool, pool_index_max);

drivers/net/ethernet/freescale/fec_main.c+21−9

 	int ret;
 	if (enable) {
-		ret = clk_prepare_enable(fep->clk_ahb);
-		if (ret)
-			return ret;
 		ret = clk_prepare_enable(fep->clk_enet_out);
 		if (ret)
-			goto failed_clk_enet_out;
+			return ret;
 		if (fep->clk_ptp) {
 			mutex_lock(&fep->ptp_clk_mutex);
 		phy_reset_after_clk_enable(ndev->phydev);
 	} else {
-		clk_disable_unprepare(fep->clk_ahb);
 		clk_disable_unprepare(fep->clk_enet_out);
 		if (fep->clk_ptp) {
 			mutex_lock(&fep->ptp_clk_mutex);
 failed_clk_ptp:
 	if (fep->clk_enet_out)
 		clk_disable_unprepare(fep->clk_enet_out);
-failed_clk_enet_out:
-		clk_disable_unprepare(fep->clk_ahb);
 	return ret;
 }
 	ret = clk_prepare_enable(fep->clk_ipg);
 	if (ret)
 		goto failed_clk_ipg;
+	ret = clk_prepare_enable(fep->clk_ahb);
+	if (ret)
+		goto failed_clk_ahb;
 	fep->reg_phy = devm_regulator_get_optional(&pdev->dev, "phy");
 	if (!IS_ERR(fep->reg_phy)) {
 	pm_runtime_put(&pdev->dev);
 	pm_runtime_disable(&pdev->dev);
 failed_regulator:
+	clk_disable_unprepare(fep->clk_ahb);
+failed_clk_ahb:
+	clk_disable_unprepare(fep->clk_ipg);
 failed_clk_ipg:
 	fec_enet_clk_enable(ndev, false);
 failed_clk:
 	struct net_device *ndev = dev_get_drvdata(dev);
 	struct fec_enet_private *fep = netdev_priv(ndev);
+	clk_disable_unprepare(fep->clk_ahb);
 	clk_disable_unprepare(fep->clk_ipg);
 	return 0;
 {
 	struct net_device *ndev = dev_get_drvdata(dev);
 	struct fec_enet_private *fep = netdev_priv(ndev);
+	int ret;
-	return clk_prepare_enable(fep->clk_ipg);
+	ret = clk_prepare_enable(fep->clk_ahb);
+	if (ret)
+		return ret;
+	ret = clk_prepare_enable(fep->clk_ipg);
+	if (ret)
+		goto failed_clk_ipg;
+	return 0;
+failed_clk_ipg:
+	clk_disable_unprepare(fep->clk_ahb);
+	return ret;
 }
 static const struct dev_pm_ops fec_pm_ops = {

drivers/net/ethernet/hisilicon/hns/hnae.c+3−1

 /* free desc along with its attached buffer */
 static void hnae_free_desc(struct hnae_ring *ring)
 {
-	hnae_free_buffers(ring);
 	dma_unmap_single(ring_to_dev(ring), ring->desc_dma_addr,
 			 ring->desc_num * sizeof(ring->desc[0]),
 			 ring_to_dma_dir(ring));
 /* fini ring, also free the buffer for the ring */
 static void hnae_fini_ring(struct hnae_ring *ring)
 {
+	if (is_rx_ring(ring))
+		hnae_free_buffers(ring);
 	hnae_free_desc(ring);
 	kfree(ring->desc_cb);
 	ring->desc_cb = NULL;

drivers/net/ethernet/hisilicon/hns/hnae.h+1−1

@@ -357,7 +357,7 @@ struct hnae_buf_ops { · 356 unmodified lines
357	};	357	};
358		358
359	struct hnae_queue {	359	struct hnae_queue {
360	void __iomem *io_base;	360	u8 __iomem *io_base;
361	phys_addr_t phy_base;	361	phys_addr_t phy_base;
362	struct hnae_ae_dev dev; / the device who use this queue */	362	struct hnae_ae_dev dev; / the device who use this queue */
363	struct hnae_ring rx_ring ____cacheline_internodealigned_in_smp;	363	struct hnae_ring rx_ring ____cacheline_internodealigned_in_smp;

drivers/net/ethernet/hisilicon/hns/hns_dsaf_mac.c+1−1

@@ -370,7 +370,7 @@ int hns_mac_clr_multicast(struct hns_mac_cb *mac_cb, int vfn) · 369 unmodified lines
370	static void hns_mac_param_get(struct mac_params *param,	370	static void hns_mac_param_get(struct mac_params *param,
371	struct hns_mac_cb *mac_cb)	371	struct hns_mac_cb *mac_cb)
372	{	372	{
373	param->vaddr = (void *)mac_cb->vaddr;	373	param->vaddr = mac_cb->vaddr;
374	param->mac_mode = hns_get_enet_interface(mac_cb);	374	param->mac_mode = hns_get_enet_interface(mac_cb);
375	ether_addr_copy(param->addr, mac_cb->addr_entry_idx[0].addr);	375	ether_addr_copy(param->addr, mac_cb->addr_entry_idx[0].addr);
376	param->mac_id = mac_cb->mac_id;	376	param->mac_id = mac_cb->mac_id;

drivers/net/ethernet/hisilicon/hns/hns_dsaf_mac.h+2−2

@@ -187,7 +187,7 @@ struct mac_statistics { · 186 unmodified lines
187	/mac para struct ,mac get param from nic or dsaf when initialize/	187	/mac para struct ,mac get param from nic or dsaf when initialize/
188	struct mac_params {	188	struct mac_params {
189	char addr[ETH_ALEN];	189	char addr[ETH_ALEN];
190	void vaddr; /virtual address*/	190	u8 __iomem vaddr; /virtual address*/
191	struct device *dev;	191	struct device *dev;
192	u8 mac_id;	192	u8 mac_id;
193	/*< Ethernet operation mode (MAC-PHY interface and speed) /	193	/*< Ethernet operation mode (MAC-PHY interface and speed) /
@@ -402,7 +402,7 @@ struct mac_driver { · 208 unmodified lines
402	enum mac_mode mac_mode;	402	enum mac_mode mac_mode;
403	u8 mac_id;	403	u8 mac_id;
404	struct hns_mac_cb *mac_cb;	404	struct hns_mac_cb *mac_cb;
405	void __iomem *io_base;	405	u8 __iomem *io_base;
406	unsigned int mac_en_flg;/you'd better don't enable mac twice/	406	unsigned int mac_en_flg;/you'd better don't enable mac twice/
407	unsigned int virt_dev_num;	407	unsigned int virt_dev_num;
408	struct device *dev;	408	struct device *dev;

drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c+33−20

 		       DSAF_TBL_TCAM_KEY_VLAN_S, vlan_id);
 	dsaf_set_field(mac_key->low.bits.port_vlan, DSAF_TBL_TCAM_KEY_PORT_M,
 		       DSAF_TBL_TCAM_KEY_PORT_S, port);
-	mac_key->low.bits.port_vlan = le16_to_cpu(mac_key->low.bits.port_vlan);
 }
 /**
 	/* default config dvc to 0 */
 	mac_data.tbl_ucast_dvc = 0;
 	mac_data.tbl_ucast_out_port = mac_entry->port_num;
-	tcam_data.tbl_tcam_data_high = cpu_to_le32(mac_key.high.val);
+	tcam_data.tbl_tcam_data_high = mac_key.high.val;
-	tcam_data.tbl_tcam_data_low = cpu_to_le32(mac_key.low.val);
+	tcam_data.tbl_tcam_data_low = mac_key.low.val;
 	hns_dsaf_tcam_uc_cfg(dsaf_dev, entry_index, &tcam_data, &mac_data);
 				     0xff,
 				     mc_mask);
-		mask_key.high.val = le32_to_cpu(mask_key.high.val);
-		mask_key.low.val = le32_to_cpu(mask_key.low.val);
 		pmask_key = (struct dsaf_tbl_tcam_data *)(&mask_key);
 	}
 		dsaf_dev->ae_dev.name, mac_key.high.val,
 		mac_key.low.val, entry_index);
-	tcam_data.tbl_tcam_data_high = cpu_to_le32(mac_key.high.val);
+	tcam_data.tbl_tcam_data_high = mac_key.high.val;
-	tcam_data.tbl_tcam_data_low = cpu_to_le32(mac_key.low.val);
+	tcam_data.tbl_tcam_data_low = mac_key.low.val;
 	/* config mc entry with mask */
 	hns_dsaf_tcam_mc_cfg(dsaf_dev, entry_index, &tcam_data,
 		/* config key mask */
 		hns_dsaf_set_mac_key(dsaf_dev, &mask_key, 0x00, 0xff, mc_mask);
-		mask_key.high.val = le32_to_cpu(mask_key.high.val);
-		mask_key.low.val = le32_to_cpu(mask_key.low.val);
 		pmask_key = (struct dsaf_tbl_tcam_data *)(&mask_key);
 	}
 		soft_mac_entry += entry_index;
 		soft_mac_entry->index = DSAF_INVALID_ENTRY_IDX;
 	} else { /* not zero, just del port, update */
-		tcam_data.tbl_tcam_data_high = cpu_to_le32(mac_key.high.val);
+		tcam_data.tbl_tcam_data_high = mac_key.high.val;
-		tcam_data.tbl_tcam_data_low = cpu_to_le32(mac_key.low.val);
+		tcam_data.tbl_tcam_data_low = mac_key.low.val;
 		hns_dsaf_tcam_mc_cfg(dsaf_dev, entry_index,
 				     &tcam_data,
 	return DSAF_DUMP_REGS_NUM;
 }
+static int hns_dsaf_get_port_id(u8 port)
+{
+	if (port < DSAF_SERVICE_NW_NUM)
+		return port;
+	if (port >= DSAF_BASE_INNER_PORT_NUM)
+		return port - DSAF_BASE_INNER_PORT_NUM + DSAF_SERVICE_NW_NUM;
+	return -EINVAL;
+}
 static void set_promisc_tcam_enable(struct dsaf_device *dsaf_dev, u32 port)
 {
 	struct dsaf_tbl_tcam_ucast_cfg tbl_tcam_ucast = {0, 1, 0, 0, 0x80};
 	memset(&temp_key, 0x0, sizeof(temp_key));
 	mask_entry.addr[0] = 0x01;
 	hns_dsaf_set_mac_key(dsaf_dev, &mask_key, mask_entry.in_vlan_id,
-			     port, mask_entry.addr);
+			     0xf, mask_entry.addr);
 	tbl_tcam_mcast.tbl_mcast_item_vld = 1;
 	tbl_tcam_mcast.tbl_mcast_old_en = 0;
-	if (port < DSAF_SERVICE_NW_NUM) {
+	/* set MAC port to handle multicast */
-		mskid = port;
+	mskid = hns_dsaf_get_port_id(port);
-	} else if (port >= DSAF_BASE_INNER_PORT_NUM) {
+	if (mskid == -EINVAL) {
-		mskid = port - DSAF_BASE_INNER_PORT_NUM + DSAF_SERVICE_NW_NUM;
-	} else {
 		dev_err(dsaf_dev->dev, "%s,pnum(%d)error,key(%#x:%#x)\n",
 			dsaf_dev->ae_dev.name, port,
 			mask_key.high.val, mask_key.low.val);
 		return;
 	}
+	dsaf_set_bit(tbl_tcam_mcast.tbl_mcast_port_msk[mskid / 32],
+		     mskid % 32, 1);
+	/* set pool bit map to handle multicast */
+	mskid = hns_dsaf_get_port_id(port_num);
+	if (mskid == -EINVAL) {
+		dev_err(dsaf_dev->dev,
+			"%s, pool bit map pnum(%d)error,key(%#x:%#x)\n",
+			dsaf_dev->ae_dev.name, port_num,
+			mask_key.high.val, mask_key.low.val);
+		return;
+	}
 	dsaf_set_bit(tbl_tcam_mcast.tbl_mcast_port_msk[mskid / 32],
 		     mskid % 32, 1);
 	memcpy(&temp_key, &mask_key, sizeof(mask_key));
 	hns_dsaf_tcam_mc_cfg_vague(dsaf_dev, entry_index, &tbl_tcam_data_mc,
 				   (struct dsaf_tbl_tcam_data *)(&mask_key),

drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.h+2−0

@@ -467,4 +467,6 @@ int hns_dsaf_clr_mac_mc_port(struct dsaf_device *dsaf_dev, · 466 unmodified lines
467	u8 mac_id, u8 port_num);	467	u8 mac_id, u8 port_num);
468	int hns_dsaf_wait_pkt_clean(struct dsaf_device *dsaf_dev, int port);	468	int hns_dsaf_wait_pkt_clean(struct dsaf_device *dsaf_dev, int port);
469		469
		470	int hns_dsaf_roce_reset(struct fwnode_handle *dsaf_fwnode, bool dereset);
		471
470	#endif /* __HNS_DSAF_MAIN_H__ */	472	#endif /* __HNS_DSAF_MAIN_H__ */

drivers/net/ethernet/hisilicon/hns/hns_dsaf_misc.c+1−1

@@ -670,7 +670,7 @@ static int hns_mac_config_sds_loopback(struct hns_mac_cb *mac_cb, bool en) · 669 unmodified lines
670	dsaf_set_field(origin, 1ull << 10, 10, en);	670	dsaf_set_field(origin, 1ull << 10, 10, en);
671	dsaf_write_syscon(mac_cb->serdes_ctrl, reg_offset, origin);	671	dsaf_write_syscon(mac_cb->serdes_ctrl, reg_offset, origin);
672	} else {	672	} else {
673	u8 base_addr = (u8 )mac_cb->serdes_vaddr +	673	u8 __iomem *base_addr = mac_cb->serdes_vaddr +
674	(mac_cb->mac_id <= 3 ? 0x00280000 : 0x00200000);	674	(mac_cb->mac_id <= 3 ? 0x00280000 : 0x00200000);
675	dsaf_set_reg_field(base_addr, reg_offset, 1ull << 10, 10, en);	675	dsaf_set_reg_field(base_addr, reg_offset, 1ull << 10, 10, en);
676	}	676	}

drivers/net/ethernet/hisilicon/hns/hns_dsaf_ppe.c+3−3

@@ -61,7 +61,7 @@ void hns_ppe_set_indir_table(struct hns_ppe_cb *ppe_cb, · 60 unmodified lines
61	}	61	}
62	}	62	}
63		63
64	static void __iomem *	64	static u8 __iomem *
65	hns_ppe_common_get_ioaddr(struct ppe_common_cb *ppe_common)	65	hns_ppe_common_get_ioaddr(struct ppe_common_cb *ppe_common)
66	{	66	{
67	return ppe_common->dsaf_dev->ppe_base + PPE_COMMON_REG_OFFSET;	67	return ppe_common->dsaf_dev->ppe_base + PPE_COMMON_REG_OFFSET;
@@ -111,8 +111,8 @@ hns_ppe_common_free_cfg(struct dsaf_device *dsaf_dev, u32 comm_index) · 43 unmodified lines
111	dsaf_dev->ppe_common[comm_index] = NULL;	111	dsaf_dev->ppe_common[comm_index] = NULL;
112	}	112	}
113		113
114	static void __iomem hns_ppe_get_iobase(struct ppe_common_cb ppe_common,	114	static u8 __iomem hns_ppe_get_iobase(struct ppe_common_cb ppe_common,
115	int ppe_idx)	115	int ppe_idx)
116	{	116	{
117	return ppe_common->dsaf_dev->ppe_base + ppe_idx * PPE_REG_OFFSET;	117	return ppe_common->dsaf_dev->ppe_base + ppe_idx * PPE_REG_OFFSET;
118	}	118	}

drivers/net/ethernet/hisilicon/hns/hns_dsaf_ppe.h+2−2

@@ -80,7 +80,7 @@ struct hns_ppe_cb { · 79 unmodified lines
80	struct hns_ppe_hw_stats hw_stats;	80	struct hns_ppe_hw_stats hw_stats;
81		81
82	u8 index; /* index in a ppe common device */	82	u8 index; /* index in a ppe common device */
83	void __iomem *io_base;	83	u8 __iomem *io_base;
84	int virq;	84	int virq;
85	u32 rss_indir_table[HNS_PPEV2_RSS_IND_TBL_SIZE]; /shadow indir tab /	85	u32 rss_indir_table[HNS_PPEV2_RSS_IND_TBL_SIZE]; /shadow indir tab /
86	u32 rss_key[HNS_PPEV2_RSS_KEY_NUM]; /* rss hash key */	86	u32 rss_key[HNS_PPEV2_RSS_KEY_NUM]; /* rss hash key */
@@ -89,7 +89,7 @@ struct hns_ppe_cb { · 2 unmodified lines
89	struct ppe_common_cb {	89	struct ppe_common_cb {
90	struct device *dev;	90	struct device *dev;
91	struct dsaf_device *dsaf_dev;	91	struct dsaf_device *dsaf_dev;
92	void __iomem *io_base;	92	u8 __iomem *io_base;
93		93
94	enum ppe_common_mode ppe_mode;	94	enum ppe_common_mode ppe_mode;
95		95

drivers/net/ethernet/hisilicon/hns/hns_dsaf_rcb.c+2−2

@@ -458,7 +458,7 @@ static void hns_rcb_ring_get_cfg(struct hnae_queue *q, int ring_type) · 457 unmodified lines
458	mdnum_ppkt = HNS_RCB_RING_MAX_BD_PER_PKT;	458	mdnum_ppkt = HNS_RCB_RING_MAX_BD_PER_PKT;
459	} else {	459	} else {
460	ring = &q->tx_ring;	460	ring = &q->tx_ring;
461	ring->io_base = (u8 __iomem *)ring_pair_cb->q.io_base +	461	ring->io_base = ring_pair_cb->q.io_base +
462	HNS_RCB_TX_REG_OFFSET;	462	HNS_RCB_TX_REG_OFFSET;
463	irq_idx = HNS_RCB_IRQ_IDX_TX;	463	irq_idx = HNS_RCB_IRQ_IDX_TX;
464	mdnum_ppkt = is_ver1 ? HNS_RCB_RING_MAX_TXBD_PER_PKT :	464	mdnum_ppkt = is_ver1 ? HNS_RCB_RING_MAX_TXBD_PER_PKT :
@@ -764,7 +764,7 @@ static int hns_rcb_get_ring_num(struct dsaf_device *dsaf_dev) · 299 unmodified lines
764	}	764	}
765	}	765	}
766		766
767	static void __iomem hns_rcb_common_get_vaddr(struct rcb_common_cb rcb_common)	767	static u8 __iomem hns_rcb_common_get_vaddr(struct rcb_common_cb rcb_common)
768	{	768	{
769	struct dsaf_device *dsaf_dev = rcb_common->dsaf_dev;	769	struct dsaf_device *dsaf_dev = rcb_common->dsaf_dev;
770		770

drivers/net/ethernet/hisilicon/hns/hns_dsaf_reg.h+6−6

@@ -1018,7 +1018,7 @@ · 1017 unmodified lines
1018	#define XGMAC_PAUSE_CTL_RSP_MODE_B 2	1018	#define XGMAC_PAUSE_CTL_RSP_MODE_B 2
1019	#define XGMAC_PAUSE_CTL_TX_XOFF_B 3	1019	#define XGMAC_PAUSE_CTL_TX_XOFF_B 3
1020		1020
1021	static inline void dsaf_write_reg(void __iomem *base, u32 reg, u32 value)	1021	static inline void dsaf_write_reg(u8 __iomem *base, u32 reg, u32 value)
1022	{	1022	{
1023	writel(value, base + reg);	1023	writel(value, base + reg);
1024	}	1024	}
@@ -1053,7 +1053,7 @@ static inline int dsaf_read_syscon(struct regmap base, u32 reg, u32 val) · 28 unmodified lines
1053	#define dsaf_set_bit(origin, shift, val) \	1053	#define dsaf_set_bit(origin, shift, val) \
1054	dsaf_set_field((origin), (1ull << (shift)), (shift), (val))	1054	dsaf_set_field((origin), (1ull << (shift)), (shift), (val))
1055		1055
1056	static inline void dsaf_set_reg_field(void __iomem *base, u32 reg, u32 mask,	1056	static inline void dsaf_set_reg_field(u8 __iomem *base, u32 reg, u32 mask,
1057	u32 shift, u32 val)	1057	u32 shift, u32 val)
1058	{	1058	{
1059	u32 origin = dsaf_read_reg(base, reg);	1059	u32 origin = dsaf_read_reg(base, reg);
@@ -1073,7 +1073,7 @@ static inline void dsaf_set_reg_field(void __iomem *base, u32 reg, u32 mask, · 13 unmodified lines
1073	#define dsaf_get_bit(origin, shift) \	1073	#define dsaf_get_bit(origin, shift) \
1074	dsaf_get_field((origin), (1ull << (shift)), (shift))	1074	dsaf_get_field((origin), (1ull << (shift)), (shift))
1075		1075
1076	static inline u32 dsaf_get_reg_field(void __iomem *base, u32 reg, u32 mask,	1076	static inline u32 dsaf_get_reg_field(u8 __iomem *base, u32 reg, u32 mask,
1077	u32 shift)	1077	u32 shift)
1078	{	1078	{
1079	u32 origin;	1079	u32 origin;
@@ -1089,11 +1089,11 @@ static inline u32 dsaf_get_reg_field(void __iomem *base, u32 reg, u32 mask, · 9 unmodified lines
1089	dsaf_get_reg_field((dev)->io_base, (reg), (1ull << (bit)), (bit))	1089	dsaf_get_reg_field((dev)->io_base, (reg), (1ull << (bit)), (bit))
1090		1090
1091	#define dsaf_write_b(addr, data)\	1091	#define dsaf_write_b(addr, data)\
1092	writeb((data), (__iomem unsigned char *)(addr))	1092	writeb((data), (__iomem u8 *)(addr))
1093	#define dsaf_read_b(addr)\	1093	#define dsaf_read_b(addr)\
1094	readb((__iomem unsigned char *)(addr))	1094	readb((__iomem u8 *)(addr))
1095		1095
1096	#define hns_mac_reg_read64(drv, offset) \	1096	#define hns_mac_reg_read64(drv, offset) \
1097	readq((__iomem void )(((u8 )(drv)->io_base + 0xc00 + (offset))))	1097	readq((__iomem void *)(((drv)->io_base + 0xc00 + (offset))))
1098		1098
1099	#endif /* _DSAF_REG_H */	1099	#endif /* _DSAF_REG_H */

drivers/net/ethernet/hisilicon/hns/hns_dsaf_xgmac.c+1−1

@@ -129,7 +129,7 @@ static void hns_xgmac_lf_rf_control_init(struct mac_driver *mac_drv) · 128 unmodified lines
129	dsaf_set_bit(val, XGMAC_UNIDIR_EN_B, 0);	129	dsaf_set_bit(val, XGMAC_UNIDIR_EN_B, 0);
130	dsaf_set_bit(val, XGMAC_RF_TX_EN_B, 1);	130	dsaf_set_bit(val, XGMAC_RF_TX_EN_B, 1);
131	dsaf_set_field(val, XGMAC_LF_RF_INSERT_M, XGMAC_LF_RF_INSERT_S, 0);	131	dsaf_set_field(val, XGMAC_LF_RF_INSERT_M, XGMAC_LF_RF_INSERT_S, 0);
132	dsaf_write_reg(mac_drv, XGMAC_MAC_TX_LF_RF_CONTROL_REG, val);	132	dsaf_write_dev(mac_drv, XGMAC_MAC_TX_LF_RF_CONTROL_REG, val);
133	}	133	}
134		134
135	/**	135	/**

drivers/net/ethernet/hisilicon/hns/hns_enet.c+5−7

 #define SERVICE_TIMER_HZ (1 * HZ)
-#define NIC_TX_CLEAN_MAX_NUM 256
-#define NIC_RX_CLEAN_MAX_NUM 64
 #define RCB_IRQ_NOT_INITED 0
 #define RCB_IRQ_INITED 1
 #define HNS_BUFFER_SIZE_2048 2048
 	wmb(); /* commit all data before submit */
 	assert(skb->queue_mapping < priv->ae_handle->q_num);
 	hnae_queue_xmit(priv->ae_handle->qs[skb->queue_mapping], buf_num);
-	ring->stats.tx_pkts++;
-	ring->stats.tx_bytes += skb->len;
 	return NETDEV_TX_OK;
 		/* issue prefetch for next Tx descriptor */
 		prefetch(&ring->desc_cb[ring->next_to_clean]);
 	}
+	/* update tx ring statistics. */
+	ring->stats.tx_pkts += pkts;
+	ring->stats.tx_bytes += bytes;
 	NETIF_TX_UNLOCK(ring);
 			hns_nic_tx_fini_pro_v2;
 		netif_napi_add(priv->netdev, &rd->napi,
-			       hns_nic_common_poll, NIC_TX_CLEAN_MAX_NUM);
+			       hns_nic_common_poll, NAPI_POLL_WEIGHT);
 		rd->ring->irq_init_flag = RCB_IRQ_NOT_INITED;
 	}
 	for (i = h->q_num; i < h->q_num * 2; i++) {
 			hns_nic_rx_fini_pro_v2;
 		netif_napi_add(priv->netdev, &rd->napi,
-			       hns_nic_common_poll, NIC_RX_CLEAN_MAX_NUM);
+			       hns_nic_common_poll, NAPI_POLL_WEIGHT);
 		rd->ring->irq_init_flag = RCB_IRQ_NOT_INITED;
 	}

drivers/net/ethernet/hisilicon/hns3/hns3pf/Makefile+1−1

@@ -3,7 +3,7 @@ · 2 unmodified lines
3	# Makefile for the HISILICON network device drivers.	3	# Makefile for the HISILICON network device drivers.
4	#	4	#
5		5
6	ccflags-y := -Idrivers/net/ethernet/hisilicon/hns3	6	ccflags-y := -I $(srctree)/drivers/net/ethernet/hisilicon/hns3
7		7
8	obj-$(CONFIG_HNS3_HCLGE) += hclge.o	8	obj-$(CONFIG_HNS3_HCLGE) += hclge.o
9	hclge-objs = hclge_main.o hclge_cmd.o hclge_mdio.o hclge_tm.o hclge_mbx.o hclge_err.o hclge_debugfs.o	9	hclge-objs = hclge_main.o hclge_cmd.o hclge_mdio.o hclge_tm.o hclge_mbx.o hclge_err.o hclge_debugfs.o

drivers/net/ethernet/hisilicon/hns3/hns3vf/Makefile+1−1

@@ -3,7 +3,7 @@ · 2 unmodified lines
3	# Makefile for the HISILICON network device drivers.	3	# Makefile for the HISILICON network device drivers.
4	#	4	#
5		5
6	ccflags-y := -Idrivers/net/ethernet/hisilicon/hns3	6	ccflags-y := -I $(srctree)/drivers/net/ethernet/hisilicon/hns3
7		7
8	obj-$(CONFIG_HNS3_HCLGEVF) += hclgevf.o	8	obj-$(CONFIG_HNS3_HCLGEVF) += hclgevf.o
9	hclgevf-objs = hclgevf_main.o hclgevf_cmd.o hclgevf_mbx.o	9	hclgevf-objs = hclgevf_main.o hclgevf_cmd.o hclgevf_mbx.o

drivers/net/ethernet/hisilicon/hns_mdio.c+7−11

 };
 struct hns_mdio_device {
-	void *vbase;		/* mdio reg base address */
+	u8 __iomem *vbase;		/* mdio reg base address */
 	struct regmap *subctrl_vbase;
 	struct hns_mdio_sc_reg sc_reg;
 };
 #define MDIO_SC_CLK_ST		0x531C
 #define MDIO_SC_RESET_ST	0x5A1C
-static void mdio_write_reg(void *base, u32 reg, u32 value)
+static void mdio_write_reg(u8 __iomem *base, u32 reg, u32 value)
 {
-	u8 __iomem *reg_addr = (u8 __iomem *)base;
+	writel_relaxed(value, base + reg);
-	writel_relaxed(value, reg_addr + reg);
 }
 #define MDIO_WRITE_REG(a, reg, value) \
 	mdio_write_reg((a)->vbase, (reg), (value))
-static u32 mdio_read_reg(void *base, u32 reg)
+static u32 mdio_read_reg(u8 __iomem *base, u32 reg)
 {
-	u8 __iomem *reg_addr = (u8 __iomem *)base;
+	return readl_relaxed(base + reg);
-	return readl_relaxed(reg_addr + reg);
 }
 #define mdio_set_field(origin, mask, shift, val) \
 #define mdio_get_field(origin, mask, shift) (((origin) >> (shift)) & (mask))
-static void mdio_set_reg_field(void *base, u32 reg, u32 mask, u32 shift,
+static void mdio_set_reg_field(u8 __iomem *base, u32 reg, u32 mask, u32 shift,
 			       u32 val)
 {
 	u32 origin = mdio_read_reg(base, reg);
 #define MDIO_SET_REG_FIELD(dev, reg, mask, shift, val) \
 	mdio_set_reg_field((dev)->vbase, (reg), (mask), (shift), (val))
-static u32 mdio_get_reg_field(void *base, u32 reg, u32 mask, u32 shift)
+static u32 mdio_get_reg_field(u8 __iomem *base, u32 reg, u32 mask, u32 shift)
 {
 	u32 origin;

drivers/net/ethernet/ibm/ibmvnic.c+28−9

 	 */
 	adapter->state = VNIC_PROBED;
+	reinit_completion(&adapter->init_done);
 	rc = init_crq_queue(adapter);
 	if (rc) {
 		netdev_err(adapter->netdev,
 {
 	struct device *dev = &adapter->vdev->dev;
 	struct ibmvnic_query_ip_offload_buffer *buf = &adapter->ip_offload_buf;
+	netdev_features_t old_hw_features = 0;
 	union ibmvnic_crq crq;
 	int i;
 	adapter->ip_offload_ctrl.large_rx_ipv4 = 0;
 	adapter->ip_offload_ctrl.large_rx_ipv6 = 0;
-	adapter->netdev->features = NETIF_F_SG | NETIF_F_GSO;
+	if (adapter->state != VNIC_PROBING) {
+		old_hw_features = adapter->netdev->hw_features;
+		adapter->netdev->hw_features = 0;
+	}
+	adapter->netdev->hw_features = NETIF_F_SG | NETIF_F_GSO | NETIF_F_GRO;
 	if (buf->tcp_ipv4_chksum || buf->udp_ipv4_chksum)
-		adapter->netdev->features |= NETIF_F_IP_CSUM;
+		adapter->netdev->hw_features |= NETIF_F_IP_CSUM;
 	if (buf->tcp_ipv6_chksum || buf->udp_ipv6_chksum)
-		adapter->netdev->features |= NETIF_F_IPV6_CSUM;
+		adapter->netdev->hw_features |= NETIF_F_IPV6_CSUM;
 	if ((adapter->netdev->features &
 	    (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM)))
-		adapter->netdev->features |= NETIF_F_RXCSUM;
+		adapter->netdev->hw_features |= NETIF_F_RXCSUM;
 	if (buf->large_tx_ipv4)
-		adapter->netdev->features |= NETIF_F_TSO;
+		adapter->netdev->hw_features |= NETIF_F_TSO;
 	if (buf->large_tx_ipv6)
-		adapter->netdev->features |= NETIF_F_TSO6;
+		adapter->netdev->hw_features |= NETIF_F_TSO6;
+	if (adapter->state == VNIC_PROBING) {
+		adapter->netdev->features |= adapter->netdev->hw_features;
+	} else if (old_hw_features != adapter->netdev->hw_features) {
+		netdev_features_t tmp = 0;
-	adapter->netdev->hw_features |= adapter->netdev->features;
+		/* disable features no longer supported */
+		adapter->netdev->features &= adapter->netdev->hw_features;
+		/* turn on features now supported if previously enabled */
+		tmp = (old_hw_features ^ adapter->netdev->hw_features) &
+			adapter->netdev->hw_features;
+		adapter->netdev->features |=
+				tmp & adapter->netdev->wanted_features;
+	}
 	memset(&crq, 0, sizeof(crq));
 	crq.control_ip_offload.first = IBMVNIC_CRQ_CMD;
 	old_num_rx_queues = adapter->req_rx_queues;
 	old_num_tx_queues = adapter->req_tx_queues;
-	init_completion(&adapter->init_done);
+	reinit_completion(&adapter->init_done);
 	adapter->init_done_rc = 0;
 	ibmvnic_send_crq_init(adapter);
 	if (!wait_for_completion_timeout(&adapter->init_done, timeout)) {
 	adapter->from_passive_init = false;
-	init_completion(&adapter->init_done);
 	adapter->init_done_rc = 0;
 	ibmvnic_send_crq_init(adapter);
 	if (!wait_for_completion_timeout(&adapter->init_done, timeout)) {
 	INIT_WORK(&adapter->ibmvnic_reset, __ibmvnic_reset);
 	INIT_LIST_HEAD(&adapter->rwi_list);
 	spin_lock_init(&adapter->rwi_lock);
+	init_completion(&adapter->init_done);
 	adapter->resetting = false;
 	adapter->mac_change_pending = false;

drivers/net/ethernet/intel/fm10k/fm10k_main.c+2−0

@@ -41,6 +41,8 @@ static int __init fm10k_init_module(void) · 40 unmodified lines
41	/* create driver workqueue */	41	/* create driver workqueue */
42	fm10k_workqueue = alloc_workqueue("%s", WQ_MEM_RECLAIM, 0,	42	fm10k_workqueue = alloc_workqueue("%s", WQ_MEM_RECLAIM, 0,
43	fm10k_driver_name);	43	fm10k_driver_name);
		44	if (!fm10k_workqueue)
		45	return -ENOMEM;
44		46
45	fm10k_dbg_init();	47	fm10k_dbg_init();
46		48

drivers/net/ethernet/intel/i40e/i40e.h+2−14

 	/* VSI specific handlers */
 	irqreturn_t (*irq_handler)(int irq, void *data);
+	unsigned long *af_xdp_zc_qps; /* tracks AF_XDP ZC enabled qps */
 } ____cacheline_internodealigned_in_smp;
 struct i40e_netdev_priv {
 	return !!vsi->xdp_prog;
 }
-static inline struct xdp_umem *i40e_xsk_umem(struct i40e_ring *ring)
-{
-	bool xdp_on = i40e_enabled_xdp_vsi(ring->vsi);
-	int qid = ring->queue_index;
-	if (ring_is_xdp(ring))
-		qid -= ring->vsi->alloc_queue_pairs;
-	if (!xdp_on)
-		return NULL;
-	return xdp_get_umem_from_qid(ring->vsi->netdev, qid);
-}
 int i40e_create_queue_channel(struct i40e_vsi *vsi, struct i40e_channel *ch);
 int i40e_set_bw_limit(struct i40e_vsi *vsi, u16 seid, u64 max_tx_rate);
 int i40e_add_del_cloud_filter(struct i40e_vsi *vsi,

drivers/net/ethernet/intel/i40e/i40e_ethtool.c+1−2

@@ -2573,8 +2573,7 @@ static int i40e_set_wol(struct net_device netdev, struct ethtool_wolinfo wol) · 2572 unmodified lines
2573	return -EOPNOTSUPP;	2573	return -EOPNOTSUPP;
2574		2574
2575	/* only magic packet is supported */	2575	/* only magic packet is supported */
2576	if (wol->wolopts && (wol->wolopts != WAKE_MAGIC)	2576	if (wol->wolopts & ~WAKE_MAGIC)
2577	\| (wol->wolopts != WAKE_FILTER))
2578	return -EOPNOTSUPP;	2577	return -EOPNOTSUPP;
2579		2578
2580	/* is this a new value? */	2579	/* is this a new value? */

drivers/net/ethernet/intel/i40e/i40e_main.c+28−0

@@ -3063,6 +3063,26 @@ static void i40e_config_xps_tx_ring(struct i40e_ring *ring) · 3062 unmodified lines
3063	ring->queue_index);	3063	ring->queue_index);
3064	}	3064	}
3065		3065
		3066	/**
		3067	* i40e_xsk_umem - Retrieve the AF_XDP ZC if XDP and ZC is enabled
		3068	* @ring: The Tx or Rx ring
		3069	*
		3070	* Returns the UMEM or NULL.
		3071	**/
		3072	static struct xdp_umem i40e_xsk_umem(struct i40e_ring ring)
		3073	{
		3074	bool xdp_on = i40e_enabled_xdp_vsi(ring->vsi);
		3075	int qid = ring->queue_index;
		3076
		3077	if (ring_is_xdp(ring))
		3078	qid -= ring->vsi->alloc_queue_pairs;
		3079
		3080	if (!xdp_on \|\| !test_bit(qid, ring->vsi->af_xdp_zc_qps))
		3081	return NULL;
		3082
		3083	return xdp_get_umem_from_qid(ring->vsi->netdev, qid);
		3084	}
		3085
3066	/**	3086	/**
3067	* i40e_configure_tx_ring - Configure a transmit ring context and rest	3087	* i40e_configure_tx_ring - Configure a transmit ring context and rest
3068	* @ring: The Tx ring to configure	3088	* @ring: The Tx ring to configure
@@ -10064,6 +10084,12 @@ static int i40e_vsi_mem_alloc(struct i40e_pf *pf, enum i40e_vsi_type type) · 6995 unmodified lines
10064	hash_init(vsi->mac_filter_hash);	10084	hash_init(vsi->mac_filter_hash);
10065	vsi->irqs_ready = false;	10085	vsi->irqs_ready = false;
10066		10086
		10087	if (type == I40E_VSI_MAIN) {
		10088	vsi->af_xdp_zc_qps = bitmap_zalloc(pf->num_lan_qps, GFP_KERNEL);
		10089	if (!vsi->af_xdp_zc_qps)
		10090	goto err_rings;
		10091	}
		10092
10067	ret = i40e_set_num_rings_in_vsi(vsi);	10093	ret = i40e_set_num_rings_in_vsi(vsi);
10068	if (ret)	10094	if (ret)
10069	goto err_rings;	10095	goto err_rings;
@@ -10082,6 +10108,7 @@ static int i40e_vsi_mem_alloc(struct i40e_pf *pf, enum i40e_vsi_type type) · 12 unmodified lines
10082	goto unlock_pf;	10108	goto unlock_pf;
10083		10109
10084	err_rings:	10110	err_rings:
		10111	bitmap_free(vsi->af_xdp_zc_qps);
10085	pf->next_vsi = i - 1;	10112	pf->next_vsi = i - 1;
10086	kfree(vsi);	10113	kfree(vsi);
10087	unlock_pf:	10114	unlock_pf:
@@ -10162,6 +10189,7 @@ static int i40e_vsi_clear(struct i40e_vsi *vsi) · 74 unmodified lines
10162	i40e_put_lump(pf->qp_pile, vsi->base_queue, vsi->idx);	10189	i40e_put_lump(pf->qp_pile, vsi->base_queue, vsi->idx);
10163	i40e_put_lump(pf->irq_pile, vsi->base_vector, vsi->idx);	10190	i40e_put_lump(pf->irq_pile, vsi->base_vector, vsi->idx);
10164		10191
		10192	bitmap_free(vsi->af_xdp_zc_qps);
10165	i40e_vsi_free_arrays(vsi, true);	10193	i40e_vsi_free_arrays(vsi, true);
10166	i40e_clear_rss_config_user(vsi);	10194	i40e_clear_rss_config_user(vsi);
10167		10195

drivers/net/ethernet/intel/i40e/i40e_ptp.c+3−2

 static int i40e_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta)
 {
 	struct i40e_pf *pf = container_of(ptp, struct i40e_pf, ptp_caps);
-	struct timespec64 now;
+	struct timespec64 now, then;
+	then = ns_to_timespec64(delta);
 	mutex_lock(&pf->tmreg_lock);
 	i40e_ptp_read(pf, &now, NULL);
-	timespec64_add_ns(&now, delta);
+	now = timespec64_add(now, then);
 	i40e_ptp_write(pf, (const struct timespec64 *)&now);
 	mutex_unlock(&pf->tmreg_lock);

drivers/net/ethernet/intel/i40e/i40e_xsk.c+3−0

 	if (err)
 		return err;
+	set_bit(qid, vsi->af_xdp_zc_qps);
 	if_running = netif_running(vsi->netdev) && i40e_enabled_xdp_vsi(vsi);
 	if (if_running) {
 			return err;
 	}
+	clear_bit(qid, vsi->af_xdp_zc_qps);
 	i40e_xsk_umem_dma_unmap(vsi, umem);
 	if (if_running) {

drivers/net/ethernet/intel/igb/e1000_defines.h+2−0

 /* enable link status from external LINK_0 and LINK_1 pins */
 #define E1000_CTRL_SWDPIN0  0x00040000  /* SWDPIN 0 value */
 #define E1000_CTRL_SWDPIN1  0x00080000  /* SWDPIN 1 value */
+#define E1000_CTRL_ADVD3WUC 0x00100000  /* D3 WUC */
+#define E1000_CTRL_EN_PHY_PWR_MGMT 0x00200000 /* PHY PM enable */
 #define E1000_CTRL_SDP0_DIR 0x00400000  /* SDP0 Data direction */
 #define E1000_CTRL_SDP1_DIR 0x00800000  /* SDP1 Data direction */
 #define E1000_CTRL_RST      0x04000000  /* Global reset */

drivers/net/ethernet/intel/igb/igb_main.c+8−49

 	struct e1000_hw *hw = &adapter->hw;
 	u32 ctrl, rctl, status;
 	u32 wufc = runtime ? E1000_WUFC_LNKC : adapter->wol;
-#ifdef CONFIG_PM
+	bool wake;
-	int retval = 0;
-#endif
 	rtnl_lock();
 	netif_device_detach(netdev);
 	igb_clear_interrupt_scheme(adapter);
 	rtnl_unlock();
-#ifdef CONFIG_PM
-	if (!runtime) {
-		retval = pci_save_state(pdev);
-		if (retval)
-			return retval;
-	}
-#endif
 	status = rd32(E1000_STATUS);
 	if (status & E1000_STATUS_LU)
 		wufc &= ~E1000_WUFC_LNKC;
 		}
 		ctrl = rd32(E1000_CTRL);
-		/* advertise wake from D3Cold */
-		#define E1000_CTRL_ADVD3WUC 0x00100000
-		/* phy power management enable */
-		#define E1000_CTRL_EN_PHY_PWR_MGMT 0x00200000
 		ctrl |= E1000_CTRL_ADVD3WUC;
 		wr32(E1000_CTRL, ctrl);
 		wr32(E1000_WUFC, 0);
 	}
-	*enable_wake = wufc || adapter->en_mng_pt;
+	wake = wufc || adapter->en_mng_pt;
-	if (!*enable_wake)
+	if (!wake)
 		igb_power_down_link(adapter);
 	else
 		igb_power_up_link(adapter);
+	if (enable_wake)
+		*enable_wake = wake;
 	/* Release control of h/w to f/w.  If f/w is AMT enabled, this
 	 * would have already happened in close and is redundant.
 	 */
 static int __maybe_unused igb_suspend(struct device *dev)
 {
-	int retval;
+	return __igb_shutdown(to_pci_dev(dev), NULL, 0);
-	bool wake;
-	struct pci_dev *pdev = to_pci_dev(dev);
-	retval = __igb_shutdown(pdev, &wake, 0);
-	if (retval)
-		return retval;
-	if (wake) {
-		pci_prepare_to_sleep(pdev);
-	} else {
-		pci_wake_from_d3(pdev, false);
-		pci_set_power_state(pdev, PCI_D3hot);
-	}
-	return 0;
 }
 static int __maybe_unused igb_resume(struct device *dev)
 static int __maybe_unused igb_runtime_suspend(struct device *dev)
 {
-	struct pci_dev *pdev = to_pci_dev(dev);
+	return __igb_shutdown(to_pci_dev(dev), NULL, 1);
-	int retval;
-	bool wake;
-	retval = __igb_shutdown(pdev, &wake, 1);
-	if (retval)
-		return retval;
-	if (wake) {
-		pci_prepare_to_sleep(pdev);
-	} else {
-		pci_wake_from_d3(pdev, false);
-		pci_set_power_state(pdev, PCI_D3hot);
-	}
-	return 0;
 }
 static int __maybe_unused igb_runtime_resume(struct device *dev)

drivers/net/ethernet/intel/ixgbe/ixgbe_phy.c+9−7

 	struct pci_dev *pdev = adapter->pdev;
 	struct device *dev = &adapter->netdev->dev;
 	struct mii_bus *bus;
+	int err = -ENODEV;
-	adapter->mii_bus = devm_mdiobus_alloc(dev);
+	bus = devm_mdiobus_alloc(dev);
-	if (!adapter->mii_bus)
+	if (!bus)
 		return -ENOMEM;
-	bus = adapter->mii_bus;
 	switch (hw->device_id) {
 	/* C3000 SoCs */
 	case IXGBE_DEV_ID_X550EM_A_KR:
 	 */
 	hw->phy.mdio.mode_support = MDIO_SUPPORTS_C45 | MDIO_SUPPORTS_C22;
-	return mdiobus_register(bus);
+	err = mdiobus_register(bus);
+	if (!err) {
+		adapter->mii_bus = bus;
+		return 0;
+	}
 ixgbe_no_mii_bus:
 	devm_mdiobus_free(dev, bus);
-	adapter->mii_bus = NULL;
+	return err;
-	return -ENODEV;
 }
 /**

drivers/net/ethernet/mellanox/mlx5/core/en.h+1−0

@@ -858,6 +858,7 @@ void mlx5e_close_channels(struct mlx5e_channels *chs); · 857 unmodified lines
858	* switching channels	858	* switching channels
859	*/	859	*/
860	typedef int (mlx5e_fp_hw_modify)(struct mlx5e_priv priv);	860	typedef int (mlx5e_fp_hw_modify)(struct mlx5e_priv priv);
		861	int mlx5e_safe_reopen_channels(struct mlx5e_priv *priv);
861	int mlx5e_safe_switch_channels(struct mlx5e_priv *priv,	862	int mlx5e_safe_switch_channels(struct mlx5e_priv *priv,
862	struct mlx5e_channels *new_chs,	863	struct mlx5e_channels *new_chs,
863	mlx5e_fp_hw_modify hw_modify);	864	mlx5e_fp_hw_modify hw_modify);

drivers/net/ethernet/mellanox/mlx5/core/en/port.c+0−3

@@ -96,9 +96,6 @@ int mlx5_port_query_eth_proto(struct mlx5_core_dev *dev, u8 port, bool ext, · 95 unmodified lines
96	if (!eproto)	96	if (!eproto)
97	return -EINVAL;	97	return -EINVAL;
98		98
99	if (ext != MLX5_CAP_PCAM_FEATURE(dev, ptys_extended_ethernet))
100	return -EOPNOTSUPP;
101
102	err = mlx5_query_port_ptys(dev, out, sizeof(out), MLX5_PTYS_EN, port);	99	err = mlx5_query_port_ptys(dev, out, sizeof(out), MLX5_PTYS_EN, port);
103	if (err)	100	if (err)
104	return err;	101	return err;

drivers/net/ethernet/mellanox/mlx5/core/en/port_buffer.c+22−17

 	return err;
 }
-/* xoff = ((301+2.16 * len [m]) * speed [Gbps] + 2.72 MTU [B]) */
+/* xoff = ((301+2.16 * len [m]) * speed [Gbps] + 2.72 MTU [B])
+ * minimum speed value is 40Gbps
+ */
 static u32 calculate_xoff(struct mlx5e_priv *priv, unsigned int mtu)
 {
 	u32 speed;
 	int err;
 	err = mlx5e_port_linkspeed(priv->mdev, &speed);
-	if (err) {
+	if (err)
-		mlx5_core_warn(priv->mdev, "cannot get port speed\n");
+		speed = SPEED_40000;
-		return 0;
+	speed = max_t(u32, speed, SPEED_40000);
-	}
 	xoff = (301 + 216 * priv->dcbx.cable_len / 100) * speed / 1000 + 272 * mtu / 100;
 }
 static int update_xoff_threshold(struct mlx5e_port_buffer *port_buffer,
-				 u32 xoff, unsigned int mtu)
+				 u32 xoff, unsigned int max_mtu)
 {
 	int i;
 		}
 		if (port_buffer->buffer[i].size <
-		    (xoff + mtu + (1 << MLX5E_BUFFER_CELL_SHIFT)))
+		    (xoff + max_mtu + (1 << MLX5E_BUFFER_CELL_SHIFT)))
 			return -ENOMEM;
 		port_buffer->buffer[i].xoff = port_buffer->buffer[i].size - xoff;
-		port_buffer->buffer[i].xon  = port_buffer->buffer[i].xoff - mtu;
+		port_buffer->buffer[i].xon  =
+			port_buffer->buffer[i].xoff - max_mtu;
 	}
 	return 0;
 /**
  * update_buffer_lossy()
- *   mtu: device's MTU
+ *   max_mtu: netdev's max_mtu
  *   pfc_en: <input> current pfc configuration
  *   buffer: <input> current prio to buffer mapping
  *   xoff:   <input> xoff value
  *     Return 0 if no error.
  *     Set change to true if buffer configuration is modified.
  */
-static int update_buffer_lossy(unsigned int mtu,
+static int update_buffer_lossy(unsigned int max_mtu,
 			       u8 pfc_en, u8 *buffer, u32 xoff,
 			       struct mlx5e_port_buffer *port_buffer,
 			       bool *change)
 	}
 	if (changed) {
-		err = update_xoff_threshold(port_buffer, xoff, mtu);
+		err = update_xoff_threshold(port_buffer, xoff, max_mtu);
 		if (err)
 			return err;
 	return 0;
 }
+#define MINIMUM_MAX_MTU 9216
 int mlx5e_port_manual_buffer_config(struct mlx5e_priv *priv,
 				    u32 change, unsigned int mtu,
 				    struct ieee_pfc *pfc,
 	bool update_prio2buffer = false;
 	u8 buffer[MLX5E_MAX_PRIORITY];
 	bool update_buffer = false;
+	unsigned int max_mtu;
 	u32 total_used = 0;
 	u8 curr_pfc_en;
 	int err;
 	int i;
 	mlx5e_dbg(HW, priv, "%s: change=%x\n", __func__, change);
+	max_mtu = max_t(unsigned int, priv->netdev->max_mtu, MINIMUM_MAX_MTU);
 	err = mlx5e_port_query_buffer(priv, &port_buffer);
 	if (err)
 	if (change & MLX5E_PORT_BUFFER_CABLE_LEN) {
 		update_buffer = true;
-		err = update_xoff_threshold(&port_buffer, xoff, mtu);
+		err = update_xoff_threshold(&port_buffer, xoff, max_mtu);
 		if (err)
 			return err;
 	}
 		if (err)
 			return err;
-		err = update_buffer_lossy(mtu, pfc->pfc_en, buffer, xoff,
+		err = update_buffer_lossy(max_mtu, pfc->pfc_en, buffer, xoff,
 					  &port_buffer, &update_buffer);
 		if (err)
 			return err;
 		if (err)
 			return err;
-		err = update_buffer_lossy(mtu, curr_pfc_en, prio2buffer, xoff,
+		err = update_buffer_lossy(max_mtu, curr_pfc_en, prio2buffer,
-					  &port_buffer, &update_buffer);
+					  xoff, &port_buffer, &update_buffer);
 		if (err)
 			return err;
 	}
 			return -EINVAL;
 		update_buffer = true;
-		err = update_xoff_threshold(&port_buffer, xoff, mtu);
+		err = update_xoff_threshold(&port_buffer, xoff, max_mtu);
 		if (err)
 			return err;
 	}
 	/* Need to update buffer configuration if xoff value is changed */
 	if (!update_buffer && xoff != priv->dcbx.xoff) {
 		update_buffer = true;
-		err = update_xoff_threshold(&port_buffer, xoff, mtu);
+		err = update_xoff_threshold(&port_buffer, xoff, max_mtu);
 		if (err)
 			return err;
 	}

drivers/net/ethernet/mellanox/mlx5/core/en/reporter_tx.c+8−3

@@ -186,12 +186,17 @@ static int mlx5e_tx_reporter_recover_from_ctx(struct mlx5e_tx_err_ctx *err_ctx) · 185 unmodified lines
186		186
187	static int mlx5e_tx_reporter_recover_all(struct mlx5e_priv *priv)	187	static int mlx5e_tx_reporter_recover_all(struct mlx5e_priv *priv)
188	{	188	{
189	int err;	189	int err = 0;
190		190
191	rtnl_lock();	191	rtnl_lock();
192	mutex_lock(&priv->state_lock);	192	mutex_lock(&priv->state_lock);
193	mlx5e_close_locked(priv->netdev);	193
194	err = mlx5e_open_locked(priv->netdev);	194	if (!test_bit(MLX5E_STATE_OPENED, &priv->state))
		195	goto out;
		196
		197	err = mlx5e_safe_reopen_channels(priv);
		198
		199	out:
195	mutex_unlock(&priv->state_lock);	200	mutex_unlock(&priv->state_lock);
196	rtnl_unlock();	201	rtnl_unlock();
197		202

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c+4−0

@@ -39,6 +39,10 @@ static int get_route_and_out_devs(struct mlx5e_priv *priv, · 38 unmodified lines
39	return -EOPNOTSUPP;	39	return -EOPNOTSUPP;
40	}	40	}
41		41
		42	if (!(mlx5e_eswitch_rep(*out_dev) &&
		43	mlx5e_is_uplink_rep(netdev_priv(*out_dev))))
		44	return -EOPNOTSUPP;
		45
42	return 0;	46	return 0;
43	}	47	}
44		48

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

 	if (err)
 		return err;
+	mutex_lock(&mdev->mlx5e_res.td.list_lock);
 	list_add(&tir->list, &mdev->mlx5e_res.td.tirs_list);
+	mutex_unlock(&mdev->mlx5e_res.td.list_lock);
 	return 0;
 }
 void mlx5e_destroy_tir(struct mlx5_core_dev *mdev,
 		       struct mlx5e_tir *tir)
 {
+	mutex_lock(&mdev->mlx5e_res.td.list_lock);
 	mlx5_core_destroy_tir(mdev, tir->tirn);
 	list_del(&tir->list);
+	mutex_unlock(&mdev->mlx5e_res.td.list_lock);
 }
 static int mlx5e_create_mkey(struct mlx5_core_dev *mdev, u32 pdn,
 	}
 	INIT_LIST_HEAD(&mdev->mlx5e_res.td.tirs_list);
+	mutex_init(&mdev->mlx5e_res.td.list_lock);
 	return 0;
 {
 	struct mlx5_core_dev *mdev = priv->mdev;
 	struct mlx5e_tir *tir;
-	int err  = -ENOMEM;
+	int err  = 0;
 	u32 tirn = 0;
 	int inlen;
 	void *in;
 	inlen = MLX5_ST_SZ_BYTES(modify_tir_in);
 	in = kvzalloc(inlen, GFP_KERNEL);
-	if (!in)
+	if (!in) {
+		err = -ENOMEM;
 		goto out;
+	}
 	if (enable_uc_lb)
 		MLX5_SET(modify_tir_in, in, ctx.self_lb_block,
 	MLX5_SET(modify_tir_in, in, bitmask.self_lb_en, 1);
+	mutex_lock(&mdev->mlx5e_res.td.list_lock);
 	list_for_each_entry(tir, &mdev->mlx5e_res.td.tirs_list, list) {
 		tirn = tir->tirn;
 		err = mlx5_core_modify_tir(mdev, tirn, in, inlen);
 	kvfree(in);
 	if (err)
 		netdev_err(priv->netdev, "refresh tir(0x%x) failed, %d\n", tirn, err);
+	mutex_unlock(&mdev->mlx5e_res.td.list_lock);
 	return err;
 }

drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c+36−19

@@ -603,16 +603,18 @@ static void ptys2ethtool_supported_link(struct mlx5_core_dev *mdev, · 602 unmodified lines
603	__ETHTOOL_LINK_MODE_MASK_NBITS);	603	__ETHTOOL_LINK_MODE_MASK_NBITS);
604	}	604	}
605		605
606	static void ptys2ethtool_adver_link(struct mlx5_core_dev *mdev,	606	static void ptys2ethtool_adver_link(unsigned long *advertising_modes,
607	unsigned long *advertising_modes,	607	u32 eth_proto_cap, bool ext)
608	u32 eth_proto_cap)
609	{	608	{
610	unsigned long proto_cap = eth_proto_cap;	609	unsigned long proto_cap = eth_proto_cap;
611	struct ptys2ethtool_config *table;	610	struct ptys2ethtool_config *table;
612	u32 max_size;	611	u32 max_size;
613	int proto;	612	int proto;
614		613
615	mlx5e_ethtool_get_speed_arr(mdev, &table, &max_size);	614	table = ext ? ptys2ext_ethtool_table : ptys2legacy_ethtool_table;
		615	max_size = ext ? ARRAY_SIZE(ptys2ext_ethtool_table) :
		616	ARRAY_SIZE(ptys2legacy_ethtool_table);
		617
616	for_each_set_bit(proto, &proto_cap, max_size)	618	for_each_set_bit(proto, &proto_cap, max_size)
617	bitmap_or(advertising_modes, advertising_modes,	619	bitmap_or(advertising_modes, advertising_modes,
618	table[proto].advertised,	620	table[proto].advertised,
@@ -794,12 +796,12 @@ static void get_supported(struct mlx5_core_dev *mdev, u32 eth_proto_cap, · 175 unmodified lines
794	ethtool_link_ksettings_add_link_mode(link_ksettings, supported, Pause);	796	ethtool_link_ksettings_add_link_mode(link_ksettings, supported, Pause);
795	}	797	}
796		798
797	static void get_advertising(struct mlx5_core_dev *mdev, u32 eth_proto_cap,	799	static void get_advertising(u32 eth_proto_cap, u8 tx_pause, u8 rx_pause,
798	u8 tx_pause, u8 rx_pause,	800	struct ethtool_link_ksettings *link_ksettings,
799	struct ethtool_link_ksettings *link_ksettings)	801	bool ext)
800	{	802	{
801	unsigned long *advertising = link_ksettings->link_modes.advertising;	803	unsigned long *advertising = link_ksettings->link_modes.advertising;
802	ptys2ethtool_adver_link(mdev, advertising, eth_proto_cap);	804	ptys2ethtool_adver_link(advertising, eth_proto_cap, ext);
803		805
804	if (rx_pause)	806	if (rx_pause)
805	ethtool_link_ksettings_add_link_mode(link_ksettings, advertising, Pause);	807	ethtool_link_ksettings_add_link_mode(link_ksettings, advertising, Pause);
@@ -854,8 +856,9 @@ static void get_lp_advertising(struct mlx5_core_dev *mdev, u32 eth_proto_lp, · 48 unmodified lines
854	struct ethtool_link_ksettings *link_ksettings)	856	struct ethtool_link_ksettings *link_ksettings)
855	{	857	{
856	unsigned long *lp_advertising = link_ksettings->link_modes.lp_advertising;	858	unsigned long *lp_advertising = link_ksettings->link_modes.lp_advertising;
		859	bool ext = MLX5_CAP_PCAM_FEATURE(mdev, ptys_extended_ethernet);
857		860
858	ptys2ethtool_adver_link(mdev, lp_advertising, eth_proto_lp);	861	ptys2ethtool_adver_link(lp_advertising, eth_proto_lp, ext);
859	}	862	}
860		863
861	int mlx5e_ethtool_get_link_ksettings(struct mlx5e_priv *priv,	864	int mlx5e_ethtool_get_link_ksettings(struct mlx5e_priv *priv,
@@ -872,6 +875,7 @@ int mlx5e_ethtool_get_link_ksettings(struct mlx5e_priv *priv, · 10 unmodified lines
872	u8 an_disable_admin;	875	u8 an_disable_admin;
873	u8 an_status;	876	u8 an_status;
874	u8 connector_type;	877	u8 connector_type;
		878	bool admin_ext;
875	bool ext;	879	bool ext;
876	int err;	880	int err;
877		881
@@ -886,6 +890,19 @@ int mlx5e_ethtool_get_link_ksettings(struct mlx5e_priv *priv, · 8 unmodified lines
886	eth_proto_capability);	890	eth_proto_capability);
887	eth_proto_admin = MLX5_GET_ETH_PROTO(ptys_reg, out, ext,	891	eth_proto_admin = MLX5_GET_ETH_PROTO(ptys_reg, out, ext,
888	eth_proto_admin);	892	eth_proto_admin);
		893	/* Fields: eth_proto_admin and ext_eth_proto_admin are
		894	* mutually exclusive. Hence try reading legacy advertising
		895	* when extended advertising is zero.
		896	* admin_ext indicates how eth_proto_admin should be
		897	* interpreted
		898	*/
		899	admin_ext = ext;
		900	if (ext && !eth_proto_admin) {
		901	eth_proto_admin = MLX5_GET_ETH_PROTO(ptys_reg, out, false,
		902	eth_proto_admin);
		903	admin_ext = false;
		904	}
		905
889	eth_proto_oper = MLX5_GET_ETH_PROTO(ptys_reg, out, ext,	906	eth_proto_oper = MLX5_GET_ETH_PROTO(ptys_reg, out, ext,
890	eth_proto_oper);	907	eth_proto_oper);
891	eth_proto_lp = MLX5_GET(ptys_reg, out, eth_proto_lp_advertise);	908	eth_proto_lp = MLX5_GET(ptys_reg, out, eth_proto_lp_advertise);
@@ -899,7 +916,8 @@ int mlx5e_ethtool_get_link_ksettings(struct mlx5e_priv *priv, · 7 unmodified lines
899	ethtool_link_ksettings_zero_link_mode(link_ksettings, advertising);	916	ethtool_link_ksettings_zero_link_mode(link_ksettings, advertising);
900		917
901	get_supported(mdev, eth_proto_cap, link_ksettings);	918	get_supported(mdev, eth_proto_cap, link_ksettings);
902	get_advertising(mdev, eth_proto_admin, tx_pause, rx_pause, link_ksettings);	919	get_advertising(eth_proto_admin, tx_pause, rx_pause, link_ksettings,
		920	admin_ext);
903	get_speed_duplex(priv->netdev, eth_proto_oper, link_ksettings);	921	get_speed_duplex(priv->netdev, eth_proto_oper, link_ksettings);
904		922
905	eth_proto_oper = eth_proto_oper ? eth_proto_oper : eth_proto_cap;	923	eth_proto_oper = eth_proto_oper ? eth_proto_oper : eth_proto_cap;
@@ -997,19 +1015,17 @@ int mlx5e_ethtool_set_link_ksettings(struct mlx5e_priv *priv, · 91 unmodified lines
997		1015
998	#define MLX5E_PTYS_EXT ((1ULL << ETHTOOL_LINK_MODE_50000baseKR_Full_BIT) - 1)	1016	#define MLX5E_PTYS_EXT ((1ULL << ETHTOOL_LINK_MODE_50000baseKR_Full_BIT) - 1)
999		1017
1000	ext_requested = (link_ksettings->link_modes.advertising[0] >	1018	ext_requested = !!(link_ksettings->link_modes.advertising[0] >
1001	MLX5E_PTYS_EXT);	1019	MLX5E_PTYS_EXT \|\|
		1020	link_ksettings->link_modes.advertising[1]);
1002	ext_supported = MLX5_CAP_PCAM_FEATURE(mdev, ptys_extended_ethernet);	1021	ext_supported = MLX5_CAP_PCAM_FEATURE(mdev, ptys_extended_ethernet);
1003		1022	ext_requested &= ext_supported;
1004	/when ptys_extended_ethernet is set legacy link modes are deprecated /
1005	if (ext_requested != ext_supported)
1006	return -EPROTONOSUPPORT;
1007		1023
1008	speed = link_ksettings->base.speed;	1024	speed = link_ksettings->base.speed;
1009	ethtool2ptys_adver_func = ext_requested ?	1025	ethtool2ptys_adver_func = ext_requested ?
1010	mlx5e_ethtool2ptys_ext_adver_link :	1026	mlx5e_ethtool2ptys_ext_adver_link :
1011	mlx5e_ethtool2ptys_adver_link;	1027	mlx5e_ethtool2ptys_adver_link;
1012	err = mlx5_port_query_eth_proto(mdev, 1, ext_supported, &eproto);	1028	err = mlx5_port_query_eth_proto(mdev, 1, ext_requested, &eproto);
1013	if (err) {	1029	if (err) {
1014	netdev_err(priv->netdev, "%s: query port eth proto failed: %d\n",	1030	netdev_err(priv->netdev, "%s: query port eth proto failed: %d\n",
1015	__func__, err);	1031	__func__, err);
@@ -1037,7 +1053,7 @@ int mlx5e_ethtool_set_link_ksettings(struct mlx5e_priv *priv, · 21 unmodified lines
1037	if (!an_changes && link_modes == eproto.admin)	1053	if (!an_changes && link_modes == eproto.admin)
1038	goto out;	1054	goto out;
1039		1055
1040	mlx5_port_set_eth_ptys(mdev, an_disable, link_modes, ext_supported);	1056	mlx5_port_set_eth_ptys(mdev, an_disable, link_modes, ext_requested);
1041	mlx5_toggle_port_link(mdev);	1057	mlx5_toggle_port_link(mdev);
1042		1058
1043	out:	1059	out:
@@ -1752,7 +1768,8 @@ static int set_pflag_rx_no_csum_complete(struct net_device *netdev, bool enable) · 708 unmodified lines
1752	struct mlx5e_channel *c;	1768	struct mlx5e_channel *c;
1753	int i;	1769	int i;
1754		1770
1755	if (!test_bit(MLX5E_STATE_OPENED, &priv->state))	1771	if (!test_bit(MLX5E_STATE_OPENED, &priv->state) \|\|
		1772	priv->channels.params.xdp_prog)
1756	return 0;	1773	return 0;
1757		1774
1758	for (i = 0; i < channels->num; i++) {	1775	for (i = 0; i < channels->num; i++) {

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

 	if (params->rx_dim_enabled)
 		__set_bit(MLX5E_RQ_STATE_AM, &c->rq.state);
-	if (MLX5E_GET_PFLAG(params, MLX5E_PFLAG_RX_NO_CSUM_COMPLETE))
+	/* We disable csum_complete when XDP is enabled since
+	 * XDP programs might manipulate packets which will render
+	 * skb->checksum incorrect.
+	 */
+	if (MLX5E_GET_PFLAG(params, MLX5E_PFLAG_RX_NO_CSUM_COMPLETE) || c->xdp)
 		__set_bit(MLX5E_RQ_STATE_NO_CSUM_COMPLETE, &c->rq.state);
 	return 0;
 	return 0;
 }
+int mlx5e_safe_reopen_channels(struct mlx5e_priv *priv)
+{
+	struct mlx5e_channels new_channels = {};
+	new_channels.params = priv->channels.params;
+	return mlx5e_safe_switch_channels(priv, &new_channels, NULL);
+}
 void mlx5e_timestamp_init(struct mlx5e_priv *priv)
 {
 	priv->tstamp.tx_type   = HWTSTAMP_TX_OFF;
 	if (!report_failed)
 		goto unlock;
-	mlx5e_close_locked(priv->netdev);
+	err = mlx5e_safe_reopen_channels(priv);
-	err = mlx5e_open_locked(priv->netdev);
 	if (err)
 		netdev_err(priv->netdev,
-			   "mlx5e_open_locked failed recovering from a tx_timeout, err(%d).\n",
+			   "mlx5e_safe_reopen_channels failed recovering from a tx_timeout, err(%d).\n",
 			   err);
 unlock:
 {
 	enum mlx5e_traffic_types tt;
-	rss_params->hfunc = ETH_RSS_HASH_XOR;
+	rss_params->hfunc = ETH_RSS_HASH_TOP;
 	netdev_rss_key_fill(rss_params->toeplitz_hash_key,
 			    sizeof(rss_params->toeplitz_hash_key));
 	mlx5e_build_default_indir_rqt(rss_params->indirection_rqt,

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c+75−19

@@ -692,7 +692,14 @@ static inline bool is_last_ethertype_ip(struct sk_buff skb, int network_depth, · 691 unmodified lines
692	{	692	{
693	proto = ((struct ethhdr )skb->data)->h_proto;	693	proto = ((struct ethhdr )skb->data)->h_proto;
694	proto = __vlan_get_protocol(skb, proto, network_depth);	694	proto = __vlan_get_protocol(skb, proto, network_depth);
695	return (proto == htons(ETH_P_IP) \|\| proto == htons(ETH_P_IPV6));	695
		696	if (*proto == htons(ETH_P_IP))
		697	return pskb_may_pull(skb, *network_depth + sizeof(struct iphdr));
		698
		699	if (*proto == htons(ETH_P_IPV6))
		700	return pskb_may_pull(skb, *network_depth + sizeof(struct ipv6hdr));
		701
		702	return false;
696	}	703	}
697		704
698	static inline void mlx5e_enable_ecn(struct mlx5e_rq rq, struct sk_buff skb)	705	static inline void mlx5e_enable_ecn(struct mlx5e_rq rq, struct sk_buff skb)
@@ -712,17 +719,6 @@ static inline void mlx5e_enable_ecn(struct mlx5e_rq rq, struct sk_buff skb) · 13 unmodified lines
712	rq->stats->ecn_mark += !!rc;	719	rq->stats->ecn_mark += !!rc;
713	}	720	}
714		721
715	static u32 mlx5e_get_fcs(const struct sk_buff *skb)
716	{
717	const void *fcs_bytes;
718	u32 _fcs_bytes;
719
720	fcs_bytes = skb_header_pointer(skb, skb->len - ETH_FCS_LEN,
721	ETH_FCS_LEN, &_fcs_bytes);
722
723	return __get_unaligned_cpu32(fcs_bytes);
724	}
725
726	static u8 get_ip_proto(struct sk_buff *skb, int network_depth, __be16 proto)	722	static u8 get_ip_proto(struct sk_buff *skb, int network_depth, __be16 proto)
727	{	723	{
728	void *ip_p = skb->data + network_depth;	724	void *ip_p = skb->data + network_depth;
@@ -733,6 +729,68 @@ static u8 get_ip_proto(struct sk_buff *skb, int network_depth, __be16 proto) · 4 unmodified lines
733		729
734	#define short_frame(size) ((size) <= ETH_ZLEN + ETH_FCS_LEN)	730	#define short_frame(size) ((size) <= ETH_ZLEN + ETH_FCS_LEN)
735		731
		732	#define MAX_PADDING 8
		733
		734	static void
		735	tail_padding_csum_slow(struct sk_buff *skb, int offset, int len,
		736	struct mlx5e_rq_stats *stats)
		737	{
		738	stats->csum_complete_tail_slow++;
		739	skb->csum = csum_block_add(skb->csum,
		740	skb_checksum(skb, offset, len, 0),
		741	offset);
		742	}
		743
		744	static void
		745	tail_padding_csum(struct sk_buff *skb, int offset,
		746	struct mlx5e_rq_stats *stats)
		747	{
		748	u8 tail_padding[MAX_PADDING];
		749	int len = skb->len - offset;
		750	void *tail;
		751
		752	if (unlikely(len > MAX_PADDING)) {
		753	tail_padding_csum_slow(skb, offset, len, stats);
		754	return;
		755	}
		756
		757	tail = skb_header_pointer(skb, offset, len, tail_padding);
		758	if (unlikely(!tail)) {
		759	tail_padding_csum_slow(skb, offset, len, stats);
		760	return;
		761	}
		762
		763	stats->csum_complete_tail++;
		764	skb->csum = csum_block_add(skb->csum, csum_partial(tail, len, 0), offset);
		765	}
		766
		767	static void
		768	mlx5e_skb_padding_csum(struct sk_buff *skb, int network_depth, __be16 proto,
		769	struct mlx5e_rq_stats *stats)
		770	{
		771	struct ipv6hdr *ip6;
		772	struct iphdr *ip4;
		773	int pkt_len;
		774
		775	switch (proto) {
		776	case htons(ETH_P_IP):
		777	ip4 = (struct iphdr *)(skb->data + network_depth);
		778	pkt_len = network_depth + ntohs(ip4->tot_len);
		779	break;
		780	case htons(ETH_P_IPV6):
		781	ip6 = (struct ipv6hdr *)(skb->data + network_depth);
		782	pkt_len = network_depth + sizeof(*ip6) + ntohs(ip6->payload_len);
		783	break;
		784	default:
		785	return;
		786	}
		787
		788	if (likely(pkt_len >= skb->len))
		789	return;
		790
		791	tail_padding_csum(skb, pkt_len, stats);
		792	}
		793
736	static inline void mlx5e_handle_csum(struct net_device *netdev,	794	static inline void mlx5e_handle_csum(struct net_device *netdev,
737	struct mlx5_cqe64 *cqe,	795	struct mlx5_cqe64 *cqe,
738	struct mlx5e_rq *rq,	796	struct mlx5e_rq *rq,
@@ -752,7 +810,8 @@ static inline void mlx5e_handle_csum(struct net_device *netdev, · 13 unmodified lines
752	return;	810	return;
753	}	811	}
754		812
755	if (unlikely(test_bit(MLX5E_RQ_STATE_NO_CSUM_COMPLETE, &rq->state)))	813	/* True when explicitly set via priv flag, or XDP prog is loaded */
		814	if (test_bit(MLX5E_RQ_STATE_NO_CSUM_COMPLETE, &rq->state))
756	goto csum_unnecessary;	815	goto csum_unnecessary;
757		816
758	/* CQE csum doesn't cover padding octets in short ethernet	817	/* CQE csum doesn't cover padding octets in short ethernet
@@ -780,18 +839,15 @@ static inline void mlx5e_handle_csum(struct net_device *netdev, · 21 unmodified lines
780	skb->csum = csum_partial(skb->data + ETH_HLEN,	839	skb->csum = csum_partial(skb->data + ETH_HLEN,
781	network_depth - ETH_HLEN,	840	network_depth - ETH_HLEN,
782	skb->csum);	841	skb->csum);
783	if (unlikely(netdev->features & NETIF_F_RXFCS))	842
784	skb->csum = csum_block_add(skb->csum,	843	mlx5e_skb_padding_csum(skb, network_depth, proto, stats);
785	(__force __wsum)mlx5e_get_fcs(skb),
786	skb->len - ETH_FCS_LEN);
787	stats->csum_complete++;	844	stats->csum_complete++;
788	return;	845	return;
789	}	846	}
790		847
791	csum_unnecessary:	848	csum_unnecessary:
792	if (likely((cqe->hds_ip_ext & CQE_L3_OK) &&	849	if (likely((cqe->hds_ip_ext & CQE_L3_OK) &&
793	((cqe->hds_ip_ext & CQE_L4_OK) \|\|	850	(cqe->hds_ip_ext & CQE_L4_OK))) {
794	(get_cqe_l4_hdr_type(cqe) == CQE_L4_HDR_TYPE_NONE)))) {
795	skb->ip_summed = CHECKSUM_UNNECESSARY;	851	skb->ip_summed = CHECKSUM_UNNECESSARY;
796	if (cqe_is_tunneled(cqe)) {	852	if (cqe_is_tunneled(cqe)) {
797	skb->csum_level = 1;	853	skb->csum_level = 1;

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

 	{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_unnecessary) },
 	{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_none) },
 	{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_complete) },
+	{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_complete_tail) },
+	{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_complete_tail_slow) },
 	{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_unnecessary_inner) },
 	{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_xdp_drop) },
 	{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_xdp_redirect) },
 		s->rx_removed_vlan_packets += rq_stats->removed_vlan_packets;
 		s->rx_csum_none	+= rq_stats->csum_none;
 		s->rx_csum_complete += rq_stats->csum_complete;
+		s->rx_csum_complete_tail += rq_stats->csum_complete_tail;
+		s->rx_csum_complete_tail_slow += rq_stats->csum_complete_tail_slow;
 		s->rx_csum_unnecessary += rq_stats->csum_unnecessary;
 		s->rx_csum_unnecessary_inner += rq_stats->csum_unnecessary_inner;
 		s->rx_xdp_drop     += rq_stats->xdp_drop;
 	{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, packets) },
 	{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, bytes) },
 	{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, csum_complete) },
+	{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, csum_complete_tail) },
+	{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, csum_complete_tail_slow) },
 	{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, csum_unnecessary) },
 	{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, csum_unnecessary_inner) },
 	{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, csum_none) },

drivers/net/ethernet/mellanox/mlx5/core/en_stats.h+4−0

 	u64 rx_csum_unnecessary;
 	u64 rx_csum_none;
 	u64 rx_csum_complete;
+	u64 rx_csum_complete_tail;
+	u64 rx_csum_complete_tail_slow;
 	u64 rx_csum_unnecessary_inner;
 	u64 rx_xdp_drop;
 	u64 rx_xdp_redirect;
 	u64 packets;
 	u64 bytes;
 	u64 csum_complete;
+	u64 csum_complete_tail;
+	u64 csum_complete_tail_slow;
 	u64 csum_unnecessary;
 	u64 csum_unnecessary_inner;
 	u64 csum_none;

drivers/net/ethernet/mellanox/mlx5/core/en_tc.c+68−14

 	return true;
 }
+struct ip_ttl_word {
+	__u8	ttl;
+	__u8	protocol;
+	__sum16	check;
+};
+struct ipv6_hoplimit_word {
+	__be16	payload_len;
+	__u8	nexthdr;
+	__u8	hop_limit;
+};
+static bool is_action_keys_supported(const struct flow_action_entry *act)
+{
+	u32 mask, offset;
+	u8 htype;
+	htype = act->mangle.htype;
+	offset = act->mangle.offset;
+	mask = ~act->mangle.mask;
+	/* For IPv4 & IPv6 header check 4 byte word,
+	 * to determine that modified fields
+	 * are NOT ttl & hop_limit only.
+	 */
+	if (htype == FLOW_ACT_MANGLE_HDR_TYPE_IP4) {
+		struct ip_ttl_word *ttl_word =
+			(struct ip_ttl_word *)&mask;
+		if (offset != offsetof(struct iphdr, ttl) ||
+		    ttl_word->protocol ||
+		    ttl_word->check) {
+			return true;
+		}
+	} else if (htype == FLOW_ACT_MANGLE_HDR_TYPE_IP6) {
+		struct ipv6_hoplimit_word *hoplimit_word =
+			(struct ipv6_hoplimit_word *)&mask;
+		if (offset != offsetof(struct ipv6hdr, payload_len) ||
+		    hoplimit_word->payload_len ||
+		    hoplimit_word->nexthdr) {
+			return true;
+		}
+	}
+	return false;
+}
 static bool modify_header_match_supported(struct mlx5_flow_spec *spec,
 					  struct flow_action *flow_action,
 					  u32 actions,
 {
 	const struct flow_action_entry *act;
 	bool modify_ip_header;
-	u8 htype, ip_proto;
 	void *headers_v;
 	u16 ethertype;
+	u8 ip_proto;
 	int i;
 	if (actions & MLX5_FLOW_CONTEXT_ACTION_DECAP)
 		    act->id != FLOW_ACTION_ADD)
 			continue;
-		htype = act->mangle.htype;
+		if (is_action_keys_supported(act)) {
-		if (htype == FLOW_ACT_MANGLE_HDR_TYPE_IP4 ||
-		    htype == FLOW_ACT_MANGLE_HDR_TYPE_IP6) {
 			modify_ip_header = true;
 			break;
 		}
 	return 0;
 }
-static inline int cmp_encap_info(struct ip_tunnel_key *a,
+struct encap_key {
-				 struct ip_tunnel_key *b)
+	struct ip_tunnel_key *ip_tun_key;
+	int tunnel_type;
+};
+static inline int cmp_encap_info(struct encap_key *a,
+				 struct encap_key *b)
 {
-	return memcmp(a, b, sizeof(*a));
+	return memcmp(a->ip_tun_key, b->ip_tun_key, sizeof(*a->ip_tun_key)) ||
+	       a->tunnel_type != b->tunnel_type;
 }
-static inline int hash_encap_info(struct ip_tunnel_key *key)
+static inline int hash_encap_info(struct encap_key *key)
 {
-	return jhash(key, sizeof(*key), 0);
+	return jhash(key->ip_tun_key, sizeof(*key->ip_tun_key),
+		     key->tunnel_type);
 }
 	struct mlx5_esw_flow_attr *attr = flow->esw_attr;
 	struct mlx5e_tc_flow_parse_attr *parse_attr;
 	struct ip_tunnel_info *tun_info;
-	struct ip_tunnel_key *key;
+	struct encap_key key, e_key;
 	struct mlx5e_encap_entry *e;
 	unsigned short family;
 	uintptr_t hash_key;
 	parse_attr = attr->parse_attr;
 	tun_info = &parse_attr->tun_info[out_index];
 	family = ip_tunnel_info_af(tun_info);
-	key = &tun_info->key;
+	key.ip_tun_key = &tun_info->key;
+	key.tunnel_type = mlx5e_tc_tun_get_type(mirred_dev);
-	hash_key = hash_encap_info(key);
+	hash_key = hash_encap_info(&key);
 	hash_for_each_possible_rcu(esw->offloads.encap_tbl, e,
 				   encap_hlist, hash_key) {
-		if (!cmp_encap_info(&e->tun_info.key, key)) {
+		e_key.ip_tun_key = &e->tun_info.key;
+		e_key.tunnel_type = e->tunnel_type;
+		if (!cmp_encap_info(&e_key, &key)) {
 			found = true;
 			break;
 		}
 	if (hdrs[TCA_PEDIT_KEY_EX_CMD_SET].pedits ||
 	    hdrs[TCA_PEDIT_KEY_EX_CMD_ADD].pedits) {
-		err = alloc_tc_pedit_action(priv, MLX5_FLOW_NAMESPACE_KERNEL,
+		err = alloc_tc_pedit_action(priv, MLX5_FLOW_NAMESPACE_FDB,
 					    parse_attr, hdrs, extack);
 		if (err)
 			return err;

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

 		 opcode, MLX5_CMD_OP_MODIFY_NIC_VPORT_CONTEXT);
 	MLX5_SET(modify_nic_vport_context_in, in, field_select.change_event, 1);
 	MLX5_SET(modify_nic_vport_context_in, in, vport_number, vport);
-	if (vport)
+	MLX5_SET(modify_nic_vport_context_in, in, other_vport, 1);
-		MLX5_SET(modify_nic_vport_context_in, in, other_vport, 1);
 	nic_vport_ctx = MLX5_ADDR_OF(modify_nic_vport_context_in,
 				     in, nic_vport_context);
 	MLX5_SET(modify_esw_vport_context_in, in, opcode,
 		 MLX5_CMD_OP_MODIFY_ESW_VPORT_CONTEXT);
 	MLX5_SET(modify_esw_vport_context_in, in, vport_number, vport);
-	if (vport)
+	MLX5_SET(modify_esw_vport_context_in, in, other_vport, 1);
-		MLX5_SET(modify_esw_vport_context_in, in, other_vport, 1);
 	return mlx5_cmd_exec(dev, in, inlen, out, sizeof(out));
 }
 {
 	int err;
+	memset(&esw->fdb_table.legacy, 0, sizeof(struct legacy_fdb));
 	err = esw_create_legacy_vepa_table(esw);
 	if (err)
 		return err;
 	/* Star rule to forward all traffic to uplink vport */
 	memset(spec, 0, sizeof(*spec));
+	memset(&dest, 0, sizeof(dest));
 	dest.type = MLX5_FLOW_DESTINATION_TYPE_VPORT;
 	dest.vport.num = MLX5_VPORT_UPLINK;
 	flow_act.action = MLX5_FLOW_CONTEXT_ACTION_FWD_DEST;

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

@@ -1611,6 +1611,7 @@ static int esw_offloads_steering_init(struct mlx5_eswitch *esw, int nvports) · 1610 unmodified lines
1611	{	1611	{
1612	int err;	1612	int err;
1613		1613
		1614	memset(&esw->fdb_table.offloads, 0, sizeof(struct offloads_fdb));
1614	mutex_init(&esw->fdb_table.offloads.fdb_prio_lock);	1615	mutex_init(&esw->fdb_table.offloads.fdb_prio_lock);
1615		1616
1616	err = esw_create_offloads_fdb_tables(esw, nvports);	1617	err = esw_create_offloads_fdb_tables(esw, nvports);

drivers/net/ethernet/mellanox/mlx5/core/fpga/tls.c+24−29

@@ -148,14 +148,16 @@ static int mlx5_fpga_tls_alloc_swid(struct idr idr, spinlock_t idr_spinlock, · 147 unmodified lines
148	return ret;	148	return ret;
149	}	149	}
150		150
151	static void mlx5_fpga_tls_release_swid(struct idr *idr,	151	static void mlx5_fpga_tls_release_swid(struct idr idr,
152	spinlock_t *idr_spinlock, u32 swid)	152	spinlock_t *idr_spinlock, u32 swid)
153	{	153	{
154	unsigned long flags;	154	unsigned long flags;
		155	void *ptr;
155		156
156	spin_lock_irqsave(idr_spinlock, flags);	157	spin_lock_irqsave(idr_spinlock, flags);
157	idr_remove(idr, swid);	158	ptr = idr_remove(idr, swid);
158	spin_unlock_irqrestore(idr_spinlock, flags);	159	spin_unlock_irqrestore(idr_spinlock, flags);
		160	return ptr;
159	}	161	}
160		162
161	static void mlx_tls_kfree_complete(struct mlx5_fpga_conn *conn,	163	static void mlx_tls_kfree_complete(struct mlx5_fpga_conn *conn,
@@ -165,20 +167,12 @@ static void mlx_tls_kfree_complete(struct mlx5_fpga_conn *conn, · 3 unmodified lines
165	kfree(buf);	167	kfree(buf);
166	}	168	}
167		169
168	struct mlx5_teardown_stream_context {
169	struct mlx5_fpga_tls_command_context cmd;
170	u32 swid;
171	};
172
173	static void	170	static void
174	mlx5_fpga_tls_teardown_completion(struct mlx5_fpga_conn *conn,	171	mlx5_fpga_tls_teardown_completion(struct mlx5_fpga_conn *conn,
175	struct mlx5_fpga_device *fdev,	172	struct mlx5_fpga_device *fdev,
176	struct mlx5_fpga_tls_command_context *cmd,	173	struct mlx5_fpga_tls_command_context *cmd,
177	struct mlx5_fpga_dma_buf *resp)	174	struct mlx5_fpga_dma_buf *resp)
178	{	175	{
179	struct mlx5_teardown_stream_context *ctx =
180	container_of(cmd, struct mlx5_teardown_stream_context, cmd);
181
182	if (resp) {	176	if (resp) {
183	u32 syndrome = MLX5_GET(tls_resp, resp->sg[0].data, syndrome);	177	u32 syndrome = MLX5_GET(tls_resp, resp->sg[0].data, syndrome);
184		178
@@ -186,14 +180,6 @@ mlx5_fpga_tls_teardown_completion(struct mlx5_fpga_conn *conn, · 1 unmodified line
186	mlx5_fpga_err(fdev,	180	mlx5_fpga_err(fdev,
187	"Teardown stream failed with syndrome = %d",	181	"Teardown stream failed with syndrome = %d",
188	syndrome);	182	syndrome);
189	else if (MLX5_GET(tls_cmd, cmd->buf.sg[0].data, direction_sx))
190	mlx5_fpga_tls_release_swid(&fdev->tls->tx_idr,
191	&fdev->tls->tx_idr_spinlock,
192	ctx->swid);
193	else
194	mlx5_fpga_tls_release_swid(&fdev->tls->rx_idr,
195	&fdev->tls->rx_idr_spinlock,
196	ctx->swid);
197	}	183	}
198	mlx5_fpga_tls_put_command_ctx(cmd);	184	mlx5_fpga_tls_put_command_ctx(cmd);
199	}	185	}
@@ -225,8 +211,14 @@ int mlx5_fpga_tls_resync_rx(struct mlx5_core_dev *mdev, u32 handle, u32 seq, · 25 unmodified lines
225		211
226	rcu_read_lock();	212	rcu_read_lock();
227	flow = idr_find(&mdev->fpga->tls->rx_idr, ntohl(handle));	213	flow = idr_find(&mdev->fpga->tls->rx_idr, ntohl(handle));
228	rcu_read_unlock();	214	if (unlikely(!flow)) {
		215	rcu_read_unlock();
		216	WARN_ONCE(1, "Received NULL pointer for handle\n");
		217	kfree(buf);
		218	return -EINVAL;
		219	}
229	mlx5_fpga_tls_flow_to_cmd(flow, cmd);	220	mlx5_fpga_tls_flow_to_cmd(flow, cmd);
		221	rcu_read_unlock();
230		222
231	MLX5_SET(tls_cmd, cmd, swid, ntohl(handle));	223	MLX5_SET(tls_cmd, cmd, swid, ntohl(handle));
232	MLX5_SET64(tls_cmd, cmd, tls_rcd_sn, be64_to_cpu(rcd_sn));	224	MLX5_SET64(tls_cmd, cmd, tls_rcd_sn, be64_to_cpu(rcd_sn));
@@ -238,6 +230,8 @@ int mlx5_fpga_tls_resync_rx(struct mlx5_core_dev *mdev, u32 handle, u32 seq, · 5 unmodified lines
238	buf->complete = mlx_tls_kfree_complete;	230	buf->complete = mlx_tls_kfree_complete;
239		231
240	ret = mlx5_fpga_sbu_conn_sendmsg(mdev->fpga->tls->conn, buf);	232	ret = mlx5_fpga_sbu_conn_sendmsg(mdev->fpga->tls->conn, buf);
		233	if (ret < 0)
		234	kfree(buf);
241		235
242	return ret;	236	return ret;
243	}	237	}
@@ -245,7 +239,7 @@ int mlx5_fpga_tls_resync_rx(struct mlx5_core_dev *mdev, u32 handle, u32 seq, · 1 unmodified line
245	static void mlx5_fpga_tls_send_teardown_cmd(struct mlx5_core_dev *mdev,	239	static void mlx5_fpga_tls_send_teardown_cmd(struct mlx5_core_dev *mdev,
246	void *flow, u32 swid, gfp_t flags)	240	void *flow, u32 swid, gfp_t flags)
247	{	241	{
248	struct mlx5_teardown_stream_context *ctx;	242	struct mlx5_fpga_tls_command_context *ctx;
249	struct mlx5_fpga_dma_buf *buf;	243	struct mlx5_fpga_dma_buf *buf;
250	void *cmd;	244	void *cmd;
251		245
@@ -253,7 +247,7 @@ static void mlx5_fpga_tls_send_teardown_cmd(struct mlx5_core_dev *mdev, · 1 unmodified line
253	if (!ctx)	247	if (!ctx)
254	return;	248	return;
255		249
256	buf = &ctx->cmd.buf;	250	buf = &ctx->buf;
257	cmd = (ctx + 1);	251	cmd = (ctx + 1);
258	MLX5_SET(tls_cmd, cmd, command_type, CMD_TEARDOWN_STREAM);	252	MLX5_SET(tls_cmd, cmd, command_type, CMD_TEARDOWN_STREAM);
259	MLX5_SET(tls_cmd, cmd, swid, swid);	253	MLX5_SET(tls_cmd, cmd, swid, swid);
@@ -264,8 +258,7 @@ static void mlx5_fpga_tls_send_teardown_cmd(struct mlx5_core_dev *mdev, · 4 unmodified lines
264	buf->sg[0].data = cmd;	258	buf->sg[0].data = cmd;
265	buf->sg[0].size = MLX5_TLS_COMMAND_SIZE;	259	buf->sg[0].size = MLX5_TLS_COMMAND_SIZE;
266		260
267	ctx->swid = swid;	261	mlx5_fpga_tls_cmd_send(mdev->fpga, ctx,
268	mlx5_fpga_tls_cmd_send(mdev->fpga, &ctx->cmd,
269	mlx5_fpga_tls_teardown_completion);	262	mlx5_fpga_tls_teardown_completion);
270	}	263	}
271		264
@@ -275,13 +268,14 @@ void mlx5_fpga_tls_del_flow(struct mlx5_core_dev *mdev, u32 swid, · 3 unmodified lines
275	struct mlx5_fpga_tls *tls = mdev->fpga->tls;	268	struct mlx5_fpga_tls *tls = mdev->fpga->tls;
276	void *flow;	269	void *flow;
277		270
278	rcu_read_lock();
279	if (direction_sx)	271	if (direction_sx)
280	flow = idr_find(&tls->tx_idr, swid);	272	flow = mlx5_fpga_tls_release_swid(&tls->tx_idr,
		273	&tls->tx_idr_spinlock,
		274	swid);
281	else	275	else
282	flow = idr_find(&tls->rx_idr, swid);	276	flow = mlx5_fpga_tls_release_swid(&tls->rx_idr,
283		277	&tls->rx_idr_spinlock,
284	rcu_read_unlock();	278	swid);
285		279
286	if (!flow) {	280	if (!flow) {
287	mlx5_fpga_err(mdev->fpga, "No flow information for swid %u\n",	281	mlx5_fpga_err(mdev->fpga, "No flow information for swid %u\n",
@@ -289,6 +283,7 @@ void mlx5_fpga_tls_del_flow(struct mlx5_core_dev *mdev, u32 swid, · 1 unmodified line
289	return;	283	return;
290	}	284	}
291		285
		286	synchronize_rcu(); /* before kfree(flow) */
292	mlx5_fpga_tls_send_teardown_cmd(mdev, flow, swid, flags);	287	mlx5_fpga_tls_send_teardown_cmd(mdev, flow, swid, flags);
293	}	288	}
294		289

drivers/net/ethernet/mellanox/mlx5/core/main.c+0−20

@@ -164,26 +164,6 @@ static struct mlx5_profile profile[] = { · 163 unmodified lines
164	.size = 8,	164	.size = 8,
165	.limit = 4	165	.limit = 4
166	},	166	},
167	.mr_cache[16] = {
168	.size = 8,
169	.limit = 4
170	},
171	.mr_cache[17] = {
172	.size = 8,
173	.limit = 4
174	},
175	.mr_cache[18] = {
176	.size = 8,
177	.limit = 4
178	},
179	.mr_cache[19] = {
180	.size = 4,
181	.limit = 2
182	},
183	.mr_cache[20] = {
184	.size = 4,
185	.limit = 2
186	},
187	},	167	},
188	};	168	};
189		169

drivers/net/ethernet/mellanox/mlxsw/core.c+3−3

@@ -568,7 +568,7 @@ static int mlxsw_emad_init(struct mlxsw_core *mlxsw_core) · 567 unmodified lines
568	if (!(mlxsw_core->bus->features & MLXSW_BUS_F_TXRX))	568	if (!(mlxsw_core->bus->features & MLXSW_BUS_F_TXRX))
569	return 0;	569	return 0;
570		570
571	emad_wq = alloc_workqueue("mlxsw_core_emad", WQ_MEM_RECLAIM, 0);	571	emad_wq = alloc_workqueue("mlxsw_core_emad", 0, 0);
572	if (!emad_wq)	572	if (!emad_wq)
573	return -ENOMEM;	573	return -ENOMEM;
574	mlxsw_core->emad_wq = emad_wq;	574	mlxsw_core->emad_wq = emad_wq;
@@ -1958,10 +1958,10 @@ static int __init mlxsw_core_module_init(void) · 1383 unmodified lines
1958	{	1958	{
1959	int err;	1959	int err;
1960		1960
1961	mlxsw_wq = alloc_workqueue(mlxsw_core_driver_name, WQ_MEM_RECLAIM, 0);	1961	mlxsw_wq = alloc_workqueue(mlxsw_core_driver_name, 0, 0);
1962	if (!mlxsw_wq)	1962	if (!mlxsw_wq)
1963	return -ENOMEM;	1963	return -ENOMEM;
1964	mlxsw_owq = alloc_ordered_workqueue("%s_ordered", WQ_MEM_RECLAIM,	1964	mlxsw_owq = alloc_ordered_workqueue("%s_ordered", 0,
1965	mlxsw_core_driver_name);	1965	mlxsw_core_driver_name);
1966	if (!mlxsw_owq) {	1966	if (!mlxsw_owq) {
1967	err = -ENOMEM;	1967	err = -ENOMEM;

drivers/net/ethernet/mellanox/mlxsw/spectrum_buffers.c+11−8

 	{MLXSW_REG_SBXX_DIR_EGRESS, 1},
 	{MLXSW_REG_SBXX_DIR_EGRESS, 2},
 	{MLXSW_REG_SBXX_DIR_EGRESS, 3},
+	{MLXSW_REG_SBXX_DIR_EGRESS, 15},
 };
 #define MLXSW_SP_SB_ING_TC_COUNT 8
 	MLXSW_SP_SB_PR(MLXSW_REG_SBPR_MODE_STATIC, 0),
 	MLXSW_SP_SB_PR(MLXSW_REG_SBPR_MODE_STATIC, 0),
 	MLXSW_SP_SB_PR(MLXSW_REG_SBPR_MODE_STATIC, 0),
+	MLXSW_SP_SB_PR(MLXSW_REG_SBPR_MODE_STATIC, MLXSW_SP_SB_INFI),
 };
 static int mlxsw_sp_sb_prs_init(struct mlxsw_sp *mlxsw_sp,
 	MLXSW_SP_SB_CM(0, 7, 4),
 	MLXSW_SP_SB_CM(0, 7, 4),
 	MLXSW_SP_SB_CM(0, 7, 4),
-	MLXSW_SP_SB_CM(0, 7, 4),
+	MLXSW_SP_SB_CM(0, MLXSW_SP_SB_INFI, 8),
-	MLXSW_SP_SB_CM(0, 7, 4),
+	MLXSW_SP_SB_CM(0, MLXSW_SP_SB_INFI, 8),
-	MLXSW_SP_SB_CM(0, 7, 4),
+	MLXSW_SP_SB_CM(0, MLXSW_SP_SB_INFI, 8),
-	MLXSW_SP_SB_CM(0, 7, 4),
+	MLXSW_SP_SB_CM(0, MLXSW_SP_SB_INFI, 8),
-	MLXSW_SP_SB_CM(0, 7, 4),
+	MLXSW_SP_SB_CM(0, MLXSW_SP_SB_INFI, 8),
-	MLXSW_SP_SB_CM(0, 7, 4),
+	MLXSW_SP_SB_CM(0, MLXSW_SP_SB_INFI, 8),
-	MLXSW_SP_SB_CM(0, 7, 4),
+	MLXSW_SP_SB_CM(0, MLXSW_SP_SB_INFI, 8),
-	MLXSW_SP_SB_CM(0, 7, 4),
+	MLXSW_SP_SB_CM(0, MLXSW_SP_SB_INFI, 8),
 	MLXSW_SP_SB_CM(1, 0xff, 4),
 };
 	MLXSW_SP_SB_PM(0, 0),
 	MLXSW_SP_SB_PM(0, 0),
 	MLXSW_SP_SB_PM(0, 0),
+	MLXSW_SP_SB_PM(10000, 90000),
 };
 static int mlxsw_sp_port_sb_pms_init(struct mlxsw_sp_port *mlxsw_sp_port)

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c+1−1

@@ -6781,7 +6781,7 @@ static int mlxsw_sp_router_port_check_rif_addr(struct mlxsw_sp *mlxsw_sp, · 6780 unmodified lines
6781	/* A RIF is not created for macvlan netdevs. Their MAC is used to	6781	/* A RIF is not created for macvlan netdevs. Their MAC is used to
6782	* populate the FDB	6782	* populate the FDB
6783	*/	6783	*/
6784	if (netif_is_macvlan(dev))	6784	if (netif_is_macvlan(dev) \|\| netif_is_l3_master(dev))
6785	return 0;	6785	return 0;
6786		6786
6787	for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++) {	6787	for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++) {

drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c+1−1

@@ -1630,7 +1630,7 @@ static int mlxsw_sp_port_mdb_add(struct mlxsw_sp_port *mlxsw_sp_port, · 1629 unmodified lines
1630	u16 fid_index;	1630	u16 fid_index;
1631	int err = 0;	1631	int err = 0;
1632		1632
1633	if (switchdev_trans_ph_prepare(trans))	1633	if (switchdev_trans_ph_commit(trans))
1634	return 0;	1634	return 0;
1635		1635
1636	bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);	1636	bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);

drivers/net/ethernet/mscc/ocelot.c+15−9

 			      struct netdev_hw_addr *hw_addr)
 {
 	struct ocelot *ocelot = port->ocelot;
-	struct netdev_hw_addr *ha = kzalloc(sizeof(*ha), GFP_KERNEL);
+	struct netdev_hw_addr *ha = kzalloc(sizeof(*ha), GFP_ATOMIC);
 	if (!ha)
 		return -ENOMEM;
 		       ETH_GSTRING_LEN);
 }
-static void ocelot_check_stats(struct work_struct *work)
+static void ocelot_update_stats(struct ocelot *ocelot)
 {
-	struct delayed_work *del_work = to_delayed_work(work);
-	struct ocelot *ocelot = container_of(del_work, struct ocelot, stats_work);
 	int i, j;
 	mutex_lock(&ocelot->stats_lock);
 		}
 	}
-	cancel_delayed_work(&ocelot->stats_work);
+	mutex_unlock(&ocelot->stats_lock);
+}
+static void ocelot_check_stats_work(struct work_struct *work)
+{
+	struct delayed_work *del_work = to_delayed_work(work);
+	struct ocelot *ocelot = container_of(del_work, struct ocelot,
+					     stats_work);
+	ocelot_update_stats(ocelot);
 	queue_delayed_work(ocelot->stats_queue, &ocelot->stats_work,
 			   OCELOT_STATS_CHECK_DELAY);
-	mutex_unlock(&ocelot->stats_lock);
 }
 static void ocelot_get_ethtool_stats(struct net_device *dev,
 	int i;
 	/* check and update now */
-	ocelot_check_stats(&ocelot->stats_work.work);
+	ocelot_update_stats(ocelot);
 	/* Copy all counters */
 	for (i = 0; i < ocelot->num_stats; i++)
 				 ANA_CPUQ_8021_CFG_CPUQ_BPDU_VAL(6),
 				 ANA_CPUQ_8021_CFG, i);
-	INIT_DELAYED_WORK(&ocelot->stats_work, ocelot_check_stats);
+	INIT_DELAYED_WORK(&ocelot->stats_work, ocelot_check_stats_work);
 	queue_delayed_work(ocelot->stats_queue, &ocelot->stats_work,
 			   OCELOT_STATS_CHECK_DELAY);
 	return 0;

drivers/net/ethernet/neterion/vxge/vxge-config.c+1−0

@@ -2366,6 +2366,7 @@ static void __vxge_hw_blockpool_malloc(struct __vxge_hw_device devh, u32 size, · 2365 unmodified lines
2366	dma_object->addr))) {	2366	dma_object->addr))) {
2367	vxge_os_dma_free(devh->pdev, memblock,	2367	vxge_os_dma_free(devh->pdev, memblock,
2368	&dma_object->acc_handle);	2368	&dma_object->acc_handle);
		2369	memblock = NULL;
2369	goto exit;	2370	goto exit;
2370	}	2371	}
2371		2372

drivers/net/ethernet/netronome/nfp/flower/action.c+1−2

@@ -48,8 +48,7 @@ nfp_fl_push_vlan(struct nfp_fl_push_vlan *push_vlan, · 47 unmodified lines
48		48
49	tmp_push_vlan_tci =	49	tmp_push_vlan_tci =
50	FIELD_PREP(NFP_FL_PUSH_VLAN_PRIO, act->vlan.prio) \|	50	FIELD_PREP(NFP_FL_PUSH_VLAN_PRIO, act->vlan.prio) \|
51	FIELD_PREP(NFP_FL_PUSH_VLAN_VID, act->vlan.vid) \|	51	FIELD_PREP(NFP_FL_PUSH_VLAN_VID, act->vlan.vid);
52	NFP_FL_PUSH_VLAN_CFI;
53	push_vlan->vlan_tci = cpu_to_be16(tmp_push_vlan_tci);	52	push_vlan->vlan_tci = cpu_to_be16(tmp_push_vlan_tci);
54	}	53	}
55		54

drivers/net/ethernet/netronome/nfp/flower/cmsg.h+1−2

 #define NFP_FLOWER_LAYER2_GENEVE_OP	BIT(6)
 #define NFP_FLOWER_MASK_VLAN_PRIO	GENMASK(15, 13)
-#define NFP_FLOWER_MASK_VLAN_CFI	BIT(12)
+#define NFP_FLOWER_MASK_VLAN_PRESENT	BIT(12)
 #define NFP_FLOWER_MASK_VLAN_VID	GENMASK(11, 0)
 #define NFP_FLOWER_MASK_MPLS_LB		GENMASK(31, 12)
 #define NFP_FL_OUT_FLAGS_TYPE_IDX	GENMASK(2, 0)
 #define NFP_FL_PUSH_VLAN_PRIO		GENMASK(15, 13)
-#define NFP_FL_PUSH_VLAN_CFI		BIT(12)
 #define NFP_FL_PUSH_VLAN_VID		GENMASK(11, 0)
 #define IPV6_FLOW_LABEL_MASK		cpu_to_be32(0x000fffff)

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

@@ -30,20 +30,19 @@ nfp_flower_compile_meta_tci(struct nfp_flower_meta_tci *ext, · 29 unmodified lines
30		30
31	flow_rule_match_vlan(rule, &match);	31	flow_rule_match_vlan(rule, &match);
32	/* Populate the tci field. */	32	/* Populate the tci field. */
33	if (match.key->vlan_id \|\| match.key->vlan_priority) {	33	tmp_tci = NFP_FLOWER_MASK_VLAN_PRESENT;
34	tmp_tci = FIELD_PREP(NFP_FLOWER_MASK_VLAN_PRIO,	34	tmp_tci \|= FIELD_PREP(NFP_FLOWER_MASK_VLAN_PRIO,
35	match.key->vlan_priority) \|	35	match.key->vlan_priority) \|
36	FIELD_PREP(NFP_FLOWER_MASK_VLAN_VID,	36	FIELD_PREP(NFP_FLOWER_MASK_VLAN_VID,
37	match.key->vlan_id) \|	37	match.key->vlan_id);
38	NFP_FLOWER_MASK_VLAN_CFI;	38	ext->tci = cpu_to_be16(tmp_tci);
39	ext->tci = cpu_to_be16(tmp_tci);	39
40	tmp_tci = FIELD_PREP(NFP_FLOWER_MASK_VLAN_PRIO,	40	tmp_tci = NFP_FLOWER_MASK_VLAN_PRESENT;
41	match.mask->vlan_priority) \|	41	tmp_tci \|= FIELD_PREP(NFP_FLOWER_MASK_VLAN_PRIO,
42	FIELD_PREP(NFP_FLOWER_MASK_VLAN_VID,	42	match.mask->vlan_priority) \|
43	match.mask->vlan_id) \|	43	FIELD_PREP(NFP_FLOWER_MASK_VLAN_VID,
44	NFP_FLOWER_MASK_VLAN_CFI;	44	match.mask->vlan_id);
45	msk->tci = cpu_to_be16(tmp_tci);	45	msk->tci = cpu_to_be16(tmp_tci);
46	}
47	}	46	}
48	}	47	}
49		48

drivers/net/ethernet/netronome/nfp/nfp_net_repr.c+2−2

@@ -195,7 +195,7 @@ static netdev_tx_t nfp_repr_xmit(struct sk_buff skb, struct net_device netdev) · 194 unmodified lines
195	ret = dev_queue_xmit(skb);	195	ret = dev_queue_xmit(skb);
196	nfp_repr_inc_tx_stats(netdev, len, ret);	196	nfp_repr_inc_tx_stats(netdev, len, ret);
197		197
198	return ret;	198	return NETDEV_TX_OK;
199	}	199	}
200		200
201	static int nfp_repr_stop(struct net_device *netdev)	201	static int nfp_repr_stop(struct net_device *netdev)
@@ -383,7 +383,7 @@ int nfp_repr_init(struct nfp_app app, struct net_device netdev, · 181 unmodified lines
383	netdev->features &= ~(NETIF_F_TSO \| NETIF_F_TSO6);	383	netdev->features &= ~(NETIF_F_TSO \| NETIF_F_TSO6);
384	netdev->gso_max_segs = NFP_NET_LSO_MAX_SEGS;	384	netdev->gso_max_segs = NFP_NET_LSO_MAX_SEGS;
385		385
386	netdev->priv_flags \|= IFF_NO_QUEUE;	386	netdev->priv_flags \|= IFF_NO_QUEUE \| IFF_DISABLE_NETPOLL;
387	netdev->features \|= NETIF_F_LLTX;	387	netdev->features \|= NETIF_F_LLTX;
388		388
389	if (nfp_app_has_tc(app)) {	389	if (nfp_app_has_tc(app)) {

drivers/net/ethernet/qlogic/qed/qed.h+5−2

 	u8 num_pf_rls;
 };
+#define QED_OVERFLOW_BIT	1
 struct qed_db_recovery_info {
 	struct list_head list;
 	/* Lock to protect the doorbell recovery mechanism list */
 	spinlock_t lock;
+	bool dorq_attn;
 	u32 db_recovery_counter;
+	unsigned long overflow;
 };
 struct storm_stats {
 /* doorbell recovery mechanism */
 void qed_db_recovery_dp(struct qed_hwfn *p_hwfn);
-void qed_db_recovery_execute(struct qed_hwfn *p_hwfn,
+void qed_db_recovery_execute(struct qed_hwfn *p_hwfn);
-			     enum qed_db_rec_exec db_exec);
 bool qed_edpm_enabled(struct qed_hwfn *p_hwfn);
 /* Other Linux specific common definitions */

drivers/net/ethernet/qlogic/qed/qed_dev.c+34−51

 /* Doorbell address sanity (address within doorbell bar range) */
 static bool qed_db_rec_sanity(struct qed_dev *cdev,
-			      void __iomem *db_addr, void *db_data)
+			      void __iomem *db_addr,
+			      enum qed_db_rec_width db_width,
+			      void *db_data)
 {
+	u32 width = (db_width == DB_REC_WIDTH_32B) ? 32 : 64;
 	/* Make sure doorbell address is within the doorbell bar */
 	if (db_addr < cdev->doorbells ||
-	    (u8 __iomem *)db_addr >
+	    (u8 __iomem *)db_addr + width >
 	    (u8 __iomem *)cdev->doorbells + cdev->db_size) {
 		WARN(true,
 		     "Illegal doorbell address: %p. Legal range for doorbell addresses is [%p..%p]\n",
 	}
 	/* Sanitize doorbell address */
-	if (!qed_db_rec_sanity(cdev, db_addr, db_data))
+	if (!qed_db_rec_sanity(cdev, db_addr, db_width, db_data))
 		return -EINVAL;
 	/* Obtain hwfn from doorbell address */
 		return 0;
 	}
-	/* Sanitize doorbell address */
-	if (!qed_db_rec_sanity(cdev, db_addr, db_data))
-		return -EINVAL;
 	/* Obtain hwfn from doorbell address */
 	p_hwfn = qed_db_rec_find_hwfn(cdev, db_addr);
 /* Ring the doorbell of a single doorbell recovery entry */
 static void qed_db_recovery_ring(struct qed_hwfn *p_hwfn,
-				 struct qed_db_recovery_entry *db_entry,
+				 struct qed_db_recovery_entry *db_entry)
-				 enum qed_db_rec_exec db_exec)
+{
-{
+	/* Print according to width */
-	if (db_exec != DB_REC_ONCE) {
+	if (db_entry->db_width == DB_REC_WIDTH_32B) {
-		/* Print according to width */
+		DP_VERBOSE(p_hwfn, QED_MSG_SPQ,
-		if (db_entry->db_width == DB_REC_WIDTH_32B) {
+			   "ringing doorbell address %p data %x\n",
-			DP_VERBOSE(p_hwfn, QED_MSG_SPQ,
+			   db_entry->db_addr,
-				   "%s doorbell address %p data %x\n",
+			   *(u32 *)db_entry->db_data);
-				   db_exec == DB_REC_DRY_RUN ?
+	} else {
-				   "would have rung" : "ringing",
+		DP_VERBOSE(p_hwfn, QED_MSG_SPQ,
-				   db_entry->db_addr,
+			   "ringing doorbell address %p data %llx\n",
-				   *(u32 *)db_entry->db_data);
+			   db_entry->db_addr,
-		} else {
+			   *(u64 *)(db_entry->db_data));
-			DP_VERBOSE(p_hwfn, QED_MSG_SPQ,
-				   "%s doorbell address %p data %llx\n",
-				   db_exec == DB_REC_DRY_RUN ?
-				   "would have rung" : "ringing",
-				   db_entry->db_addr,
-				   *(u64 *)(db_entry->db_data));
-		}
 	}
 	/* Sanity */
 	if (!qed_db_rec_sanity(p_hwfn->cdev, db_entry->db_addr,
-			       db_entry->db_data))
+			       db_entry->db_width, db_entry->db_data))
 		return;
 	/* Flush the write combined buffer. Since there are multiple doorbelling
 	wmb();
 	/* Ring the doorbell */
-	if (db_exec == DB_REC_REAL_DEAL || db_exec == DB_REC_ONCE) {
+	if (db_entry->db_width == DB_REC_WIDTH_32B)
-		if (db_entry->db_width == DB_REC_WIDTH_32B)
+		DIRECT_REG_WR(db_entry->db_addr,
-			DIRECT_REG_WR(db_entry->db_addr,
+			      *(u32 *)(db_entry->db_data));
-				      *(u32 *)(db_entry->db_data));
+	else
-		else
+		DIRECT_REG_WR64(db_entry->db_addr,
-			DIRECT_REG_WR64(db_entry->db_addr,
+				*(u64 *)(db_entry->db_data));
-					*(u64 *)(db_entry->db_data));
-	}
 	/* Flush the write combined buffer. Next doorbell may come from a
 	 * different entity to the same address...
 }
 /* Traverse the doorbell recovery entry list and ring all the doorbells */
-void qed_db_recovery_execute(struct qed_hwfn *p_hwfn,
+void qed_db_recovery_execute(struct qed_hwfn *p_hwfn)
-			     enum qed_db_rec_exec db_exec)
 {
 	struct qed_db_recovery_entry *db_entry = NULL;
-	if (db_exec != DB_REC_ONCE) {
+	DP_NOTICE(p_hwfn, "Executing doorbell recovery. Counter was %d\n",
-		DP_NOTICE(p_hwfn,
+		  p_hwfn->db_recovery_info.db_recovery_counter);
-			  "Executing doorbell recovery. Counter was %d\n",
-			  p_hwfn->db_recovery_info.db_recovery_counter);
-		/* Track amount of times recovery was executed */
+	/* Track amount of times recovery was executed */
-		p_hwfn->db_recovery_info.db_recovery_counter++;
+	p_hwfn->db_recovery_info.db_recovery_counter++;
-	}
 	/* Protect the list */
 	spin_lock_bh(&p_hwfn->db_recovery_info.lock);
 	list_for_each_entry(db_entry,
-			    &p_hwfn->db_recovery_info.list, list_entry) {
+			    &p_hwfn->db_recovery_info.list, list_entry)
-		qed_db_recovery_ring(p_hwfn, db_entry, db_exec);
+		qed_db_recovery_ring(p_hwfn, db_entry);
-		if (db_exec == DB_REC_ONCE)
-			break;
-	}
 	spin_unlock_bh(&p_hwfn->db_recovery_info.lock);
 }

drivers/net/ethernet/qlogic/qed/qed_int.c+63−20

 	u32 count = QED_DB_REC_COUNT;
 	u32 usage = 1;
+	/* Flush any pending (e)dpms as they may never arrive */
+	qed_wr(p_hwfn, p_ptt, DORQ_REG_DPM_FORCE_ABORT, 0x1);
 	/* wait for usage to zero or count to run out. This is necessary since
 	 * EDPM doorbell transactions can take multiple 64b cycles, and as such
 	 * can "split" over the pci. Possibly, the doorbell drop can happen with
 int qed_db_rec_handler(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt)
 {
-	u32 overflow;
+	u32 attn_ovfl, cur_ovfl;
 	int rc;
-	overflow = qed_rd(p_hwfn, p_ptt, DORQ_REG_PF_OVFL_STICKY);
+	attn_ovfl = test_and_clear_bit(QED_OVERFLOW_BIT,
-	DP_NOTICE(p_hwfn, "PF Overflow sticky 0x%x\n", overflow);
+				       &p_hwfn->db_recovery_info.overflow);
-	if (!overflow) {
+	cur_ovfl = qed_rd(p_hwfn, p_ptt, DORQ_REG_PF_OVFL_STICKY);
-		qed_db_recovery_execute(p_hwfn, DB_REC_ONCE);
+	if (!cur_ovfl && !attn_ovfl)
 		return 0;
-	}
-	if (qed_edpm_enabled(p_hwfn)) {
+	DP_NOTICE(p_hwfn, "PF Overflow sticky: attn %u current %u\n",
+		  attn_ovfl, cur_ovfl);
+	if (cur_ovfl && !p_hwfn->db_bar_no_edpm) {
 		rc = qed_db_rec_flush_queue(p_hwfn, p_ptt);
 		if (rc)
 			return rc;
 	}
-	/* Flush any pending (e)dpm as they may never arrive */
-	qed_wr(p_hwfn, p_ptt, DORQ_REG_DPM_FORCE_ABORT, 0x1);
 	/* Release overflow sticky indication (stop silently dropping everything) */
 	qed_wr(p_hwfn, p_ptt, DORQ_REG_PF_OVFL_STICKY, 0x0);
 	/* Repeat all last doorbells (doorbell drop recovery) */
-	qed_db_recovery_execute(p_hwfn, DB_REC_REAL_DEAL);
+	qed_db_recovery_execute(p_hwfn);
 	return 0;
 }
-static int qed_dorq_attn_cb(struct qed_hwfn *p_hwfn)
+static void qed_dorq_attn_overflow(struct qed_hwfn *p_hwfn)
 {
-	u32 int_sts, first_drop_reason, details, address, all_drops_reason;
 	struct qed_ptt *p_ptt = p_hwfn->p_dpc_ptt;
+	u32 overflow;
 	int rc;
-	int_sts = qed_rd(p_hwfn, p_ptt, DORQ_REG_INT_STS);
+	overflow = qed_rd(p_hwfn, p_ptt, DORQ_REG_PF_OVFL_STICKY);
-	DP_NOTICE(p_hwfn->cdev, "DORQ attention. int_sts was %x\n", int_sts);
+	if (!overflow)
+		goto out;
+	/* Run PF doorbell recovery in next periodic handler */
+	set_bit(QED_OVERFLOW_BIT, &p_hwfn->db_recovery_info.overflow);
+	if (!p_hwfn->db_bar_no_edpm) {
+		rc = qed_db_rec_flush_queue(p_hwfn, p_ptt);
+		if (rc)
+			goto out;
+	}
+	qed_wr(p_hwfn, p_ptt, DORQ_REG_PF_OVFL_STICKY, 0x0);
+out:
+	/* Schedule the handler even if overflow was not detected */
+	qed_periodic_db_rec_start(p_hwfn);
+}
+static int qed_dorq_attn_int_sts(struct qed_hwfn *p_hwfn)
+{
+	u32 int_sts, first_drop_reason, details, address, all_drops_reason;
+	struct qed_ptt *p_ptt = p_hwfn->p_dpc_ptt;
 	/* int_sts may be zero since all PFs were interrupted for doorbell
 	 * overflow but another one already handled it. Can abort here. If
 	 * This PF also requires overflow recovery we will be interrupted again.
 	 * The masked almost full indication may also be set. Ignoring.
 	 */
+	int_sts = qed_rd(p_hwfn, p_ptt, DORQ_REG_INT_STS);
 	if (!(int_sts & ~DORQ_REG_INT_STS_DORQ_FIFO_AFULL))
 		return 0;
+	DP_NOTICE(p_hwfn->cdev, "DORQ attention. int_sts was %x\n", int_sts);
 	/* check if db_drop or overflow happened */
 	if (int_sts & (DORQ_REG_INT_STS_DB_DROP |
 		       DORQ_REG_INT_STS_DORQ_FIFO_OVFL_ERR)) {
 			  GET_FIELD(details, QED_DORQ_ATTENTION_SIZE) * 4,
 			  first_drop_reason, all_drops_reason);
-		rc = qed_db_rec_handler(p_hwfn, p_ptt);
-		qed_periodic_db_rec_start(p_hwfn);
-		if (rc)
-			return rc;
 		/* Clear the doorbell drop details and prepare for next drop */
 		qed_wr(p_hwfn, p_ptt, DORQ_REG_DB_DROP_DETAILS_REL, 0);
 	return -EINVAL;
 }
+static int qed_dorq_attn_cb(struct qed_hwfn *p_hwfn)
+{
+	p_hwfn->db_recovery_info.dorq_attn = true;
+	qed_dorq_attn_overflow(p_hwfn);
+	return qed_dorq_attn_int_sts(p_hwfn);
+}
+static void qed_dorq_attn_handler(struct qed_hwfn *p_hwfn)
+{
+	if (p_hwfn->db_recovery_info.dorq_attn)
+		goto out;
+	/* Call DORQ callback if the attention was missed */
+	qed_dorq_attn_cb(p_hwfn);
+out:
+	p_hwfn->db_recovery_info.dorq_attn = false;
+}
 /* Instead of major changes to the data-structure, we have a some 'special'
  * identifiers for sources that changed meaning between adapters.
  */
 		}
 	}
+	/* Handle missed DORQ attention */
+	qed_dorq_attn_handler(p_hwfn);
 	/* Clear IGU indication for the deasserted bits */
 	DIRECT_REG_WR((u8 __iomem *)p_hwfn->regview +
 				    GTT_BAR0_MAP_REG_IGU_CMD +

drivers/net/ethernet/qlogic/qed/qed_int.h+2−2

@@ -192,8 +192,8 @@ void qed_int_disable_post_isr_release(struct qed_dev *cdev); · 191 unmodified lines
192		192
193	/**	193	/**
194	* @brief - Doorbell Recovery handler.	194	* @brief - Doorbell Recovery handler.
195	* Run DB_REAL_DEAL doorbell recovery in case of PF overflow	195	* Run doorbell recovery in case of PF overflow (and flush DORQ if
196	* (and flush DORQ if needed), otherwise run DB_REC_ONCE.	196	* needed).
197	*	197	*
198	* @param p_hwfn	198	* @param p_hwfn
199	* @param p_ptt	199	* @param p_ptt

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

@@ -970,7 +970,7 @@ static void qed_update_pf_params(struct qed_dev *cdev, · 969 unmodified lines
970	}	970	}
971	}	971	}
972		972
973	#define QED_PERIODIC_DB_REC_COUNT 100	973	#define QED_PERIODIC_DB_REC_COUNT 10
974	#define QED_PERIODIC_DB_REC_INTERVAL_MS 100	974	#define QED_PERIODIC_DB_REC_INTERVAL_MS 100
975	#define QED_PERIODIC_DB_REC_INTERVAL \	975	#define QED_PERIODIC_DB_REC_INTERVAL \
976	msecs_to_jiffies(QED_PERIODIC_DB_REC_INTERVAL_MS)	976	msecs_to_jiffies(QED_PERIODIC_DB_REC_INTERVAL_MS)

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

@@ -1591,7 +1591,7 @@ static void qed_iov_vf_mbx_acquire(struct qed_hwfn *p_hwfn, · 1590 unmodified lines
1591	p_vfdev->eth_fp_hsi_minor = ETH_HSI_VER_NO_PKT_LEN_TUNN;	1591	p_vfdev->eth_fp_hsi_minor = ETH_HSI_VER_NO_PKT_LEN_TUNN;
1592	} else {	1592	} else {
1593	DP_INFO(p_hwfn,	1593	DP_INFO(p_hwfn,
1594	"VF[%d] needs fastpath HSI %02x.%02x, which is incompatible with loaded FW's faspath HSI %02x.%02x\n",	1594	"VF[%d] needs fastpath HSI %02x.%02x, which is incompatible with loaded FW's fastpath HSI %02x.%02x\n",
1595	vf->abs_vf_id,	1595	vf->abs_vf_id,
1596	req->vfdev_info.eth_fp_hsi_major,	1596	req->vfdev_info.eth_fp_hsi_major,
1597	req->vfdev_info.eth_fp_hsi_minor,	1597	req->vfdev_info.eth_fp_hsi_minor,

drivers/net/ethernet/qlogic/qede/qede_ptp.c+3−4

 	ptp->clock = ptp_clock_register(&ptp->clock_info, &edev->pdev->dev);
 	if (IS_ERR(ptp->clock)) {
-		rc = -EINVAL;
 		DP_ERR(edev, "PTP clock registration failed\n");
+		qede_ptp_disable(edev);
+		rc = -EINVAL;
 		goto err2;
 	}
 	return 0;
-err2:
-	qede_ptp_disable(edev);
-	ptp->clock = NULL;
 err1:
 	kfree(ptp);
+err2:
 	edev->ptp = NULL;
 	return rc;

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+7−1

 #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>
 	tp->cp_cmd |= PktCntrDisable | INTT_1;
 	RTL_W16(tp, CPlusCmd, tp->cp_cmd);
-	RTL_W16(tp, IntrMitigate, 0x5151);
+	RTL_W16(tp, IntrMitigate, 0x5100);
 	/* Work around for RxFIFO overflow. */
 	if (tp->mac_version == RTL_GIGA_MAC_VER_11) {
 	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/ethernet/stmicro/stmmac/descs_com.h+14−8

@@ -29,11 +29,13 @@ · 28 unmodified lines
29	/* Specific functions used for Ring mode */	29	/* Specific functions used for Ring mode */
30		30
31	/* Enhanced descriptors */	31	/* Enhanced descriptors */
32	static inline void ehn_desc_rx_set_on_ring(struct dma_desc *p, int end)	32	static inline void ehn_desc_rx_set_on_ring(struct dma_desc *p, int end,
		33	int bfsize)
33	{	34	{
34	p->des1 \|= cpu_to_le32((BUF_SIZE_8KiB	35	if (bfsize == BUF_SIZE_16KiB)
35	<< ERDES1_BUFFER2_SIZE_SHIFT)	36	p->des1 \|= cpu_to_le32((BUF_SIZE_8KiB
36	& ERDES1_BUFFER2_SIZE_MASK);	37	<< ERDES1_BUFFER2_SIZE_SHIFT)
		38	& ERDES1_BUFFER2_SIZE_MASK);
37		39
38	if (end)	40	if (end)
39	p->des1 \|= cpu_to_le32(ERDES1_END_RING);	41	p->des1 \|= cpu_to_le32(ERDES1_END_RING);
@@ -59,11 +61,15 @@ static inline void enh_set_tx_desc_len_on_ring(struct dma_desc *p, int len) · 19 unmodified lines
59	}	61	}
60		62
61	/* Normal descriptors */	63	/* Normal descriptors */
62	static inline void ndesc_rx_set_on_ring(struct dma_desc *p, int end)	64	static inline void ndesc_rx_set_on_ring(struct dma_desc *p, int end, int bfsize)
63	{	65	{
64	p->des1 \|= cpu_to_le32(((BUF_SIZE_2KiB - 1)	66	if (bfsize >= BUF_SIZE_2KiB) {
65	<< RDES1_BUFFER2_SIZE_SHIFT)	67	int bfsize2;
66	& RDES1_BUFFER2_SIZE_MASK);	68
		69	bfsize2 = min(bfsize - BUF_SIZE_2KiB + 1, BUF_SIZE_2KiB - 1);
		70	p->des1 \|= cpu_to_le32((bfsize2 << RDES1_BUFFER2_SIZE_SHIFT)
		71	& RDES1_BUFFER2_SIZE_MASK);
		72	}
67		73
68	if (end)	74	if (end)
69	p->des1 \|= cpu_to_le32(RDES1_END_RING);	75	p->des1 \|= cpu_to_le32(RDES1_END_RING);

drivers/net/ethernet/stmicro/stmmac/dwmac4_descs.c+1−1

@@ -296,7 +296,7 @@ exit: · 295 unmodified lines
296	}	296	}
297		297
298	static void dwmac4_rd_init_rx_desc(struct dma_desc *p, int disable_rx_ic,	298	static void dwmac4_rd_init_rx_desc(struct dma_desc *p, int disable_rx_ic,
299	int mode, int end)	299	int mode, int end, int bfsize)
300	{	300	{
301	dwmac4_set_rx_owner(p, disable_rx_ic);	301	dwmac4_set_rx_owner(p, disable_rx_ic);
302	}	302	}

drivers/net/ethernet/stmicro/stmmac/dwxgmac2_descs.c+1−1

@@ -123,7 +123,7 @@ static int dwxgmac2_get_rx_timestamp_status(void desc, void next_desc, · 122 unmodified lines
123	}	123	}
124		124
125	static void dwxgmac2_init_rx_desc(struct dma_desc *p, int disable_rx_ic,	125	static void dwxgmac2_init_rx_desc(struct dma_desc *p, int disable_rx_ic,
126	int mode, int end)	126	int mode, int end, int bfsize)
127	{	127	{
128	dwxgmac2_set_rx_owner(p, disable_rx_ic);	128	dwxgmac2_set_rx_owner(p, disable_rx_ic);
129	}	129	}

drivers/net/ethernet/stmicro/stmmac/enh_desc.c+16−6

@@ -201,6 +201,11 @@ static int enh_desc_get_rx_status(void data, struct stmmac_extra_stats x, · 200 unmodified lines
201	if (unlikely(rdes0 & RDES0_OWN))	201	if (unlikely(rdes0 & RDES0_OWN))
202	return dma_own;	202	return dma_own;
203		203
		204	if (unlikely(!(rdes0 & RDES0_LAST_DESCRIPTOR))) {
		205	stats->rx_length_errors++;
		206	return discard_frame;
		207	}
		208
204	if (unlikely(rdes0 & RDES0_ERROR_SUMMARY)) {	209	if (unlikely(rdes0 & RDES0_ERROR_SUMMARY)) {
205	if (unlikely(rdes0 & RDES0_DESCRIPTOR_ERROR)) {	210	if (unlikely(rdes0 & RDES0_DESCRIPTOR_ERROR)) {
206	x->rx_desc++;	211	x->rx_desc++;
@@ -231,9 +236,10 @@ static int enh_desc_get_rx_status(void data, struct stmmac_extra_stats x, · 24 unmodified lines
231	* It doesn't match with the information reported into the databook.	236	* It doesn't match with the information reported into the databook.
232	* At any rate, we need to understand if the CSUM hw computation is ok	237	* At any rate, we need to understand if the CSUM hw computation is ok
233	* and report this info to the upper layers. */	238	* and report this info to the upper layers. */
234	ret = enh_desc_coe_rdes0(!!(rdes0 & RDES0_IPC_CSUM_ERROR),	239	if (likely(ret == good_frame))
235	!!(rdes0 & RDES0_FRAME_TYPE),	240	ret = enh_desc_coe_rdes0(!!(rdes0 & RDES0_IPC_CSUM_ERROR),
236	!!(rdes0 & ERDES0_RX_MAC_ADDR));	241	!!(rdes0 & RDES0_FRAME_TYPE),
		242	!!(rdes0 & ERDES0_RX_MAC_ADDR));
237		243
238	if (unlikely(rdes0 & RDES0_DRIBBLING))	244	if (unlikely(rdes0 & RDES0_DRIBBLING))
239	x->dribbling_bit++;	245	x->dribbling_bit++;
@@ -259,15 +265,19 @@ static int enh_desc_get_rx_status(void data, struct stmmac_extra_stats x, · 19 unmodified lines
259	}	265	}
260		266
261	static void enh_desc_init_rx_desc(struct dma_desc *p, int disable_rx_ic,	267	static void enh_desc_init_rx_desc(struct dma_desc *p, int disable_rx_ic,
262	int mode, int end)	268	int mode, int end, int bfsize)
263	{	269	{
		270	int bfsize1;
		271
264	p->des0 \|= cpu_to_le32(RDES0_OWN);	272	p->des0 \|= cpu_to_le32(RDES0_OWN);
265	p->des1 \|= cpu_to_le32(BUF_SIZE_8KiB & ERDES1_BUFFER1_SIZE_MASK);	273
		274	bfsize1 = min(bfsize, BUF_SIZE_8KiB);
		275	p->des1 \|= cpu_to_le32(bfsize1 & ERDES1_BUFFER1_SIZE_MASK);
266		276
267	if (mode == STMMAC_CHAIN_MODE)	277	if (mode == STMMAC_CHAIN_MODE)
268	ehn_desc_rx_set_on_chain(p);	278	ehn_desc_rx_set_on_chain(p);
269	else	279	else
270	ehn_desc_rx_set_on_ring(p, end);	280	ehn_desc_rx_set_on_ring(p, end, bfsize);
271		281
272	if (disable_rx_ic)	282	if (disable_rx_ic)
273	p->des1 \|= cpu_to_le32(ERDES1_DISABLE_IC);	283	p->des1 \|= cpu_to_le32(ERDES1_DISABLE_IC);

drivers/net/ethernet/stmicro/stmmac/hwif.h+1−1

@@ -33,7 +33,7 @@ struct dma_extended_desc; · 32 unmodified lines
33	struct stmmac_desc_ops {	33	struct stmmac_desc_ops {
34	/* DMA RX descriptor ring initialization */	34	/* DMA RX descriptor ring initialization */
35	void (init_rx_desc)(struct dma_desc p, int disable_rx_ic, int mode,	35	void (init_rx_desc)(struct dma_desc p, int disable_rx_ic, int mode,
36	int end);	36	int end, int bfsize);
37	/* DMA TX descriptor ring initialization */	37	/* DMA TX descriptor ring initialization */
38	void (init_tx_desc)(struct dma_desc p, int mode, int end);	38	void (init_tx_desc)(struct dma_desc p, int mode, int end);
39	/* Invoked by the xmit function to prepare the tx descriptor */	39	/* Invoked by the xmit function to prepare the tx descriptor */

drivers/net/ethernet/stmicro/stmmac/norm_desc.c+7−5

@@ -91,8 +91,6 @@ static int ndesc_get_rx_status(void data, struct stmmac_extra_stats x, · 90 unmodified lines
91	return dma_own;	91	return dma_own;
92		92
93	if (unlikely(!(rdes0 & RDES0_LAST_DESCRIPTOR))) {	93	if (unlikely(!(rdes0 & RDES0_LAST_DESCRIPTOR))) {
94	pr_warn("%s: Oversized frame spanned multiple buffers\n",
95	__func__);
96	stats->rx_length_errors++;	94	stats->rx_length_errors++;
97	return discard_frame;	95	return discard_frame;
98	}	96	}
@@ -135,15 +133,19 @@ static int ndesc_get_rx_status(void data, struct stmmac_extra_stats x, · 36 unmodified lines
135	}	133	}
136		134
137	static void ndesc_init_rx_desc(struct dma_desc *p, int disable_rx_ic, int mode,	135	static void ndesc_init_rx_desc(struct dma_desc *p, int disable_rx_ic, int mode,
138	int end)	136	int end, int bfsize)
139	{	137	{
		138	int bfsize1;
		139
140	p->des0 \|= cpu_to_le32(RDES0_OWN);	140	p->des0 \|= cpu_to_le32(RDES0_OWN);
141	p->des1 \|= cpu_to_le32((BUF_SIZE_2KiB - 1) & RDES1_BUFFER1_SIZE_MASK);	141
		142	bfsize1 = min(bfsize, BUF_SIZE_2KiB - 1);
		143	p->des1 \|= cpu_to_le32(bfsize & RDES1_BUFFER1_SIZE_MASK);
142		144
143	if (mode == STMMAC_CHAIN_MODE)	145	if (mode == STMMAC_CHAIN_MODE)
144	ndesc_rx_set_on_chain(p, end);	146	ndesc_rx_set_on_chain(p, end);
145	else	147	else
146	ndesc_rx_set_on_ring(p, end);	148	ndesc_rx_set_on_ring(p, end, bfsize);
147		149
148	if (disable_rx_ic)	150	if (disable_rx_ic)
149	p->des1 \|= cpu_to_le32(RDES1_DISABLE_IC);	151	p->des1 \|= cpu_to_le32(RDES1_DISABLE_IC);

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c+19−15

 		if (priv->extend_desc)
 			stmmac_init_rx_desc(priv, &rx_q->dma_erx[i].basic,
 					priv->use_riwt, priv->mode,
-					(i == DMA_RX_SIZE - 1));
+					(i == DMA_RX_SIZE - 1),
+					priv->dma_buf_sz);
 		else
 			stmmac_init_rx_desc(priv, &rx_q->dma_rx[i],
 					priv->use_riwt, priv->mode,
-					(i == DMA_RX_SIZE - 1));
+					(i == DMA_RX_SIZE - 1),
+					priv->dma_buf_sz);
 }
 /**
 {
 	struct stmmac_rx_queue *rx_q = &priv->rx_queue[queue];
 	struct stmmac_channel *ch = &priv->channel[queue];
-	unsigned int entry = rx_q->cur_rx;
+	unsigned int next_entry = rx_q->cur_rx;
 	int coe = priv->hw->rx_csum;
-	unsigned int next_entry;
 	unsigned int count = 0;
 	bool xmac;
 		stmmac_display_ring(priv, rx_head, DMA_RX_SIZE, true);
 	}
 	while (count < limit) {
-		int status;
+		int entry, status;
 		struct dma_desc *p;
 		struct dma_desc *np;
+		entry = next_entry;
 		if (priv->extend_desc)
 			p = (struct dma_desc *)(rx_q->dma_erx + entry);
 		else
 			 *  ignored
 			 */
 			if (frame_len > priv->dma_buf_sz) {
-				netdev_err(priv->dev,
+				if (net_ratelimit())
-					   "len %d larger than size (%d)\n",
+					netdev_err(priv->dev,
-					   frame_len, priv->dma_buf_sz);
+						   "len %d larger than size (%d)\n",
+						   frame_len, priv->dma_buf_sz);
 				priv->dev->stats.rx_length_errors++;
-				break;
+				continue;
 			}
 			/* ACS is set; GMAC core strips PAD/FCS for IEEE 802.3
 						dev_warn(priv->device,
 							 "packet dropped\n");
 					priv->dev->stats.rx_dropped++;
-					break;
+					continue;
 				}
 				dma_sync_single_for_cpu(priv->device,
 			} else {
 				skb = rx_q->rx_skbuff[entry];
 				if (unlikely(!skb)) {
-					netdev_err(priv->dev,
+					if (net_ratelimit())
-						   "%s: Inconsistent Rx chain\n",
+						netdev_err(priv->dev,
-						   priv->dev->name);
+							   "%s: Inconsistent Rx chain\n",
+							   priv->dev->name);
 					priv->dev->stats.rx_dropped++;
-					break;
+					continue;
 				}
 				prefetch(skb->data - NET_IP_ALIGN);
 				rx_q->rx_skbuff[entry] = NULL;
 			priv->dev->stats.rx_packets++;
 			priv->dev->stats.rx_bytes += frame_len;
 		}
-		entry = next_entry;
 	}
 	stmmac_rx_refill(priv, queue);

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

@@ -987,6 +987,7 @@ struct netvsc_device { · 986 unmodified lines
987		987
988	wait_queue_head_t wait_drain;	988	wait_queue_head_t wait_drain;
989	bool destroy;	989	bool destroy;
		990	bool tx_disable; /* if true, do not wake up queue again */
990		991
991	/* Receive buffer allocated by us but manages by NetVSP */	992	/* Receive buffer allocated by us but manages by NetVSP */
992	void *recv_buf;	993	void *recv_buf;

drivers/net/hyperv/netvsc.c+4−2

 	init_waitqueue_head(&net_device->wait_drain);
 	net_device->destroy = false;
+	net_device->tx_disable = false;
 	net_device->max_pkt = RNDIS_MAX_PKT_DEFAULT;
 	net_device->pkt_align = RNDIS_PKT_ALIGN_DEFAULT;
 	} else {
 		struct netdev_queue *txq = netdev_get_tx_queue(ndev, q_idx);
-		if (netif_tx_queue_stopped(txq) &&
+		if (netif_tx_queue_stopped(txq) && !net_device->tx_disable &&
 		    (hv_get_avail_to_write_percent(&channel->outbound) >
 		     RING_AVAIL_PERCENT_HIWATER || queue_sends < 1)) {
 			netif_tx_wake_queue(txq);
 	} else if (ret == -EAGAIN) {
 		netif_tx_stop_queue(txq);
 		ndev_ctx->eth_stats.stop_queue++;
-		if (atomic_read(&nvchan->queue_sends) < 1) {
+		if (atomic_read(&nvchan->queue_sends) < 1 &&
+		    !net_device->tx_disable) {
 			netif_tx_wake_queue(txq);
 			ndev_ctx->eth_stats.wake_queue++;
 			ret = -ENOSPC;

drivers/net/hyperv/netvsc_drv.c+26−6

 	rcu_read_unlock();
 }
+static void netvsc_tx_enable(struct netvsc_device *nvscdev,
+			     struct net_device *ndev)
+{
+	nvscdev->tx_disable = false;
+	virt_wmb(); /* ensure queue wake up mechanism is on */
+	netif_tx_wake_all_queues(ndev);
+}
 static int netvsc_open(struct net_device *net)
 {
 	struct net_device_context *ndev_ctx = netdev_priv(net);
 	rdev = nvdev->extension;
 	if (!rdev->link_state) {
 		netif_carrier_on(net);
-		netif_tx_wake_all_queues(net);
+		netvsc_tx_enable(nvdev, net);
 	}
 	if (vf_netdev) {
 	}
 }
+static void netvsc_tx_disable(struct netvsc_device *nvscdev,
+			      struct net_device *ndev)
+{
+	if (nvscdev) {
+		nvscdev->tx_disable = true;
+		virt_wmb(); /* ensure txq will not wake up after stop */
+	}
+	netif_tx_disable(ndev);
+}
 static int netvsc_close(struct net_device *net)
 {
 	struct net_device_context *net_device_ctx = netdev_priv(net);
 	struct netvsc_device *nvdev = rtnl_dereference(net_device_ctx->nvdev);
 	int ret;
-	netif_tx_disable(net);
+	netvsc_tx_disable(nvdev, net);
 	/* No need to close rndis filter if it is removed already */
 	if (!nvdev)
 	/* If device was up (receiving) then shutdown */
 	if (netif_running(ndev)) {
-		netif_tx_disable(ndev);
+		netvsc_tx_disable(nvdev, ndev);
 		ret = rndis_filter_close(nvdev);
 		if (ret) {
 		if (rdev->link_state) {
 			rdev->link_state = false;
 			netif_carrier_on(net);
-			netif_tx_wake_all_queues(net);
+			netvsc_tx_enable(net_device, net);
 		} else {
 			notify = true;
 		}
 		if (!rdev->link_state) {
 			rdev->link_state = true;
 			netif_carrier_off(net);
-			netif_tx_stop_all_queues(net);
+			netvsc_tx_disable(net_device, net);
 		}
 		kfree(event);
 		break;
 		if (!rdev->link_state) {
 			rdev->link_state = true;
 			netif_carrier_off(net);
-			netif_tx_stop_all_queues(net);
+			netvsc_tx_disable(net_device, net);
 			event->event = RNDIS_STATUS_MEDIA_CONNECT;
 			spin_lock_irqsave(&ndev_ctx->lock, flags);
 			list_add(&event->list, &ndev_ctx->reconfig_events);

drivers/net/team/team.c+26−0

@@ -1246,6 +1246,23 @@ static int team_port_add(struct team team, struct net_device port_dev, · 1245 unmodified lines
1246	goto err_option_port_add;	1246	goto err_option_port_add;
1247	}	1247	}
1248		1248
		1249	/* set promiscuity level to new slave */
		1250	if (dev->flags & IFF_PROMISC) {
		1251	err = dev_set_promiscuity(port_dev, 1);
		1252	if (err)
		1253	goto err_set_slave_promisc;
		1254	}
		1255
		1256	/* set allmulti level to new slave */
		1257	if (dev->flags & IFF_ALLMULTI) {
		1258	err = dev_set_allmulti(port_dev, 1);
		1259	if (err) {
		1260	if (dev->flags & IFF_PROMISC)
		1261	dev_set_promiscuity(port_dev, -1);
		1262	goto err_set_slave_promisc;
		1263	}
		1264	}
		1265
1249	netif_addr_lock_bh(dev);	1266	netif_addr_lock_bh(dev);
1250	dev_uc_sync_multiple(port_dev, dev);	1267	dev_uc_sync_multiple(port_dev, dev);
1251	dev_mc_sync_multiple(port_dev, dev);	1268	dev_mc_sync_multiple(port_dev, dev);
@@ -1262,6 +1279,9 @@ static int team_port_add(struct team team, struct net_device port_dev, · 10 unmodified lines
1262		1279
1263	return 0;	1280	return 0;
1264		1281
		1282	err_set_slave_promisc:
		1283	__team_option_inst_del_port(team, port);
		1284
1265	err_option_port_add:	1285	err_option_port_add:
1266	team_upper_dev_unlink(team, port);	1286	team_upper_dev_unlink(team, port);
1267		1287
@@ -1307,6 +1327,12 @@ static int team_port_del(struct team team, struct net_device port_dev) · 39 unmodified lines
1307		1327
1308	team_port_disable(team, port);	1328	team_port_disable(team, port);
1309	list_del_rcu(&port->list);	1329	list_del_rcu(&port->list);
		1330
		1331	if (dev->flags & IFF_PROMISC)
		1332	dev_set_promiscuity(port_dev, -1);
		1333	if (dev->flags & IFF_ALLMULTI)
		1334	dev_set_allmulti(port_dev, -1);
		1335
1310	team_upper_dev_unlink(team, port);	1336	team_upper_dev_unlink(team, port);
1311	netdev_rx_handler_unregister(port_dev);	1337	netdev_rx_handler_unregister(port_dev);
1312	team_port_disable_netpoll(port);	1338	team_port_disable_netpoll(port);

drivers/net/usb/qmi_wwan.c+1−0

@@ -1203,6 +1203,7 @@ static const struct usb_device_id products[] = { · 1202 unmodified lines
1203	{QMI_FIXED_INTF(0x19d2, 0x2002, 4)}, /* ZTE (Vodafone) K3765-Z */	1203	{QMI_FIXED_INTF(0x19d2, 0x2002, 4)}, /* ZTE (Vodafone) K3765-Z */
1204	{QMI_FIXED_INTF(0x2001, 0x7e19, 4)}, /* D-Link DWM-221 B1 */	1204	{QMI_FIXED_INTF(0x2001, 0x7e19, 4)}, /* D-Link DWM-221 B1 */
1205	{QMI_FIXED_INTF(0x2001, 0x7e35, 4)}, /* D-Link DWM-222 */	1205	{QMI_FIXED_INTF(0x2001, 0x7e35, 4)}, /* D-Link DWM-222 */
		1206	{QMI_FIXED_INTF(0x2020, 0x2031, 4)}, /* Olicard 600 */
1206	{QMI_FIXED_INTF(0x2020, 0x2033, 4)}, /* BroadMobi BM806U */	1207	{QMI_FIXED_INTF(0x2020, 0x2033, 4)}, /* BroadMobi BM806U */
1207	{QMI_FIXED_INTF(0x0f3d, 0x68a2, 8)}, /* Sierra Wireless MC7700 */	1208	{QMI_FIXED_INTF(0x0f3d, 0x68a2, 8)}, /* Sierra Wireless MC7700 */
1208	{QMI_FIXED_INTF(0x114f, 0x68a2, 8)}, /* Sierra Wireless MC7750 */	1209	{QMI_FIXED_INTF(0x114f, 0x68a2, 8)}, /* Sierra Wireless MC7750 */

drivers/net/vrf.c+7−2

 	/* default to no qdisc; user can add if desired */
 	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/net/wireless/ath/ath10k/htt_rx.c+1−1

@@ -2728,7 +2728,7 @@ static void ath10k_htt_rx_tx_fetch_ind(struct ath10k ar, struct sk_buff skb) · 2727 unmodified lines
2728	num_msdus++;	2728	num_msdus++;
2729	num_bytes += ret;	2729	num_bytes += ret;
2730	}	2730	}
2731	ieee80211_return_txq(hw, txq);	2731	ieee80211_return_txq(hw, txq, false);
2732	ieee80211_txq_schedule_end(hw, txq->ac);	2732	ieee80211_txq_schedule_end(hw, txq->ac);
2733		2733
2734	record->num_msdus = cpu_to_le16(num_msdus);	2734	record->num_msdus = cpu_to_le16(num_msdus);

drivers/net/wireless/ath/ath10k/mac.c+2−2

@@ -4089,7 +4089,7 @@ static int ath10k_mac_schedule_txq(struct ieee80211_hw *hw, u32 ac) · 4088 unmodified lines
4089	if (ret < 0)	4089	if (ret < 0)
4090	break;	4090	break;
4091	}	4091	}
4092	ieee80211_return_txq(hw, txq);	4092	ieee80211_return_txq(hw, txq, false);
4093	ath10k_htt_tx_txq_update(hw, txq);	4093	ath10k_htt_tx_txq_update(hw, txq);
4094	if (ret == -EBUSY)	4094	if (ret == -EBUSY)
4095	break;	4095	break;
@@ -4374,7 +4374,7 @@ static void ath10k_mac_op_wake_tx_queue(struct ieee80211_hw *hw, · 278 unmodified lines
4374	if (ret < 0)	4374	if (ret < 0)
4375	break;	4375	break;
4376	}	4376	}
4377	ieee80211_return_txq(hw, txq);	4377	ieee80211_return_txq(hw, txq, false);
4378	ath10k_htt_tx_txq_update(hw, txq);	4378	ath10k_htt_tx_txq_update(hw, txq);
4379	out:	4379	out:
4380	ieee80211_txq_schedule_end(hw, ac);	4380	ieee80211_txq_schedule_end(hw, ac);

drivers/net/wireless/ath/ath9k/xmit.c+4−1

 		goto out;
 	while ((queue = ieee80211_next_txq(hw, txq->mac80211_qnum))) {
+		bool force;
 		tid = (struct ath_atx_tid *)queue->drv_priv;
 		ret = ath_tx_sched_aggr(sc, txq, tid);
 		ath_dbg(common, QUEUE, "ath_tx_sched_aggr returned %d\n", ret);
-		ieee80211_return_txq(hw, queue);
+		force = !skb_queue_empty(&tid->retry_q);
+		ieee80211_return_txq(hw, queue, force);
 	}
 out:

drivers/net/wireless/intel/iwlwifi/cfg/22000.c+22−8

 #define IWL_22000_HR_A0_FW_PRE		"iwlwifi-QuQnj-a0-hr-a0-"
 #define IWL_22000_SU_Z0_FW_PRE		"iwlwifi-su-z0-"
 #define IWL_QU_B_JF_B_FW_PRE		"iwlwifi-Qu-b0-jf-b0-"
+#define IWL_QUZ_A_HR_B_FW_PRE		"iwlwifi-QuZ-a0-hr-b0-"
 #define IWL_QNJ_B_JF_B_FW_PRE		"iwlwifi-QuQnj-b0-jf-b0-"
 #define IWL_CC_A_FW_PRE			"iwlwifi-cc-a0-"
 #define IWL_22000_SO_A_JF_B_FW_PRE	"iwlwifi-so-a0-jf-b0-"
 	IWL_22000_HR_A0_FW_PRE __stringify(api) ".ucode"
 #define IWL_22000_SU_Z0_MODULE_FIRMWARE(api) \
 	IWL_22000_SU_Z0_FW_PRE __stringify(api) ".ucode"
-#define IWL_QU_B_JF_B_MODULE_FIRMWARE(api) \
+#define IWL_QUZ_A_HR_B_MODULE_FIRMWARE(api) \
-	IWL_QU_B_JF_B_FW_PRE __stringify(api) ".ucode"
+	IWL_QUZ_A_HR_B_FW_PRE __stringify(api) ".ucode"
 #define IWL_QU_B_JF_B_MODULE_FIRMWARE(api) \
 	IWL_QU_B_JF_B_FW_PRE __stringify(api) ".ucode"
 #define IWL_QNJ_B_JF_B_MODULE_FIRMWARE(api)		\
 	.max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
 };
-const struct iwl_cfg iwl22260_2ax_cfg = {
+const struct iwl_cfg iwl_ax101_cfg_quz_hr = {
-	.name = "Intel(R) Wireless-AX 22260",
+	.name = "Intel(R) Wi-Fi 6 AX101",
+	.fw_name_pre = IWL_QUZ_A_HR_B_FW_PRE,
+	IWL_DEVICE_22500,
+	/*
+	 * This device doesn't support receiving BlockAck with a large bitmap
+	 * so we need to restrict the size of transmitted aggregation to the
+	 * HT size; mac80211 would otherwise pick the HE max (256) by default.
+	 */
+	.max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT,
+};
+const struct iwl_cfg iwl_ax200_cfg_cc = {
+	.name = "Intel(R) Wi-Fi 6 AX200 160MHz",
 	.fw_name_pre = IWL_CC_A_FW_PRE,
 	IWL_DEVICE_22500,
 	/*
 };
 const struct iwl_cfg killer1650x_2ax_cfg = {
-	.name = "Killer(R) Wireless-AX 1650x Wireless Network Adapter (200NGW)",
+	.name = "Killer(R) Wi-Fi 6 AX1650x 160MHz Wireless Network Adapter (200NGW)",
 	.fw_name_pre = IWL_CC_A_FW_PRE,
 	IWL_DEVICE_22500,
 	/*
 };
 const struct iwl_cfg killer1650w_2ax_cfg = {
-	.name = "Killer(R) Wireless-AX 1650w Wireless Network Adapter (200D2W)",
+	.name = "Killer(R) Wi-Fi 6 AX1650w 160MHz Wireless Network Adapter (200D2W)",
 	.fw_name_pre = IWL_CC_A_FW_PRE,
 	IWL_DEVICE_22500,
 	/*
 };
 const struct iwl_cfg killer1650s_2ax_cfg_qu_b0_hr_b0 = {
-	.name = "Killer(R) Wireless-AX 1650i Wireless Network Adapter (22560NGW)",
+	.name = "Killer(R) Wi-Fi 6 AX1650i 160MHz Wireless Network Adapter (201NGW)",
 	.fw_name_pre = IWL_22000_QU_B_HR_B_FW_PRE,
 	IWL_DEVICE_22500,
 	/*
 };
 const struct iwl_cfg killer1650i_2ax_cfg_qu_b0_hr_b0 = {
-	.name = "Killer(R) Wireless-AX 1650s Wireless Network Adapter (22560D2W)",
+	.name = "Killer(R) Wi-Fi 6 AX1650s 160MHz Wireless Network Adapter (201D2W)",
 	.fw_name_pre = IWL_22000_QU_B_HR_B_FW_PRE,
 	IWL_DEVICE_22500,
 	/*
 MODULE_FIRMWARE(IWL_22000_HR_A0_QNJ_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 MODULE_FIRMWARE(IWL_22000_SU_Z0_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 MODULE_FIRMWARE(IWL_QU_B_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
+MODULE_FIRMWARE(IWL_QUZ_A_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 MODULE_FIRMWARE(IWL_QNJ_B_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 MODULE_FIRMWARE(IWL_CC_A_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));
 MODULE_FIRMWARE(IWL_22000_SO_A_JF_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX));

drivers/net/wireless/intel/iwlwifi/fw/dbg.c+8−26

 	if (!range) {
 		IWL_ERR(fwrt, "Failed to fill region header: id=%d, type=%d\n",
 			le32_to_cpu(reg->region_id), type);
+		memset(*data, 0, le32_to_cpu((*data)->len));
 		return;
 	}
 		if (range_size < 0) {
 			IWL_ERR(fwrt, "Failed to dump region: id=%d, type=%d\n",
 				le32_to_cpu(reg->region_id), type);
+			memset(*data, 0, le32_to_cpu((*data)->len));
 			return;
 		}
 		range = range + range_size;
 	trigger = fwrt->dump.active_trigs[id].trig;
-	size = sizeof(*dump_file);
+	size = iwl_fw_ini_get_trigger_len(fwrt, trigger);
-	size += iwl_fw_ini_get_trigger_len(fwrt, trigger);
 	if (!size)
 		return NULL;
+	size += sizeof(*dump_file);
 	dump_file = vzalloc(size);
 	if (!dump_file)
 		return NULL;
 	iwl_dump_error_desc->len = 0;
 	ret = iwl_fw_dbg_collect_desc(fwrt, iwl_dump_error_desc, false, 0);
-	if (ret) {
+	if (ret)
 		kfree(iwl_dump_error_desc);
-	} else {
+	else
-		set_bit(STATUS_FW_WAIT_DUMP, &fwrt->trans->status);
+		iwl_trans_sync_nmi(fwrt->trans);
-		/* trigger nmi to halt the fw */
-		iwl_force_nmi(fwrt->trans);
-	}
 	return ret;
 }
 void iwl_fwrt_stop_device(struct iwl_fw_runtime *fwrt)
 {
-	/* if the wait event timeout elapses instead of wake up then
-	 * the driver did not receive NMI interrupt and can not assume the FW
-	 * is halted
-	 */
-	int ret = wait_event_timeout(fwrt->trans->fw_halt_waitq,
-				     !test_bit(STATUS_FW_WAIT_DUMP,
-					       &fwrt->trans->status),
-				     msecs_to_jiffies(2000));
-	if (!ret) {
-		/* failed to receive NMI interrupt, assuming the FW is stuck */
-		set_bit(STATUS_FW_ERROR, &fwrt->trans->status);
-		clear_bit(STATUS_FW_WAIT_DUMP, &fwrt->trans->status);
-	}
-	/* Assuming the op mode mutex is held at this point */
 	iwl_fw_dbg_collect_sync(fwrt);
 	iwl_trans_stop_device(fwrt->trans);

drivers/net/wireless/intel/iwlwifi/fw/init.c+0−1

@@ -76,7 +76,6 @@ void iwl_fw_runtime_init(struct iwl_fw_runtime fwrt, struct iwl_trans trans, · 75 unmodified lines
76	fwrt->ops_ctx = ops_ctx;	76	fwrt->ops_ctx = ops_ctx;
77	INIT_DELAYED_WORK(&fwrt->dump.wk, iwl_fw_error_dump_wk);	77	INIT_DELAYED_WORK(&fwrt->dump.wk, iwl_fw_error_dump_wk);
78	iwl_fwrt_dbgfs_register(fwrt, dbgfs_dir);	78	iwl_fwrt_dbgfs_register(fwrt, dbgfs_dir);
79	init_waitqueue_head(&fwrt->trans->fw_halt_waitq);
80	}	79	}
81	IWL_EXPORT_SYMBOL(iwl_fw_runtime_init);	80	IWL_EXPORT_SYMBOL(iwl_fw_runtime_init);
82		81

drivers/net/wireless/intel/iwlwifi/iwl-config.h+2−1

 extern const struct iwl_cfg iwl22000_2ac_cfg_hr_cdb;
 extern const struct iwl_cfg iwl22000_2ac_cfg_jf;
 extern const struct iwl_cfg iwl_ax101_cfg_qu_hr;
+extern const struct iwl_cfg iwl_ax101_cfg_quz_hr;
 extern const struct iwl_cfg iwl22000_2ax_cfg_hr;
-extern const struct iwl_cfg iwl22260_2ax_cfg;
+extern const struct iwl_cfg iwl_ax200_cfg_cc;
 extern const struct iwl_cfg killer1650s_2ax_cfg_qu_b0_hr_b0;
 extern const struct iwl_cfg killer1650i_2ax_cfg_qu_b0_hr_b0;
 extern const struct iwl_cfg killer1650x_2ax_cfg;

drivers/net/wireless/intel/iwlwifi/iwl-csr.h+1−0

@@ -327,6 +327,7 @@ enum { · 326 unmodified lines
327	#define CSR_HW_REV_TYPE_NONE (0x00001F0)	327	#define CSR_HW_REV_TYPE_NONE (0x00001F0)
328	#define CSR_HW_REV_TYPE_QNJ (0x0000360)	328	#define CSR_HW_REV_TYPE_QNJ (0x0000360)
329	#define CSR_HW_REV_TYPE_QNJ_B0 (0x0000364)	329	#define CSR_HW_REV_TYPE_QNJ_B0 (0x0000364)
		330	#define CSR_HW_REV_TYPE_QUZ (0x0000354)
330	#define CSR_HW_REV_TYPE_HR_CDB (0x0000340)	331	#define CSR_HW_REV_TYPE_HR_CDB (0x0000340)
331	#define CSR_HW_REV_TYPE_SO (0x0000370)	332	#define CSR_HW_REV_TYPE_SO (0x0000370)
332	#define CSR_HW_REV_TYPE_TY (0x0000420)	333	#define CSR_HW_REV_TYPE_TY (0x0000420)

drivers/net/wireless/intel/iwlwifi/iwl-trans.h+6−6

@@ -338,7 +338,6 @@ enum iwl_d3_status { · 337 unmodified lines
338	* are sent	338	* are sent
339	* @STATUS_TRANS_IDLE: the trans is idle - general commands are not to be sent	339	* @STATUS_TRANS_IDLE: the trans is idle - general commands are not to be sent
340	* @STATUS_TRANS_DEAD: trans is dead - avoid any read/write operation	340	* @STATUS_TRANS_DEAD: trans is dead - avoid any read/write operation
341	* @STATUS_FW_WAIT_DUMP: if set, wait until cleared before collecting dump
342	*/	341	*/
343	enum iwl_trans_status {	342	enum iwl_trans_status {
344	STATUS_SYNC_HCMD_ACTIVE,	343	STATUS_SYNC_HCMD_ACTIVE,
@@ -351,7 +350,6 @@ enum iwl_trans_status { · 6 unmodified lines
351	STATUS_TRANS_GOING_IDLE,	350	STATUS_TRANS_GOING_IDLE,
352	STATUS_TRANS_IDLE,	351	STATUS_TRANS_IDLE,
353	STATUS_TRANS_DEAD,	352	STATUS_TRANS_DEAD,
354	STATUS_FW_WAIT_DUMP,
355	};	353	};
356		354
357	static inline int	355	static inline int
@@ -618,6 +616,7 @@ struct iwl_trans_ops { · 260 unmodified lines
618	struct iwl_trans_dump_data (dump_data)(struct iwl_trans *trans,	616	struct iwl_trans_dump_data (dump_data)(struct iwl_trans *trans,
619	u32 dump_mask);	617	u32 dump_mask);
620	void (debugfs_cleanup)(struct iwl_trans trans);	618	void (debugfs_cleanup)(struct iwl_trans trans);
		619	void (sync_nmi)(struct iwl_trans trans);
621	};	620	};
622		621
623	/**	622	/**
@@ -831,7 +830,6 @@ struct iwl_trans { · 207 unmodified lines
831	u32 lmac_error_event_table[2];	830	u32 lmac_error_event_table[2];
832	u32 umac_error_event_table;	831	u32 umac_error_event_table;
833	unsigned int error_event_table_tlv_status;	832	unsigned int error_event_table_tlv_status;
834	wait_queue_head_t fw_halt_waitq;
835		833
836	/* pointer to trans specific struct */	834	/* pointer to trans specific struct */
837	/Ensure that this pointer will always be aligned to sizeof pointer /	835	/Ensure that this pointer will always be aligned to sizeof pointer /
@@ -1239,10 +1237,12 @@ static inline void iwl_trans_fw_error(struct iwl_trans *trans) · 401 unmodified lines
1239	/* prevent double restarts due to the same erroneous FW */	1237	/* prevent double restarts due to the same erroneous FW */
1240	if (!test_and_set_bit(STATUS_FW_ERROR, &trans->status))	1238	if (!test_and_set_bit(STATUS_FW_ERROR, &trans->status))
1241	iwl_op_mode_nic_error(trans->op_mode);	1239	iwl_op_mode_nic_error(trans->op_mode);
		1240	}
1242		1241
1243	if (test_and_clear_bit(STATUS_FW_WAIT_DUMP, &trans->status))	1242	static inline void iwl_trans_sync_nmi(struct iwl_trans *trans)
1244	wake_up(&trans->fw_halt_waitq);	1243	{
1245		1244	if (trans->ops->sync_nmi)
		1245	trans->ops->sync_nmi(trans);
1246	}	1246	}
1247		1247
1248	/*****************************************************	1248	/*****************************************************

drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c+22−49

@@ -2714,9 +2714,6 @@ static void iwl_mvm_stop_ap_ibss(struct ieee80211_hw *hw, · 2713 unmodified lines
2714		2714
2715	iwl_mvm_mac_ctxt_remove(mvm, vif);	2715	iwl_mvm_mac_ctxt_remove(mvm, vif);
2716		2716
2717	kfree(mvmvif->ap_wep_key);
2718	mvmvif->ap_wep_key = NULL;
2719
2720	mutex_unlock(&mvm->mutex);	2717	mutex_unlock(&mvm->mutex);
2721	}	2718	}
2722		2719
@@ -3183,24 +3180,7 @@ static int iwl_mvm_mac_sta_state(struct ieee80211_hw *hw, · 460 unmodified lines
3183	ret = iwl_mvm_update_sta(mvm, vif, sta);	3180	ret = iwl_mvm_update_sta(mvm, vif, sta);
3184	} else if (old_state == IEEE80211_STA_ASSOC &&	3181	} else if (old_state == IEEE80211_STA_ASSOC &&
3185	new_state == IEEE80211_STA_AUTHORIZED) {	3182	new_state == IEEE80211_STA_AUTHORIZED) {
3186	/* if wep is used, need to set the key for the station now */	3183	ret = 0;
3187	if (vif->type == NL80211_IFTYPE_AP && mvmvif->ap_wep_key) {
3188	mvm_sta->wep_key =
3189	kmemdup(mvmvif->ap_wep_key,
3190	sizeof(*mvmvif->ap_wep_key) +
3191	mvmvif->ap_wep_key->keylen,
3192	GFP_KERNEL);
3193	if (!mvm_sta->wep_key) {
3194	ret = -ENOMEM;
3195	goto out_unlock;
3196	}
3197
3198	ret = iwl_mvm_set_sta_key(mvm, vif, sta,
3199	mvm_sta->wep_key,
3200	STA_KEY_IDX_INVALID);
3201	} else {
3202	ret = 0;
3203	}
3204		3184
3205	/* we don't support TDLS during DCM */	3185	/* we don't support TDLS during DCM */
3206	if (iwl_mvm_phy_ctx_count(mvm) > 1)	3186	if (iwl_mvm_phy_ctx_count(mvm) > 1)
@@ -3242,17 +3222,6 @@ static int iwl_mvm_mac_sta_state(struct ieee80211_hw *hw, · 35 unmodified lines
3242	NL80211_TDLS_DISABLE_LINK);	3222	NL80211_TDLS_DISABLE_LINK);
3243	}	3223	}
3244		3224
3245	/* Remove STA key if this is an AP using WEP */
3246	if (vif->type == NL80211_IFTYPE_AP && mvmvif->ap_wep_key) {
3247	int rm_ret = iwl_mvm_remove_sta_key(mvm, vif, sta,
3248	mvm_sta->wep_key);
3249
3250	if (!ret)
3251	ret = rm_ret;
3252	kfree(mvm_sta->wep_key);
3253	mvm_sta->wep_key = NULL;
3254	}
3255
3256	if (unlikely(ret &&	3225	if (unlikely(ret &&
3257	test_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED,	3226	test_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED,
3258	&mvm->status)))	3227	&mvm->status)))
@@ -3289,6 +3258,13 @@ static void iwl_mvm_sta_rc_update(struct ieee80211_hw *hw, · 30 unmodified lines
3289	struct ieee80211_sta *sta, u32 changed)	3258	struct ieee80211_sta *sta, u32 changed)
3290	{	3259	{
3291	struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);	3260	struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
		3261	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
		3262
		3263	if (changed & (IEEE80211_RC_BW_CHANGED \|
		3264	IEEE80211_RC_SUPP_RATES_CHANGED \|
		3265	IEEE80211_RC_NSS_CHANGED))
		3266	iwl_mvm_rs_rate_init(mvm, sta, mvmvif->phy_ctxt->channel->band,
		3267	true);
3292		3268
3293	if (vif->type == NL80211_IFTYPE_STATION &&	3269	if (vif->type == NL80211_IFTYPE_STATION &&
3294	changed & IEEE80211_RC_NSS_CHANGED)	3270	changed & IEEE80211_RC_NSS_CHANGED)
@@ -3439,20 +3415,12 @@ static int iwl_mvm_mac_set_key(struct ieee80211_hw *hw, · 144 unmodified lines
3439	break;	3415	break;
3440	case WLAN_CIPHER_SUITE_WEP40:	3416	case WLAN_CIPHER_SUITE_WEP40:
3441	case WLAN_CIPHER_SUITE_WEP104:	3417	case WLAN_CIPHER_SUITE_WEP104:
3442	if (vif->type == NL80211_IFTYPE_AP) {	3418	if (vif->type == NL80211_IFTYPE_STATION)
3443	struct iwl_mvm_vif *mvmvif =	3419	break;
3444	iwl_mvm_vif_from_mac80211(vif);	3420	if (iwl_mvm_has_new_tx_api(mvm))
3445		3421	return -EOPNOTSUPP;
3446	mvmvif->ap_wep_key = kmemdup(key,	3422	/* support HW crypto on TX */
3447	sizeof(*key) + key->keylen,	3423	return 0;
3448	GFP_KERNEL);
3449	if (!mvmvif->ap_wep_key)
3450	return -ENOMEM;
3451	}
3452
3453	if (vif->type != NL80211_IFTYPE_STATION)
3454	return 0;
3455	break;
3456	default:	3424	default:
3457	/* currently FW supports only one optional cipher scheme */	3425	/* currently FW supports only one optional cipher scheme */
3458	if (hw->n_cipher_schemes &&	3426	if (hw->n_cipher_schemes &&
@@ -3540,12 +3508,17 @@ static int iwl_mvm_mac_set_key(struct ieee80211_hw *hw, · 81 unmodified lines
3540	ret = iwl_mvm_set_sta_key(mvm, vif, sta, key, key_offset);	3508	ret = iwl_mvm_set_sta_key(mvm, vif, sta, key, key_offset);
3541	if (ret) {	3509	if (ret) {
3542	IWL_WARN(mvm, "set key failed\n");	3510	IWL_WARN(mvm, "set key failed\n");
		3511	key->hw_key_idx = STA_KEY_IDX_INVALID;
3543	/*	3512	/*
3544	* can't add key for RX, but we don't need it	3513	* can't add key for RX, but we don't need it
3545	* in the device for TX so still return 0	3514	* in the device for TX so still return 0,
		3515	* unless we have new TX API where we cannot
		3516	* put key material into the TX_CMD
3546	*/	3517	*/
3547	key->hw_key_idx = STA_KEY_IDX_INVALID;	3518	if (iwl_mvm_has_new_tx_api(mvm))
3548	ret = 0;	3519	ret = -EOPNOTSUPP;
		3520	else
		3521	ret = 0;
3549	}	3522	}
3550		3523
3551	break;	3524	break;

drivers/net/wireless/intel/iwlwifi/mvm/mvm.h+0−1

@@ -498,7 +498,6 @@ struct iwl_mvm_vif { · 497 unmodified lines
498	netdev_features_t features;	498	netdev_features_t features;
499		499
500	struct iwl_probe_resp_data __rcu *probe_resp_data;	500	struct iwl_probe_resp_data __rcu *probe_resp_data;
501	struct ieee80211_key_conf *ap_wep_key;
502	};	501	};
503		502
504	static inline struct iwl_mvm_vif *	503	static inline struct iwl_mvm_vif *

drivers/net/wireless/intel/iwlwifi/mvm/sta.c+4−39

@@ -8,7 +8,7 @@ · 7 unmodified lines
8	* Copyright(c) 2012 - 2015 Intel Corporation. All rights reserved.	8	* Copyright(c) 2012 - 2015 Intel Corporation. All rights reserved.
9	* Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH	9	* Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
10	* Copyright(c) 2016 - 2017 Intel Deutschland GmbH	10	* Copyright(c) 2016 - 2017 Intel Deutschland GmbH
11	* Copyright(c) 2018 Intel Corporation	11	* Copyright(c) 2018 - 2019 Intel Corporation
12	*	12	*
13	* This program is free software; you can redistribute it and/or modify	13	* This program is free software; you can redistribute it and/or modify
14	* it under the terms of version 2 of the GNU General Public License as	14	* it under the terms of version 2 of the GNU General Public License as
@@ -31,7 +31,7 @@ · 16 unmodified lines
31	* Copyright(c) 2012 - 2015 Intel Corporation. All rights reserved.	31	* Copyright(c) 2012 - 2015 Intel Corporation. All rights reserved.
32	* Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH	32	* Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
33	* Copyright(c) 2016 - 2017 Intel Deutschland GmbH	33	* Copyright(c) 2016 - 2017 Intel Deutschland GmbH
34	* Copyright(c) 2018 Intel Corporation	34	* Copyright(c) 2018 - 2019 Intel Corporation
35	* All rights reserved.	35	* All rights reserved.
36	*	36	*
37	* Redistribution and use in source and binary forms, with or without	37	* Redistribution and use in source and binary forms, with or without
@@ -1399,7 +1399,9 @@ void iwl_mvm_add_new_dqa_stream_wk(struct work_struct *wk) · 1361 unmodified lines
1399		1399
1400	iwl_mvm_sta_alloc_queue(mvm, txq->sta, txq->ac, tid);	1400	iwl_mvm_sta_alloc_queue(mvm, txq->sta, txq->ac, tid);
1401	list_del_init(&mvmtxq->list);	1401	list_del_init(&mvmtxq->list);
		1402	local_bh_disable();
1402	iwl_mvm_mac_itxq_xmit(mvm->hw, txq);	1403	iwl_mvm_mac_itxq_xmit(mvm->hw, txq);
		1404	local_bh_enable();
1403	}	1405	}
1404		1406
1405	mutex_unlock(&mvm->mutex);	1407	mutex_unlock(&mvm->mutex);
@@ -2333,21 +2335,6 @@ int iwl_mvm_add_mcast_sta(struct iwl_mvm mvm, struct ieee80211_vif vif) · 927 unmodified lines
2333	iwl_mvm_enable_txq(mvm, NULL, mvmvif->cab_queue, 0, &cfg,	2335	iwl_mvm_enable_txq(mvm, NULL, mvmvif->cab_queue, 0, &cfg,
2334	timeout);	2336	timeout);
2335		2337
2336	if (mvmvif->ap_wep_key) {
2337	u8 key_offset = iwl_mvm_set_fw_key_idx(mvm);
2338
2339	__set_bit(key_offset, mvm->fw_key_table);
2340
2341	if (key_offset == STA_KEY_IDX_INVALID)
2342	return -ENOSPC;
2343
2344	ret = iwl_mvm_send_sta_key(mvm, mvmvif->mcast_sta.sta_id,
2345	mvmvif->ap_wep_key, true, 0, NULL, 0,
2346	key_offset, 0);
2347	if (ret)
2348	return ret;
2349	}
2350
2351	return 0;	2338	return 0;
2352	}	2339	}
2353		2340
@@ -2419,28 +2406,6 @@ int iwl_mvm_rm_mcast_sta(struct iwl_mvm mvm, struct ieee80211_vif vif) · 65 unmodified lines
2419		2406
2420	iwl_mvm_disable_txq(mvm, NULL, mvmvif->cab_queue, 0, 0);	2407	iwl_mvm_disable_txq(mvm, NULL, mvmvif->cab_queue, 0, 0);
2421		2408
2422	if (mvmvif->ap_wep_key) {
2423	int i;
2424
2425	if (!__test_and_clear_bit(mvmvif->ap_wep_key->hw_key_idx,
2426	mvm->fw_key_table)) {
2427	IWL_ERR(mvm, "offset %d not used in fw key table.\n",
2428	mvmvif->ap_wep_key->hw_key_idx);
2429	return -ENOENT;
2430	}
2431
2432	/* track which key was deleted last */
2433	for (i = 0; i < STA_KEY_MAX_NUM; i++) {
2434	if (mvm->fw_key_deleted[i] < U8_MAX)
2435	mvm->fw_key_deleted[i]++;
2436	}
2437	mvm->fw_key_deleted[mvmvif->ap_wep_key->hw_key_idx] = 0;
2438	ret = __iwl_mvm_remove_sta_key(mvm, mvmvif->mcast_sta.sta_id,
2439	mvmvif->ap_wep_key, true);
2440	if (ret)
2441	return ret;
2442	}
2443
2444	ret = iwl_mvm_rm_sta_common(mvm, mvmvif->mcast_sta.sta_id);	2409	ret = iwl_mvm_rm_sta_common(mvm, mvmvif->mcast_sta.sta_id);
2445	if (ret)	2410	if (ret)
2446	IWL_WARN(mvm, "Failed sending remove station\n");	2411	IWL_WARN(mvm, "Failed sending remove station\n");

drivers/net/wireless/intel/iwlwifi/mvm/sta.h+2−5

  * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
  * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
  * Copyright(c) 2015 - 2016 Intel Deutschland GmbH
- * Copyright(c) 2018 Intel Corporation
+ * Copyright(c) 2018 - 2019 Intel Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of version 2 of the GNU General Public License as
  * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
  * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
  * Copyright(c) 2015 - 2016 Intel Deutschland GmbH
- * Copyright(c) 2018 Intel Corporation
+ * Copyright(c) 2018 - 2019 Intel Corporation
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  *	the BA window. To be used for UAPSD only.
  * @ptk_pn: per-queue PTK PN data structures
  * @dup_data: per queue duplicate packet detection data
- * @wep_key: used in AP mode. Is a duplicate of the WEP key.
  * @deferred_traffic_tid_map: indication bitmap of deferred traffic per-TID
  * @tx_ant: the index of the antenna to use for data tx to this station. Only
  *	used during connection establishment (e.g. for the 4 way handshake
 	struct iwl_mvm_key_pn __rcu *ptk_pn[4];
 	struct iwl_mvm_rxq_dup_data *dup_data;
-	struct ieee80211_key_conf *wep_key;
 	u8 reserved_queue;
 	/* Temporary, until the new TLC will control the Tx protection */

drivers/net/wireless/intel/iwlwifi/pcie/drv.c+7−6

@@ -953,14 +953,15 @@ static const struct pci_device_id iwl_hw_card_ids[] = { · 952 unmodified lines
953	{IWL_PCI_DEVICE(0xA0F0, 0x1652, killer1650i_2ax_cfg_qu_b0_hr_b0)},	953	{IWL_PCI_DEVICE(0xA0F0, 0x1652, killer1650i_2ax_cfg_qu_b0_hr_b0)},
954	{IWL_PCI_DEVICE(0xA0F0, 0x4070, iwl_ax101_cfg_qu_hr)},	954	{IWL_PCI_DEVICE(0xA0F0, 0x4070, iwl_ax101_cfg_qu_hr)},
955		955
956	{IWL_PCI_DEVICE(0x2723, 0x0080, iwl22260_2ax_cfg)},	956	{IWL_PCI_DEVICE(0x2723, 0x0080, iwl_ax200_cfg_cc)},
957	{IWL_PCI_DEVICE(0x2723, 0x0084, iwl22260_2ax_cfg)},	957	{IWL_PCI_DEVICE(0x2723, 0x0084, iwl_ax200_cfg_cc)},
958	{IWL_PCI_DEVICE(0x2723, 0x0088, iwl22260_2ax_cfg)},	958	{IWL_PCI_DEVICE(0x2723, 0x0088, iwl_ax200_cfg_cc)},
959	{IWL_PCI_DEVICE(0x2723, 0x008C, iwl22260_2ax_cfg)},	959	{IWL_PCI_DEVICE(0x2723, 0x008C, iwl_ax200_cfg_cc)},
960	{IWL_PCI_DEVICE(0x2723, 0x1653, killer1650w_2ax_cfg)},	960	{IWL_PCI_DEVICE(0x2723, 0x1653, killer1650w_2ax_cfg)},
961	{IWL_PCI_DEVICE(0x2723, 0x1654, killer1650x_2ax_cfg)},	961	{IWL_PCI_DEVICE(0x2723, 0x1654, killer1650x_2ax_cfg)},
962	{IWL_PCI_DEVICE(0x2723, 0x4080, iwl22260_2ax_cfg)},	962	{IWL_PCI_DEVICE(0x2723, 0x2080, iwl_ax200_cfg_cc)},
963	{IWL_PCI_DEVICE(0x2723, 0x4088, iwl22260_2ax_cfg)},	963	{IWL_PCI_DEVICE(0x2723, 0x4080, iwl_ax200_cfg_cc)},
		964	{IWL_PCI_DEVICE(0x2723, 0x4088, iwl_ax200_cfg_cc)},
964		965
965	{IWL_PCI_DEVICE(0x1a56, 0x1653, killer1650w_2ax_cfg)},	966	{IWL_PCI_DEVICE(0x1a56, 0x1653, killer1650w_2ax_cfg)},
966	{IWL_PCI_DEVICE(0x1a56, 0x1654, killer1650x_2ax_cfg)},	967	{IWL_PCI_DEVICE(0x1a56, 0x1654, killer1650x_2ax_cfg)},

drivers/net/wireless/intel/iwlwifi/pcie/internal.h+1−1

@@ -1043,7 +1043,7 @@ static inline bool iwl_pcie_dbg_on(struct iwl_trans *trans) · 1042 unmodified lines
1043		1043
1044	void iwl_trans_pcie_rf_kill(struct iwl_trans *trans, bool state);	1044	void iwl_trans_pcie_rf_kill(struct iwl_trans *trans, bool state);
1045	void iwl_trans_pcie_dump_regs(struct iwl_trans *trans);	1045	void iwl_trans_pcie_dump_regs(struct iwl_trans *trans);
1046	void iwl_trans_sync_nmi(struct iwl_trans *trans);	1046	void iwl_trans_pcie_sync_nmi(struct iwl_trans *trans);
1047		1047
1048	#ifdef CONFIG_IWLWIFI_DEBUGFS	1048	#ifdef CONFIG_IWLWIFI_DEBUGFS
1049	int iwl_trans_pcie_dbgfs_register(struct iwl_trans *trans);	1049	int iwl_trans_pcie_dbgfs_register(struct iwl_trans *trans);

drivers/net/wireless/intel/iwlwifi/pcie/trans.c+8−3

 	.unref = iwl_trans_pcie_unref,					\
 	.dump_data = iwl_trans_pcie_dump_data,				\
 	.d3_suspend = iwl_trans_pcie_d3_suspend,			\
-	.d3_resume = iwl_trans_pcie_d3_resume
+	.d3_resume = iwl_trans_pcie_d3_resume,				\
+	.sync_nmi = iwl_trans_pcie_sync_nmi
 #ifdef CONFIG_PM_SLEEP
 #define IWL_TRANS_PM_OPS						\
 		}
 	} else if (cfg == &iwl_ax101_cfg_qu_hr) {
 		if (CSR_HW_RF_ID_TYPE_CHIP_ID(trans->hw_rf_id) ==
+		    CSR_HW_RF_ID_TYPE_CHIP_ID(CSR_HW_RF_ID_TYPE_HR) &&
+		    trans->hw_rev == CSR_HW_REV_TYPE_QNJ_B0) {
+			trans->cfg = &iwl22000_2ax_cfg_qnj_hr_b0;
+		} else if (CSR_HW_RF_ID_TYPE_CHIP_ID(trans->hw_rf_id) ==
 		    CSR_HW_RF_ID_TYPE_CHIP_ID(CSR_HW_RF_ID_TYPE_HR)) {
 			trans->cfg = &iwl_ax101_cfg_qu_hr;
 		} else if (CSR_HW_RF_ID_TYPE_CHIP_ID(trans->hw_rf_id) ==
 		}
 	} else if (CSR_HW_RF_ID_TYPE_CHIP_ID(trans->hw_rf_id) ==
 		   CSR_HW_RF_ID_TYPE_CHIP_ID(CSR_HW_RF_ID_TYPE_HR) &&
-		   (trans->cfg != &iwl22260_2ax_cfg ||
+		   (trans->cfg != &iwl_ax200_cfg_cc ||
 		    trans->hw_rev == CSR_HW_REV_TYPE_QNJ_B0)) {
 		u32 hw_status;
 	return ERR_PTR(ret);
 }
-void iwl_trans_sync_nmi(struct iwl_trans *trans)
+void iwl_trans_pcie_sync_nmi(struct iwl_trans *trans)
 {
 	unsigned long timeout = jiffies + IWL_TRANS_NMI_TIMEOUT;

drivers/net/wireless/intel/iwlwifi/pcie/tx-gen2.c+1−1

@@ -965,7 +965,7 @@ static int iwl_pcie_gen2_send_hcmd_sync(struct iwl_trans *trans, · 964 unmodified lines
965	cmd_str);	965	cmd_str);
966	ret = -ETIMEDOUT;	966	ret = -ETIMEDOUT;
967		967
968	iwl_trans_sync_nmi(trans);	968	iwl_trans_pcie_sync_nmi(trans);
969	goto cancel;	969	goto cancel;
970	}	970	}
971		971

drivers/net/wireless/intel/iwlwifi/pcie/tx.c+1−1

@@ -1960,7 +1960,7 @@ static int iwl_pcie_send_hcmd_sync(struct iwl_trans *trans, · 1959 unmodified lines
1960	iwl_get_cmd_string(trans, cmd->id));	1960	iwl_get_cmd_string(trans, cmd->id));
1961	ret = -ETIMEDOUT;	1961	ret = -ETIMEDOUT;
1962		1962
1963	iwl_trans_sync_nmi(trans);	1963	iwl_trans_pcie_sync_nmi(trans);
1964	goto cancel;	1964	goto cancel;
1965	}	1965	}
1966		1966

drivers/net/wireless/mac80211_hwsim.c+15−4

 	enum nl80211_band band;
 	const struct ieee80211_ops *ops = &mac80211_hwsim_ops;
 	struct net *net;
-	int idx;
+	int idx, i;
 	int n_limits = 0;
 	if (WARN_ON(param->channels > 1 && !param->use_chanctx))
 		goto failed_hw;
 	}
+	data->if_combination.max_interfaces = 0;
+	for (i = 0; i < n_limits; i++)
+		data->if_combination.max_interfaces +=
+			data->if_limits[i].max;
 	data->if_combination.n_limits = n_limits;
-	data->if_combination.max_interfaces = 2048;
 	data->if_combination.limits = data->if_limits;
-	hw->wiphy->iface_combinations = &data->if_combination;
+	/*
-	hw->wiphy->n_iface_combinations = 1;
+	 * If we actually were asked to support combinations,
+	 * advertise them - if there's only a single thing like
+	 * only IBSS then don't advertise it as combinations.
+	 */
+	if (data->if_combination.max_interfaces > 1) {
+		hw->wiphy->iface_combinations = &data->if_combination;
+		hw->wiphy->n_iface_combinations = 1;
+	}
 	if (param->ciphers) {
 		memcpy(data->ciphers, param->ciphers,

drivers/net/wireless/mediatek/mt76/mt7603/init.c+2−0

@@ -510,6 +510,8 @@ int mt7603_register_device(struct mt7603_dev *dev) · 509 unmodified lines
510	bus_ops->rmw = mt7603_rmw;	510	bus_ops->rmw = mt7603_rmw;
511	dev->mt76.bus = bus_ops;	511	dev->mt76.bus = bus_ops;
512		512
		513	spin_lock_init(&dev->ps_lock);
		514
513	INIT_DELAYED_WORK(&dev->mac_work, mt7603_mac_work);	515	INIT_DELAYED_WORK(&dev->mac_work, mt7603_mac_work);
514	tasklet_init(&dev->pre_tbtt_tasklet, mt7603_pre_tbtt_tasklet,	516	tasklet_init(&dev->pre_tbtt_tasklet, mt7603_pre_tbtt_tasklet,
515	(unsigned long)dev);	517	(unsigned long)dev);

drivers/net/wireless/mediatek/mt76/mt7603/mac.c+14−39

 		 MT_BA_CONTROL_1_RESET));
 }
-void mt7603_mac_tx_ba_reset(struct mt7603_dev *dev, int wcid, int tid, int ssn,
+void mt7603_mac_tx_ba_reset(struct mt7603_dev *dev, int wcid, int tid,
 			    int ba_size)
 {
 	u32 addr = mt7603_wtbl2_addr(wcid);
 		mt76_clear(dev, addr + (15 * 4), tid_mask);
 		return;
 	}
-	mt76_poll(dev, MT_WTBL_UPDATE, MT_WTBL_UPDATE_BUSY, 0, 5000);
-	mt7603_mac_stop(dev);
-	switch (tid) {
-	case 0:
-		mt76_rmw_field(dev, addr + (2 * 4), MT_WTBL2_W2_TID0_SN, ssn);
-		break;
-	case 1:
-		mt76_rmw_field(dev, addr + (2 * 4), MT_WTBL2_W2_TID1_SN, ssn);
-		break;
-	case 2:
-		mt76_rmw_field(dev, addr + (2 * 4), MT_WTBL2_W2_TID2_SN_LO,
-			       ssn);
-		mt76_rmw_field(dev, addr + (3 * 4), MT_WTBL2_W3_TID2_SN_HI,
-			       ssn >> 8);
-		break;
-	case 3:
-		mt76_rmw_field(dev, addr + (3 * 4), MT_WTBL2_W3_TID3_SN, ssn);
-		break;
-	case 4:
-		mt76_rmw_field(dev, addr + (3 * 4), MT_WTBL2_W3_TID4_SN, ssn);
-		break;
-	case 5:
-		mt76_rmw_field(dev, addr + (3 * 4), MT_WTBL2_W3_TID5_SN_LO,
-			       ssn);
-		mt76_rmw_field(dev, addr + (4 * 4), MT_WTBL2_W4_TID5_SN_HI,
-			       ssn >> 4);
-		break;
-	case 6:
-		mt76_rmw_field(dev, addr + (4 * 4), MT_WTBL2_W4_TID6_SN, ssn);
-		break;
-	case 7:
-		mt76_rmw_field(dev, addr + (4 * 4), MT_WTBL2_W4_TID7_SN, ssn);
-		break;
-	}
-	mt7603_wtbl_update(dev, wcid, MT_WTBL_UPDATE_WTBL2);
-	mt7603_mac_start(dev);
 	for (i = 7; i > 0; i--) {
 		if (ba_size >= MT_AGG_SIZE_LIMIT(i))
 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 	struct ieee80211_tx_rate *rate = &info->control.rates[0];
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
+	struct ieee80211_bar *bar = (struct ieee80211_bar *)skb->data;
 	struct ieee80211_vif *vif = info->control.vif;
 	struct mt7603_vif *mvif;
 	int wlan_idx;
 	int tx_count = 8;
 	u8 frame_type, frame_subtype;
 	u16 fc = le16_to_cpu(hdr->frame_control);
+	u16 seqno = 0;
 	u8 vif_idx = 0;
 	u32 val;
 	u8 bw;
 		tx_count = 0x1f;
 	val = FIELD_PREP(MT_TXD3_REM_TX_COUNT, tx_count) |
-	      FIELD_PREP(MT_TXD3_SEQ, le16_to_cpu(hdr->seq_ctrl));
+		  MT_TXD3_SN_VALID;
+	if (ieee80211_is_data_qos(hdr->frame_control))
+		seqno = le16_to_cpu(hdr->seq_ctrl);
+	else if (ieee80211_is_back_req(hdr->frame_control))
+		seqno = le16_to_cpu(bar->start_seq_num);
+	else
+		val &= ~MT_TXD3_SN_VALID;
+	val |= FIELD_PREP(MT_TXD3_SEQ, seqno >> 4);
 	txwi[3] = cpu_to_le32(val);
 	if (key) {

drivers/net/wireless/mediatek/mt76/mt7603/main.c+4−4

@@ -372,7 +372,7 @@ mt7603_sta_ps(struct mt76_dev mdev, struct ieee80211_sta sta, bool ps) · 371 unmodified lines
372	struct mt7603_sta msta = (struct mt7603_sta )sta->drv_priv;	372	struct mt7603_sta msta = (struct mt7603_sta )sta->drv_priv;
373	struct sk_buff_head list;	373	struct sk_buff_head list;
374		374
375	mt76_stop_tx_queues(&dev->mt76, sta, false);	375	mt76_stop_tx_queues(&dev->mt76, sta, true);
376	mt7603_wtbl_set_ps(dev, msta, ps);	376	mt7603_wtbl_set_ps(dev, msta, ps);
377	if (ps)	377	if (ps)
378	return;	378	return;
@@ -584,13 +584,13 @@ mt7603_ampdu_action(struct ieee80211_hw hw, struct ieee80211_vif vif, · 205 unmodified lines
584	case IEEE80211_AMPDU_TX_OPERATIONAL:	584	case IEEE80211_AMPDU_TX_OPERATIONAL:
585	mtxq->aggr = true;	585	mtxq->aggr = true;
586	mtxq->send_bar = false;	586	mtxq->send_bar = false;
587	mt7603_mac_tx_ba_reset(dev, msta->wcid.idx, tid, *ssn, ba_size);	587	mt7603_mac_tx_ba_reset(dev, msta->wcid.idx, tid, ba_size);
588	break;	588	break;
589	case IEEE80211_AMPDU_TX_STOP_FLUSH:	589	case IEEE80211_AMPDU_TX_STOP_FLUSH:
590	case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:	590	case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
591	mtxq->aggr = false;	591	mtxq->aggr = false;
592	ieee80211_send_bar(vif, sta->addr, tid, mtxq->agg_ssn);	592	ieee80211_send_bar(vif, sta->addr, tid, mtxq->agg_ssn);
593	mt7603_mac_tx_ba_reset(dev, msta->wcid.idx, tid, *ssn, -1);	593	mt7603_mac_tx_ba_reset(dev, msta->wcid.idx, tid, -1);
594	break;	594	break;
595	case IEEE80211_AMPDU_TX_START:	595	case IEEE80211_AMPDU_TX_START:
596	mtxq->agg_ssn = *ssn << 4;	596	mtxq->agg_ssn = *ssn << 4;
@@ -598,7 +598,7 @@ mt7603_ampdu_action(struct ieee80211_hw hw, struct ieee80211_vif vif, · 1 unmodified line
598	break;	598	break;
599	case IEEE80211_AMPDU_TX_STOP_CONT:	599	case IEEE80211_AMPDU_TX_STOP_CONT:
600	mtxq->aggr = false;	600	mtxq->aggr = false;
601	mt7603_mac_tx_ba_reset(dev, msta->wcid.idx, tid, *ssn, -1);	601	mt7603_mac_tx_ba_reset(dev, msta->wcid.idx, tid, -1);
602	ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);	602	ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
603	break;	603	break;
604	}	604	}

drivers/net/wireless/mediatek/mt76/mt7603/mt7603.h+1−1

@@ -200,7 +200,7 @@ void mt7603_beacon_set_timer(struct mt7603_dev *dev, int idx, int intval); · 199 unmodified lines
200	int mt7603_mac_fill_rx(struct mt7603_dev dev, struct sk_buff skb);	200	int mt7603_mac_fill_rx(struct mt7603_dev dev, struct sk_buff skb);
201	void mt7603_mac_add_txs(struct mt7603_dev dev, void data);	201	void mt7603_mac_add_txs(struct mt7603_dev dev, void data);
202	void mt7603_mac_rx_ba_reset(struct mt7603_dev dev, void addr, u8 tid);	202	void mt7603_mac_rx_ba_reset(struct mt7603_dev dev, void addr, u8 tid);
203	void mt7603_mac_tx_ba_reset(struct mt7603_dev *dev, int wcid, int tid, int ssn,	203	void mt7603_mac_tx_ba_reset(struct mt7603_dev *dev, int wcid, int tid,
204	int ba_size);	204	int ba_size);
205		205
206	void mt7603_pse_client_reset(struct mt7603_dev *dev);	206	void mt7603_pse_client_reset(struct mt7603_dev *dev);

drivers/net/wireless/mediatek/mt76/mt76x02_mac.c+8−6

 		return;
 	rcu_read_lock();
-	mt76_tx_status_lock(mdev, &list);
 	if (stat->wcid < ARRAY_SIZE(dev->mt76.wcid))
 		wcid = rcu_dereference(dev->mt76.wcid[stat->wcid]);
 					  drv_priv);
 	}
+	mt76_tx_status_lock(mdev, &list);
 	if (wcid) {
 		if (stat->pktid >= MT_PACKET_ID_FIRST)
 			status.skb = mt76_tx_status_skb_get(mdev, wcid,
 		if (*update == 0 && stat_val == stat_cache &&
 		    stat->wcid == msta->status.wcid && msta->n_frames < 32) {
 			msta->n_frames++;
-			goto out;
+			mt76_tx_status_unlock(mdev, &list);
+			rcu_read_unlock();
+			return;
 		}
 		mt76x02_mac_fill_tx_status(dev, status.info, &msta->status,
 	if (status.skb)
 		mt76_tx_status_skb_done(mdev, status.skb, &list);
-	else
-		ieee80211_tx_status_ext(mt76_hw(dev), &status);
-out:
 	mt76_tx_status_unlock(mdev, &list);
+	if (!status.skb)
+		ieee80211_tx_status_ext(mt76_hw(dev), &status);
 	rcu_read_unlock();
 }

drivers/net/wireless/ralink/rt2x00/rt2x00.h+0−1

@@ -673,7 +673,6 @@ enum rt2x00_state_flags { · 672 unmodified lines
673	CONFIG_CHANNEL_HT40,	673	CONFIG_CHANNEL_HT40,
674	CONFIG_POWERSAVING,	674	CONFIG_POWERSAVING,
675	CONFIG_HT_DISABLED,	675	CONFIG_HT_DISABLED,
676	CONFIG_QOS_DISABLED,
677	CONFIG_MONITORING,	676	CONFIG_MONITORING,
678		677
679	/*	678	/*

drivers/net/wireless/ralink/rt2x00/rt2x00mac.c+0−10

@@ -642,18 +642,8 @@ void rt2x00mac_bss_info_changed(struct ieee80211_hw *hw, · 641 unmodified lines
642	rt2x00dev->intf_associated--;	642	rt2x00dev->intf_associated--;
643		643
644	rt2x00leds_led_assoc(rt2x00dev, !!rt2x00dev->intf_associated);	644	rt2x00leds_led_assoc(rt2x00dev, !!rt2x00dev->intf_associated);
645
646	clear_bit(CONFIG_QOS_DISABLED, &rt2x00dev->flags);
647	}	645	}
648		646
649	/*
650	* Check for access point which do not support 802.11e . We have to
651	* generate data frames sequence number in S/W for such AP, because
652	* of H/W bug.
653	*/
654	if (changes & BSS_CHANGED_QOS && !bss_conf->qos)
655	set_bit(CONFIG_QOS_DISABLED, &rt2x00dev->flags);
656
657	/*	647	/*
658	* When the erp information has changed, we should perform	648	* When the erp information has changed, we should perform
659	* additional configuration steps. For all other changes we are done.	649	* additional configuration steps. For all other changes we are done.

drivers/net/wireless/ralink/rt2x00/rt2x00queue.c+9−6

 	if (!rt2x00_has_cap_flag(rt2x00dev, REQUIRE_SW_SEQNO)) {
 		/*
 		 * rt2800 has a H/W (or F/W) bug, device incorrectly increase
-		 * seqno on retransmited data (non-QOS) frames. To workaround
+		 * seqno on retransmitted data (non-QOS) and management frames.
-		 * the problem let's generate seqno in software if QOS is
+		 * To workaround the problem let's generate seqno in software.
-		 * disabled.
+		 * Except for beacons which are transmitted periodically by H/W
+		 * hence hardware has to assign seqno for them.
 		 */
-		if (test_bit(CONFIG_QOS_DISABLED, &rt2x00dev->flags))
+	    	if (ieee80211_is_beacon(hdr->frame_control)) {
-			__clear_bit(ENTRY_TXD_GENERATE_SEQ, &txdesc->flags);
+			__set_bit(ENTRY_TXD_GENERATE_SEQ, &txdesc->flags);
-		else
 			/* H/W will generate sequence number */
 			return;
+		}
+		__clear_bit(ENTRY_TXD_GENERATE_SEQ, &txdesc->flags);
 	}
 	/*

drivers/nvdimm/btt_devs.c+13−5

 		return NULL;
 	nd_btt->id = ida_simple_get(&nd_region->btt_ida, 0, 0, GFP_KERNEL);
-	if (nd_btt->id < 0) {
+	if (nd_btt->id < 0)
-		kfree(nd_btt);
+		goto out_nd_btt;
-		return NULL;
-	}
 	nd_btt->lbasize = lbasize;
-	if (uuid)
+	if (uuid) {
 		uuid = kmemdup(uuid, 16, GFP_KERNEL);
+		if (!uuid)
+			goto out_put_id;
+	}
 	nd_btt->uuid = uuid;
 	dev = &nd_btt->dev;
 	dev_set_name(dev, "btt%d.%d", nd_region->id, nd_btt->id);
 		return NULL;
 	}
 	return dev;
+out_put_id:
+	ida_simple_remove(&nd_region->btt_ida, nd_btt->id);
+out_nd_btt:
+	kfree(nd_btt);
+	return NULL;
 }
 struct device *nd_btt_create(struct nd_region *nd_region)

drivers/nvdimm/namespace_devs.c+4−1

 	if (!nsblk->uuid)
 		goto blk_err;
 	memcpy(name, nd_label->name, NSLABEL_NAME_LEN);
-	if (name[0])
+	if (name[0]) {
 		nsblk->alt_name = kmemdup(name, NSLABEL_NAME_LEN,
 				GFP_KERNEL);
+		if (!nsblk->alt_name)
+			goto blk_err;
+	}
 	res = nsblk_add_resource(nd_region, ndd, nsblk,
 			__le64_to_cpu(nd_label->dpa));
 	if (!res)

drivers/nvdimm/pmem.c+4−4

@@ -113,13 +113,13 @@ static void write_pmem(void pmem_addr, struct page page, · 112 unmodified lines
113		113
114	while (len) {	114	while (len) {
115	mem = kmap_atomic(page);	115	mem = kmap_atomic(page);
116	chunk = min_t(unsigned int, len, PAGE_SIZE);	116	chunk = min_t(unsigned int, len, PAGE_SIZE - off);
117	memcpy_flushcache(pmem_addr, mem + off, chunk);	117	memcpy_flushcache(pmem_addr, mem + off, chunk);
118	kunmap_atomic(mem);	118	kunmap_atomic(mem);
119	len -= chunk;	119	len -= chunk;
120	off = 0;	120	off = 0;
121	page++;	121	page++;
122	pmem_addr += PAGE_SIZE;	122	pmem_addr += chunk;
123	}	123	}
124	}	124	}
125		125
@@ -132,7 +132,7 @@ static blk_status_t read_pmem(struct page *page, unsigned int off, · 6 unmodified lines
132		132
133	while (len) {	133	while (len) {
134	mem = kmap_atomic(page);	134	mem = kmap_atomic(page);
135	chunk = min_t(unsigned int, len, PAGE_SIZE);	135	chunk = min_t(unsigned int, len, PAGE_SIZE - off);
136	rem = memcpy_mcsafe(mem + off, pmem_addr, chunk);	136	rem = memcpy_mcsafe(mem + off, pmem_addr, chunk);
137	kunmap_atomic(mem);	137	kunmap_atomic(mem);
138	if (rem)	138	if (rem)
@@ -140,7 +140,7 @@ static blk_status_t read_pmem(struct page *page, unsigned int off, · 1 unmodified line
140	len -= chunk;	140	len -= chunk;
141	off = 0;	141	off = 0;
142	page++;	142	page++;
143	pmem_addr += PAGE_SIZE;	143	pmem_addr += chunk;
144	}	144	}
145	return BLK_STS_OK;	145	return BLK_STS_OK;
146	}	146	}

drivers/nvdimm/security.c+73−45

@@ -22,6 +22,8 @@ static bool key_revalidate = true; · 21 unmodified lines
22	module_param(key_revalidate, bool, 0444);	22	module_param(key_revalidate, bool, 0444);
23	MODULE_PARM_DESC(key_revalidate, "Require key validation at init.");	23	MODULE_PARM_DESC(key_revalidate, "Require key validation at init.");
24		24
		25	static const char zero_key[NVDIMM_PASSPHRASE_LEN];
		26
25	static void key_data(struct key key)	27	static void key_data(struct key key)
26	{	28	{
27	struct encrypted_key_payload *epayload = dereference_key_locked(key);	29	struct encrypted_key_payload *epayload = dereference_key_locked(key);
@@ -75,6 +77,16 @@ static struct key nvdimm_request_key(struct nvdimm nvdimm) · 47 unmodified lines
75	return key;	77	return key;
76	}	78	}
77		79
		80	static const void nvdimm_get_key_payload(struct nvdimm nvdimm,
		81	struct key **key)
		82	{
		83	*key = nvdimm_request_key(nvdimm);
		84	if (!*key)
		85	return zero_key;
		86
		87	return key_data(*key);
		88	}
		89
78	static struct key nvdimm_lookup_user_key(struct nvdimm nvdimm,	90	static struct key nvdimm_lookup_user_key(struct nvdimm nvdimm,
79	key_serial_t id, int subclass)	91	key_serial_t id, int subclass)
80	{	92	{
@@ -105,36 +117,57 @@ static struct key nvdimm_lookup_user_key(struct nvdimm nvdimm, · 24 unmodified lines
105	return key;	117	return key;
106	}	118	}
107		119
108	static struct key nvdimm_key_revalidate(struct nvdimm nvdimm)	120	static const void nvdimm_get_user_key_payload(struct nvdimm nvdimm,
		121	key_serial_t id, int subclass, struct key **key)
		122	{
		123	*key = NULL;
		124	if (id == 0) {
		125	if (subclass == NVDIMM_BASE_KEY)
		126	return zero_key;
		127	else
		128	return NULL;
		129	}
		130
		131	*key = nvdimm_lookup_user_key(nvdimm, id, subclass);
		132	if (!*key)
		133	return NULL;
		134
		135	return key_data(*key);
		136	}
		137
		138
		139	static int nvdimm_key_revalidate(struct nvdimm *nvdimm)
109	{	140	{
110	struct key *key;	141	struct key *key;
111	int rc;	142	int rc;
		143	const void *data;
112		144
113	if (!nvdimm->sec.ops->change_key)	145	if (!nvdimm->sec.ops->change_key)
114	return NULL;	146	return -EOPNOTSUPP;
115		147
116	key = nvdimm_request_key(nvdimm);	148	data = nvdimm_get_key_payload(nvdimm, &key);
117	if (!key)
118	return NULL;
119		149
120	/*	150	/*
121	* Send the same key to the hardware as new and old key to	151	* Send the same key to the hardware as new and old key to
122	* verify that the key is good.	152	* verify that the key is good.
123	*/	153	*/
124	rc = nvdimm->sec.ops->change_key(nvdimm, key_data(key),	154	rc = nvdimm->sec.ops->change_key(nvdimm, data, data, NVDIMM_USER);
125	key_data(key), NVDIMM_USER);
126	if (rc < 0) {	155	if (rc < 0) {
127	nvdimm_put_key(key);	156	nvdimm_put_key(key);
128	key = NULL;	157	return rc;
129	}	158	}
130	return key;	159
		160	nvdimm_put_key(key);
		161	nvdimm->sec.state = nvdimm_security_state(nvdimm, NVDIMM_USER);
		162	return 0;
131	}	163	}
132		164
133	static int __nvdimm_security_unlock(struct nvdimm *nvdimm)	165	static int __nvdimm_security_unlock(struct nvdimm *nvdimm)
134	{	166	{
135	struct device *dev = &nvdimm->dev;	167	struct device *dev = &nvdimm->dev;
136	struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);	168	struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
137	struct key *key = NULL;	169	struct key *key;
		170	const void *data;
138	int rc;	171	int rc;
139		172
140	/* The bus lock should be held at the top level of the call stack */	173	/* The bus lock should be held at the top level of the call stack */
@@ -160,16 +193,11 @@ static int __nvdimm_security_unlock(struct nvdimm *nvdimm) · 19 unmodified lines
160	if (!key_revalidate)	193	if (!key_revalidate)
161	return 0;	194	return 0;
162		195
163	key = nvdimm_key_revalidate(nvdimm);	196	return nvdimm_key_revalidate(nvdimm);
164	if (!key)
165	return nvdimm_security_freeze(nvdimm);
166	} else	197	} else
167	key = nvdimm_request_key(nvdimm);	198	data = nvdimm_get_key_payload(nvdimm, &key);
168		199
169	if (!key)	200	rc = nvdimm->sec.ops->unlock(nvdimm, data);
170	return -ENOKEY;
171
172	rc = nvdimm->sec.ops->unlock(nvdimm, key_data(key));
173	dev_dbg(dev, "key: %d unlock: %s\n", key_serial(key),	201	dev_dbg(dev, "key: %d unlock: %s\n", key_serial(key),
174	rc == 0 ? "success" : "fail");	202	rc == 0 ? "success" : "fail");
175		203
@@ -195,6 +223,7 @@ int nvdimm_security_disable(struct nvdimm *nvdimm, unsigned int keyid) · 19 unmodified lines
195	struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);	223	struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
196	struct key *key;	224	struct key *key;
197	int rc;	225	int rc;
		226	const void *data;
198		227
199	/* The bus lock should be held at the top level of the call stack */	228	/* The bus lock should be held at the top level of the call stack */
200	lockdep_assert_held(&nvdimm_bus->reconfig_mutex);	229	lockdep_assert_held(&nvdimm_bus->reconfig_mutex);
@@ -214,11 +243,12 @@ int nvdimm_security_disable(struct nvdimm *nvdimm, unsigned int keyid) · 13 unmodified lines
214	return -EBUSY;	243	return -EBUSY;
215	}	244	}
216		245
217	key = nvdimm_lookup_user_key(nvdimm, keyid, NVDIMM_BASE_KEY);	246	data = nvdimm_get_user_key_payload(nvdimm, keyid,
218	if (!key)	247	NVDIMM_BASE_KEY, &key);
		248	if (!data)
219	return -ENOKEY;	249	return -ENOKEY;
220		250
221	rc = nvdimm->sec.ops->disable(nvdimm, key_data(key));	251	rc = nvdimm->sec.ops->disable(nvdimm, data);
222	dev_dbg(dev, "key: %d disable: %s\n", key_serial(key),	252	dev_dbg(dev, "key: %d disable: %s\n", key_serial(key),
223	rc == 0 ? "success" : "fail");	253	rc == 0 ? "success" : "fail");
224		254
@@ -235,6 +265,7 @@ int nvdimm_security_update(struct nvdimm *nvdimm, unsigned int keyid, · 10 unmodified lines
235	struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);	265	struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
236	struct key key, newkey;	266	struct key key, newkey;
237	int rc;	267	int rc;
		268	const void data, newdata;
238		269
239	/* The bus lock should be held at the top level of the call stack */	270	/* The bus lock should be held at the top level of the call stack */
240	lockdep_assert_held(&nvdimm_bus->reconfig_mutex);	271	lockdep_assert_held(&nvdimm_bus->reconfig_mutex);
@@ -249,22 +280,19 @@ int nvdimm_security_update(struct nvdimm *nvdimm, unsigned int keyid, · 8 unmodified lines
249	return -EIO;	280	return -EIO;
250	}	281	}
251		282
252	if (keyid == 0)	283	data = nvdimm_get_user_key_payload(nvdimm, keyid,
253	key = NULL;	284	NVDIMM_BASE_KEY, &key);
254	else {	285	if (!data)
255	key = nvdimm_lookup_user_key(nvdimm, keyid, NVDIMM_BASE_KEY);	286	return -ENOKEY;
256	if (!key)
257	return -ENOKEY;
258	}
259		287
260	newkey = nvdimm_lookup_user_key(nvdimm, new_keyid, NVDIMM_NEW_KEY);	288	newdata = nvdimm_get_user_key_payload(nvdimm, new_keyid,
261	if (!newkey) {	289	NVDIMM_NEW_KEY, &newkey);
		290	if (!newdata) {
262	nvdimm_put_key(key);	291	nvdimm_put_key(key);
263	return -ENOKEY;	292	return -ENOKEY;
264	}	293	}
265		294
266	rc = nvdimm->sec.ops->change_key(nvdimm, key ? key_data(key) : NULL,	295	rc = nvdimm->sec.ops->change_key(nvdimm, data, newdata, pass_type);
267	key_data(newkey), pass_type);
268	dev_dbg(dev, "key: %d %d update%s: %s\n",	296	dev_dbg(dev, "key: %d %d update%s: %s\n",
269	key_serial(key), key_serial(newkey),	297	key_serial(key), key_serial(newkey),
270	pass_type == NVDIMM_MASTER ? "(master)" : "(user)",	298	pass_type == NVDIMM_MASTER ? "(master)" : "(user)",
@@ -286,8 +314,9 @@ int nvdimm_security_erase(struct nvdimm *nvdimm, unsigned int keyid, · 15 unmodified lines
286	{	314	{
287	struct device *dev = &nvdimm->dev;	315	struct device *dev = &nvdimm->dev;
288	struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);	316	struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
289	struct key *key;	317	struct key *key = NULL;
290	int rc;	318	int rc;
		319	const void *data;
291		320
292	/* The bus lock should be held at the top level of the call stack */	321	/* The bus lock should be held at the top level of the call stack */
293	lockdep_assert_held(&nvdimm_bus->reconfig_mutex);	322	lockdep_assert_held(&nvdimm_bus->reconfig_mutex);
@@ -319,11 +348,12 @@ int nvdimm_security_erase(struct nvdimm *nvdimm, unsigned int keyid, · 25 unmodified lines
319	return -EOPNOTSUPP;	348	return -EOPNOTSUPP;
320	}	349	}
321		350
322	key = nvdimm_lookup_user_key(nvdimm, keyid, NVDIMM_BASE_KEY);	351	data = nvdimm_get_user_key_payload(nvdimm, keyid,
323	if (!key)	352	NVDIMM_BASE_KEY, &key);
		353	if (!data)
324	return -ENOKEY;	354	return -ENOKEY;
325		355
326	rc = nvdimm->sec.ops->erase(nvdimm, key_data(key), pass_type);	356	rc = nvdimm->sec.ops->erase(nvdimm, data, pass_type);
327	dev_dbg(dev, "key: %d erase%s: %s\n", key_serial(key),	357	dev_dbg(dev, "key: %d erase%s: %s\n", key_serial(key),
328	pass_type == NVDIMM_MASTER ? "(master)" : "(user)",	358	pass_type == NVDIMM_MASTER ? "(master)" : "(user)",
329	rc == 0 ? "success" : "fail");	359	rc == 0 ? "success" : "fail");
@@ -337,8 +367,9 @@ int nvdimm_security_overwrite(struct nvdimm *nvdimm, unsigned int keyid) · 7 unmodified lines
337	{	367	{
338	struct device *dev = &nvdimm->dev;	368	struct device *dev = &nvdimm->dev;
339	struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);	369	struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
340	struct key *key;	370	struct key *key = NULL;
341	int rc;	371	int rc;
		372	const void *data;
342		373
343	/* The bus lock should be held at the top level of the call stack */	374	/* The bus lock should be held at the top level of the call stack */
344	lockdep_assert_held(&nvdimm_bus->reconfig_mutex);	375	lockdep_assert_held(&nvdimm_bus->reconfig_mutex);
@@ -368,15 +399,12 @@ int nvdimm_security_overwrite(struct nvdimm *nvdimm, unsigned int keyid) · 23 unmodified lines
368	return -EBUSY;	399	return -EBUSY;
369	}	400	}
370		401
371	if (keyid == 0)	402	data = nvdimm_get_user_key_payload(nvdimm, keyid,
372	key = NULL;	403	NVDIMM_BASE_KEY, &key);
373	else {	404	if (!data)
374	key = nvdimm_lookup_user_key(nvdimm, keyid, NVDIMM_BASE_KEY);	405	return -ENOKEY;
375	if (!key)
376	return -ENOKEY;
377	}
378		406
379	rc = nvdimm->sec.ops->overwrite(nvdimm, key ? key_data(key) : NULL);	407	rc = nvdimm->sec.ops->overwrite(nvdimm, data);
380	dev_dbg(dev, "key: %d overwrite submission: %s\n", key_serial(key),	408	dev_dbg(dev, "key: %d overwrite submission: %s\n", key_serial(key),
381	rc == 0 ? "success" : "fail");	409	rc == 0 ? "success" : "fail");
382		410

drivers/nvme/host/core.c+1−1

@@ -288,7 +288,7 @@ bool nvme_cancel_request(struct request req, void data, bool reserved) · 287 unmodified lines
288	"Cancelling I/O %d", req->tag);	288	"Cancelling I/O %d", req->tag);
289		289
290	nvme_req(req)->status = NVME_SC_ABORT_REQ;	290	nvme_req(req)->status = NVME_SC_ABORT_REQ;
291	blk_mq_complete_request(req);	291	blk_mq_complete_request_sync(req);
292	return true;	292	return true;
293	}	293	}
294	EXPORT_SYMBOL_GPL(nvme_cancel_request);	294	EXPORT_SYMBOL_GPL(nvme_cancel_request);

drivers/nvme/host/fc.c+15−5

 	memset(queue, 0, sizeof(*queue));
 	queue->ctrl = ctrl;
 	queue->qnum = idx;
-	atomic_set(&queue->csn, 1);
+	atomic_set(&queue->csn, 0);
 	queue->dev = ctrl->dev;
 	if (idx > 0)
 	 */
 	queue->connection_id = 0;
-	atomic_set(&queue->csn, 1);
+	atomic_set(&queue->csn, 0);
 }
 static void
 {
 	struct nvme_fc_cmd_iu *cmdiu = &op->cmd_iu;
 	struct nvme_command *sqe = &cmdiu->sqe;
-	u32 csn;
 	int ret, opstate;
 	/*
 	/* format the FC-NVME CMD IU and fcp_req */
 	cmdiu->connection_id = cpu_to_be64(queue->connection_id);
-	csn = atomic_inc_return(&queue->csn);
-	cmdiu->csn = cpu_to_be32(csn);
 	cmdiu->data_len = cpu_to_be32(data_len);
 	switch (io_dir) {
 	case NVMEFC_FCP_WRITE:
 	if (!(op->flags & FCOP_FLAGS_AEN))
 		blk_mq_start_request(op->rq);
+	cmdiu->csn = cpu_to_be32(atomic_inc_return(&queue->csn));
 	ret = ctrl->lport->ops->fcp_io(&ctrl->lport->localport,
 					&ctrl->rport->remoteport,
 					queue->lldd_handle, &op->fcp_req);
 	if (ret) {
+		/*
+		 * If the lld fails to send the command is there an issue with
+		 * the csn value?  If the command that fails is the Connect,
+		 * no - as the connection won't be live.  If it is a command
+		 * post-connect, it's possible a gap in csn may be created.
+		 * Does this matter?  As Linux initiators don't send fused
+		 * commands, no.  The gap would exist, but as there's nothing
+		 * that depends on csn order to be delivered on the target
+		 * side, it shouldn't hurt.  It would be difficult for a
+		 * target to even detect the csn gap as it has no idea when the
+		 * cmd with the csn was supposed to arrive.
+		 */
 		opstate = atomic_xchg(&op->state, FCPOP_STATE_COMPLETE);
 		__nvme_fc_fcpop_chk_teardowns(ctrl, op, opstate);

drivers/nvme/target/admin-cmd.c+5−0

 	return len;
 }
+u64 nvmet_get_log_page_offset(struct nvme_command *cmd)
+{
+	return le64_to_cpu(cmd->get_log_page.lpo);
+}
 static void nvmet_execute_get_log_page_noop(struct nvmet_req *req)
 {
 	nvmet_req_complete(req, nvmet_zero_sgl(req, 0, req->data_len));

drivers/nvme/target/discovery.c+45−23

@@ -131,54 +131,76 @@ static void nvmet_set_disc_traddr(struct nvmet_req req, struct nvmet_port port · 130 unmodified lines
131	memcpy(traddr, port->disc_addr.traddr, NVMF_TRADDR_SIZE);	131	memcpy(traddr, port->disc_addr.traddr, NVMF_TRADDR_SIZE);
132	}	132	}
133		133
		134	static size_t discovery_log_entries(struct nvmet_req *req)
		135	{
		136	struct nvmet_ctrl *ctrl = req->sq->ctrl;
		137	struct nvmet_subsys_link *p;
		138	struct nvmet_port *r;
		139	size_t entries = 0;
		140
		141	list_for_each_entry(p, &req->port->subsystems, entry) {
		142	if (!nvmet_host_allowed(p->subsys, ctrl->hostnqn))
		143	continue;
		144	entries++;
		145	}
		146	list_for_each_entry(r, &req->port->referrals, entry)
		147	entries++;
		148	return entries;
		149	}
		150
134	static void nvmet_execute_get_disc_log_page(struct nvmet_req *req)	151	static void nvmet_execute_get_disc_log_page(struct nvmet_req *req)
135	{	152	{
136	const int entry_size = sizeof(struct nvmf_disc_rsp_page_entry);	153	const int entry_size = sizeof(struct nvmf_disc_rsp_page_entry);
137	struct nvmet_ctrl *ctrl = req->sq->ctrl;	154	struct nvmet_ctrl *ctrl = req->sq->ctrl;
138	struct nvmf_disc_rsp_page_hdr *hdr;	155	struct nvmf_disc_rsp_page_hdr *hdr;
		156	u64 offset = nvmet_get_log_page_offset(req->cmd);
139	size_t data_len = nvmet_get_log_page_len(req->cmd);	157	size_t data_len = nvmet_get_log_page_len(req->cmd);
140	size_t alloc_len = max(data_len, sizeof(*hdr));	158	size_t alloc_len;
141	int residual_len = data_len - sizeof(*hdr);
142	struct nvmet_subsys_link *p;	159	struct nvmet_subsys_link *p;
143	struct nvmet_port *r;	160	struct nvmet_port *r;
144	u32 numrec = 0;	161	u32 numrec = 0;
145	u16 status = 0;	162	u16 status = 0;
		163	void *buffer;
		164
		165	/* Spec requires dword aligned offsets */
		166	if (offset & 0x3) {
		167	status = NVME_SC_INVALID_FIELD \| NVME_SC_DNR;
		168	goto out;
		169	}
146		170
147	/*	171	/*
148	* Make sure we're passing at least a buffer of response header size.	172	* Make sure we're passing at least a buffer of response header size.
149	* If host provided data len is less than the header size, only the	173	* If host provided data len is less than the header size, only the
150	* number of bytes requested by host will be sent to host.	174	* number of bytes requested by host will be sent to host.
151	*/	175	*/
152	hdr = kzalloc(alloc_len, GFP_KERNEL);	176	down_read(&nvmet_config_sem);
153	if (!hdr) {	177	alloc_len = sizeof(hdr) + entry_size discovery_log_entries(req);
		178	buffer = kzalloc(alloc_len, GFP_KERNEL);
		179	if (!buffer) {
		180	up_read(&nvmet_config_sem);
154	status = NVME_SC_INTERNAL;	181	status = NVME_SC_INTERNAL;
155	goto out;	182	goto out;
156	}	183	}
157		184
158	down_read(&nvmet_config_sem);	185	hdr = buffer;
159	list_for_each_entry(p, &req->port->subsystems, entry) {	186	list_for_each_entry(p, &req->port->subsystems, entry) {
		187	char traddr[NVMF_TRADDR_SIZE];
		188
160	if (!nvmet_host_allowed(p->subsys, ctrl->hostnqn))	189	if (!nvmet_host_allowed(p->subsys, ctrl->hostnqn))
161	continue;	190	continue;
162	if (residual_len >= entry_size) {	191
163	char traddr[NVMF_TRADDR_SIZE];	192	nvmet_set_disc_traddr(req, req->port, traddr);
164		193	nvmet_format_discovery_entry(hdr, req->port,
165	nvmet_set_disc_traddr(req, req->port, traddr);	194	p->subsys->subsysnqn, traddr,
166	nvmet_format_discovery_entry(hdr, req->port,	195	NVME_NQN_NVME, numrec);
167	p->subsys->subsysnqn, traddr,
168	NVME_NQN_NVME, numrec);
169	residual_len -= entry_size;
170	}
171	numrec++;	196	numrec++;
172	}	197	}
173		198
174	list_for_each_entry(r, &req->port->referrals, entry) {	199	list_for_each_entry(r, &req->port->referrals, entry) {
175	if (residual_len >= entry_size) {	200	nvmet_format_discovery_entry(hdr, r,
176	nvmet_format_discovery_entry(hdr, r,	201	NVME_DISC_SUBSYS_NAME,
177	NVME_DISC_SUBSYS_NAME,	202	r->disc_addr.traddr,
178	r->disc_addr.traddr,	203	NVME_NQN_DISC, numrec);
179	NVME_NQN_DISC, numrec);
180	residual_len -= entry_size;
181	}
182	numrec++;	204	numrec++;
183	}	205	}
184		206
@@ -190,8 +212,8 @@ static void nvmet_execute_get_disc_log_page(struct nvmet_req *req) · 5 unmodified lines
190		212
191	up_read(&nvmet_config_sem);	213	up_read(&nvmet_config_sem);
192		214
193	status = nvmet_copy_to_sgl(req, 0, hdr, data_len);	215	status = nvmet_copy_to_sgl(req, 0, buffer + offset, data_len);
194	kfree(hdr);	216	kfree(buffer);
195	out:	217	out:
196	nvmet_req_complete(req, status);	218	nvmet_req_complete(req, status);
197	}	219	}

drivers/nvme/target/nvmet.h+1−0

@@ -428,6 +428,7 @@ u16 nvmet_copy_from_sgl(struct nvmet_req req, off_t off, void buf, · 427 unmodified lines
428	u16 nvmet_zero_sgl(struct nvmet_req *req, off_t off, size_t len);	428	u16 nvmet_zero_sgl(struct nvmet_req *req, off_t off, size_t len);
429		429
430	u32 nvmet_get_log_page_len(struct nvme_command *cmd);	430	u32 nvmet_get_log_page_len(struct nvme_command *cmd);
		431	u64 nvmet_get_log_page_offset(struct nvme_command *cmd);
431		432
432	extern struct list_head *nvmet_ports;	433	extern struct list_head *nvmet_ports;
433	void nvmet_port_disc_changed(struct nvmet_port *port,	434	void nvmet_port_disc_changed(struct nvmet_port *port,

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/pci/hotplug/pciehp_ctrl.c+4−0

 		 * removed from the slot/adapter.
 		 */
 		msleep(1000);
+		/* Ignore link or presence changes caused by power off */
+		atomic_and(~(PCI_EXP_SLTSTA_DLLSC | PCI_EXP_SLTSTA_PDC),
+			   &ctrl->pending_events);
 	}
 	/* turn off Green LED */

drivers/pci/quirks.c+2−0

 /* https://bugzilla.kernel.org/show_bug.cgi?id=42679#c14 */
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_MARVELL_EXT, 0x9130,
 			 quirk_dma_func1_alias);
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_MARVELL_EXT, 0x9170,
+			 quirk_dma_func1_alias);
 /* https://bugzilla.kernel.org/show_bug.cgi?id=42679#c47 + c57 */
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_MARVELL_EXT, 0x9172,
 			 quirk_dma_func1_alias);

drivers/platform/x86/pmc_atom.c+21−0

 #include <linux/debugfs.h>
 #include <linux/device.h>
+#include <linux/dmi.h>
 #include <linux/init.h>
 #include <linux/io.h>
 #include <linux/platform_data/x86/clk-pmc-atom.h>
 }
 #endif /* CONFIG_DEBUG_FS */
+/*
+ * Some systems need one or more of their pmc_plt_clks to be
+ * marked as critical.
+ */
+static const struct dmi_system_id critclk_systems[] = {
+	{
+		.ident = "MPL CEC1x",
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "MPL AG"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "CEC10 Family"),
+		},
+	},
+	{ /*sentinel*/ }
+};
 static int pmc_setup_clks(struct pci_dev *pdev, void __iomem *pmc_regmap,
 			  const struct pmc_data *pmc_data)
 {
 	struct platform_device *clkdev;
 	struct pmc_clk_data *clk_data;
+	const struct dmi_system_id *d = dmi_first_match(critclk_systems);
 	clk_data = kzalloc(sizeof(*clk_data), GFP_KERNEL);
 	if (!clk_data)
 	clk_data->base = pmc_regmap; /* offset is added by client */
 	clk_data->clks = pmc_data->clks;
+	if (d) {
+		clk_data->critical = true;
+		pr_info("%s critclks quirk enabled\n", d->ident);
+	}
 	clkdev = platform_device_register_data(&pdev->dev, "clk-pmc-atom",
 					       PLATFORM_DEVID_NONE,

drivers/power/supply/goldfish_battery.c+1−1

@@ -1,4 +1,4 @@
1	// SPDX-License-Identifier: GPL	1	// SPDX-License-Identifier: GPL-2.0
2	/*	2	/*
3	* Power supply driver for the goldfish emulator	3	* Power supply driver for the goldfish emulator
4	*	4	*

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/s390/block/dasd_eckd.c+3−3

@@ -2004,14 +2004,14 @@ static int dasd_eckd_end_analysis(struct dasd_block *block) · 2003 unmodified lines
2004	blk_per_trk = recs_per_track(&private->rdc_data, 0, block->bp_block);	2004	blk_per_trk = recs_per_track(&private->rdc_data, 0, block->bp_block);
2005		2005
2006	raw:	2006	raw:
2007	block->blocks = (private->real_cyl *	2007	block->blocks = ((unsigned long) private->real_cyl *
2008	private->rdc_data.trk_per_cyl *	2008	private->rdc_data.trk_per_cyl *
2009	blk_per_trk);	2009	blk_per_trk);
2010		2010
2011	dev_info(&device->cdev->dev,	2011	dev_info(&device->cdev->dev,
2012	"DASD with %d KB/block, %d KB total size, %d KB/track, "	2012	"DASD with %u KB/block, %lu KB total size, %u KB/track, "
2013	"%s\n", (block->bp_block >> 10),	2013	"%s\n", (block->bp_block >> 10),
2014	((private->real_cyl *	2014	(((unsigned long) private->real_cyl *
2015	private->rdc_data.trk_per_cyl *	2015	private->rdc_data.trk_per_cyl *
2016	blk_per_trk * (block->bp_block >> 9)) >> 1),	2016	blk_per_trk * (block->bp_block >> 9)) >> 1),
2017	((blk_per_trk * block->bp_block) >> 10),	2017	((blk_per_trk * block->bp_block) >> 10),

drivers/s390/char/con3270.c+1−1

@@ -629,7 +629,7 @@ con3270_init(void) · 628 unmodified lines
629	(void (*)(unsigned long)) con3270_read_tasklet,	629	(void (*)(unsigned long)) con3270_read_tasklet,
630	(unsigned long) condev->read);	630	(unsigned long) condev->read);
631		631
632	raw3270_add_view(&condev->view, &con3270_fn, 1);	632	raw3270_add_view(&condev->view, &con3270_fn, 1, RAW3270_VIEW_LOCK_IRQ);
633		633
634	INIT_LIST_HEAD(&condev->freemem);	634	INIT_LIST_HEAD(&condev->freemem);
635	for (i = 0; i < CON3270_STRING_PAGES; i++) {	635	for (i = 0; i < CON3270_STRING_PAGES; i++) {

drivers/s390/char/fs3270.c+2−1

@@ -463,7 +463,8 @@ fs3270_open(struct inode inode, struct file filp) · 462 unmodified lines
463		463
464	init_waitqueue_head(&fp->wait);	464	init_waitqueue_head(&fp->wait);
465	fp->fs_pid = get_pid(task_pid(current));	465	fp->fs_pid = get_pid(task_pid(current));
466	rc = raw3270_add_view(&fp->view, &fs3270_fn, minor);	466	rc = raw3270_add_view(&fp->view, &fs3270_fn, minor,
		467	RAW3270_VIEW_LOCK_BH);
467	if (rc) {	468	if (rc) {
468	fs3270_free_view(&fp->view);	469	fs3270_free_view(&fp->view);
469	goto out;	470	goto out;

drivers/s390/char/raw3270.c+2−1

  * Add view to device with minor "minor".
  */
 int
-raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor)
+raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor, int subclass)
 {
 	unsigned long flags;
 	struct raw3270 *rp;
 		view->cols = rp->cols;
 		view->ascebc = rp->ascebc;
 		spin_lock_init(&view->lock);
+		lockdep_set_subclass(&view->lock, subclass);
 		list_add(&view->list, &rp->view_list);
 		rc = 0;
 		spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);

drivers/s390/char/raw3270.h+3−1

 struct raw3270_view {
 	struct list_head list;
 	spinlock_t lock;
+#define RAW3270_VIEW_LOCK_IRQ	0
+#define RAW3270_VIEW_LOCK_BH	1
 	atomic_t ref_count;
 	struct raw3270 *dev;
 	struct raw3270_fn *fn;
 	unsigned char *ascebc;		/* ascii -> ebcdic table */
 };
-int raw3270_add_view(struct raw3270_view *, struct raw3270_fn *, int);
+int raw3270_add_view(struct raw3270_view *, struct raw3270_fn *, int, int);
 int raw3270_activate_view(struct raw3270_view *);
 void raw3270_del_view(struct raw3270_view *);
 void raw3270_deactivate_view(struct raw3270_view *);

drivers/s390/char/tty3270.c+2−1

@@ -980,7 +980,8 @@ static int tty3270_install(struct tty_driver driver, struct tty_struct tty) · 979 unmodified lines
980	return PTR_ERR(tp);	980	return PTR_ERR(tp);
981		981
982	rc = raw3270_add_view(&tp->view, &tty3270_fn,	982	rc = raw3270_add_view(&tp->view, &tty3270_fn,
983	tty->index + RAW3270_FIRSTMINOR);	983	tty->index + RAW3270_FIRSTMINOR,
		984	RAW3270_VIEW_LOCK_BH);
984	if (rc) {	985	if (rc) {
985	tty3270_free_view(tp);	986	tty3270_free_view(tp);
986	return rc;	987	return rc;

drivers/s390/crypto/ap_queue.c+1−1

 	__ap_flush_queue(aq);
 	/* set REMOVE state to prevent new messages are queued in */
 	aq->state = AP_STATE_REMOVE;
-	del_timer_sync(&aq->timeout);
 	spin_unlock_bh(&aq->lock);
+	del_timer_sync(&aq->timeout);
 }
 void ap_queue_remove(struct ap_queue *aq)

drivers/s390/crypto/pkey_api.c+2−1

@@ -51,7 +51,8 @@ static debug_info_t *debug_info; · 50 unmodified lines
51		51
52	static void __init pkey_debug_init(void)	52	static void __init pkey_debug_init(void)
53	{	53	{
54	debug_info = debug_register("pkey", 1, 1, 4 * sizeof(long));	54	/* 5 arguments per dbf entry (including the format string ptr) */
		55	debug_info = debug_register("pkey", 1, 1, 5 * sizeof(long));
55	debug_register_view(debug_info, &debug_sprintf_view);	56	debug_register_view(debug_info, &debug_sprintf_view);
56	debug_set_level(debug_info, 3);	57	debug_set_level(debug_info, 3);
57	}	58	}

drivers/scsi/aic7xxx/aic7770_osm.c+1−0

@@ -91,6 +91,7 @@ aic7770_probe(struct device *dev) · 90 unmodified lines
91	ahc = ahc_alloc(&aic7xxx_driver_template, name);	91	ahc = ahc_alloc(&aic7xxx_driver_template, name);
92	if (ahc == NULL)	92	if (ahc == NULL)
93	return (ENOMEM);	93	return (ENOMEM);
		94	ahc->dev = dev;
94	error = aic7770_config(ahc, aic7770_ident_table + edev->id.driver_data,	95	error = aic7770_config(ahc, aic7770_ident_table + edev->id.driver_data,
95	eisaBase);	96	eisaBase);
96	if (error != 0) {	97	if (error != 0) {

drivers/scsi/aic7xxx/aic7xxx.h+1−0

@@ -943,6 +943,7 @@ struct ahc_softc { · 942 unmodified lines
943	* Platform specific device information.	943	* Platform specific device information.
944	*/	944	*/
945	ahc_dev_softc_t dev_softc;	945	ahc_dev_softc_t dev_softc;
		946	struct device *dev;
946		947
947	/*	948	/*
948	* Bus specific device information.	949	* Bus specific device information.

drivers/scsi/aic7xxx/aic7xxx_osm.c+4−6

 ahc_dmamem_alloc(struct ahc_softc *ahc, bus_dma_tag_t dmat, void** vaddr,
 		 int flags, bus_dmamap_t *mapp)
 {
-	*vaddr = pci_alloc_consistent(ahc->dev_softc,
+	/* XXX: check if we really need the GFP_ATOMIC and unwind this mess! */
-				      dmat->maxsize, mapp);
+	*vaddr = dma_alloc_coherent(ahc->dev, dmat->maxsize, mapp, GFP_ATOMIC);
 	if (*vaddr == NULL)
 		return ENOMEM;
 	return 0;
 ahc_dmamem_free(struct ahc_softc *ahc, bus_dma_tag_t dmat,
 		void* vaddr, bus_dmamap_t map)
 {
-	pci_free_consistent(ahc->dev_softc, dmat->maxsize,
+	dma_free_coherent(ahc->dev, dmat->maxsize, vaddr, map);
-			    vaddr, map);
 }
 int
 	host->transportt = ahc_linux_transport_template;
-	retval = scsi_add_host(host,
+	retval = scsi_add_host(host, ahc->dev);
-			(ahc->dev_softc ? &ahc->dev_softc->dev : NULL));
 	if (retval) {
 		printk(KERN_WARNING "aic7xxx: scsi_add_host failed\n");
 		scsi_host_put(host);

drivers/scsi/aic7xxx/aic7xxx_osm_pci.c+1−0

@@ -250,6 +250,7 @@ ahc_linux_pci_dev_probe(struct pci_dev pdev, const struct pci_device_id ent) · 249 unmodified lines
250	}	250	}
251	}	251	}
252	ahc->dev_softc = pci;	252	ahc->dev_softc = pci;
		253	ahc->dev = &pci->dev;
253	error = ahc_pci_config(ahc, entry);	254	error = ahc_pci_config(ahc, entry);
254	if (error != 0) {	255	if (error != 0) {
255	ahc_free(ahc);	256	ahc_free(ahc);

drivers/scsi/csiostor/csio_scsi.c+4−1

 	}
 out:
-	if (req->nsge > 0)
+	if (req->nsge > 0) {
 		scsi_dma_unmap(cmnd);
+		if (req->dcopy && (host_status == DID_OK))
+			host_status = csio_scsi_copy_to_sgl(hw, req);
+	}
 	cmnd->result = (((host_status) << 16) | scsi_status);
 	cmnd->scsi_done(cmnd);

drivers/scsi/libfc/fc_rport.c+0−1

@@ -2162,7 +2162,6 @@ static void fc_rport_recv_logo_req(struct fc_lport lport, struct fc_frame fp) · 2161 unmodified lines
2162	FC_RPORT_DBG(rdata, "Received LOGO request while in state %s\n",	2162	FC_RPORT_DBG(rdata, "Received LOGO request while in state %s\n",
2163	fc_rport_state(rdata));	2163	fc_rport_state(rdata));
2164		2164
2165	rdata->flags &= ~FC_RP_STARTED;
2166	fc_rport_enter_delete(rdata, RPORT_EV_STOP);	2165	fc_rport_enter_delete(rdata, RPORT_EV_STOP);
2167	mutex_unlock(&rdata->rp_mutex);	2166	mutex_unlock(&rdata->rp_mutex);
2168	kref_put(&rdata->kref, fc_rport_destroy);	2167	kref_put(&rdata->kref, fc_rport_destroy);

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/scsi_lib.c+5−1

 			ret = BLK_STS_DEV_RESOURCE;
 		break;
 	default:
+		if (unlikely(!scsi_device_online(sdev)))
+			scsi_req(req)->result = DID_NO_CONNECT << 16;
+		else
+			scsi_req(req)->result = DID_ERROR << 16;
 		/*
-		 * Make sure to release all allocated ressources when
+		 * Make sure to release all allocated resources when
 		 * we hit an error, as we will never see this command
 		 * again.
 		 */

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/scsi/virtio_scsi.c+1−0

@@ -793,6 +793,7 @@ static int virtscsi_probe(struct virtio_device *vdev) · 792 unmodified lines
793		793
794	/* We need to know how many queues before we allocate. */	794	/* We need to know how many queues before we allocate. */
795	num_queues = virtscsi_config_get(vdev, num_queues) ? : 1;	795	num_queues = virtscsi_config_get(vdev, num_queues) ? : 1;
		796	num_queues = min_t(unsigned int, nr_cpu_ids, num_queues);
796		797
797	num_targets = virtscsi_config_get(vdev, max_target) + 1;	798	num_targets = virtscsi_config_get(vdev, max_target) + 1;
798		799

drivers/staging/comedi/drivers/ni_usb6501.c+4−6

 	size = usb_endpoint_maxp(devpriv->ep_tx);
 	devpriv->usb_tx_buf = kzalloc(size, GFP_KERNEL);
-	if (!devpriv->usb_tx_buf) {
+	if (!devpriv->usb_tx_buf)
-		kfree(devpriv->usb_rx_buf);
 		return -ENOMEM;
-	}
 	return 0;
 }
 	if (!devpriv)
 		return -ENOMEM;
+	mutex_init(&devpriv->mut);
+	usb_set_intfdata(intf, devpriv);
 	ret = ni6501_find_endpoints(dev);
 	if (ret)
 		return ret;
 	if (ret)
 		return ret;
-	mutex_init(&devpriv->mut);
-	usb_set_intfdata(intf, devpriv);
 	ret = comedi_alloc_subdevices(dev, 2);
 	if (ret)
 		return ret;

drivers/staging/comedi/drivers/vmk80xx.c+3−5

 	size = usb_endpoint_maxp(devpriv->ep_tx);
 	devpriv->usb_tx_buf = kzalloc(size, GFP_KERNEL);
-	if (!devpriv->usb_tx_buf) {
+	if (!devpriv->usb_tx_buf)
-		kfree(devpriv->usb_rx_buf);
 		return -ENOMEM;
-	}
 	return 0;
 }
 	devpriv->model = board->model;
+	sema_init(&devpriv->limit_sem, 8);
 	ret = vmk80xx_find_usb_endpoints(dev);
 	if (ret)
 		return ret;
 	if (ret)
 		return ret;
-	sema_init(&devpriv->limit_sem, 8);
 	usb_set_intfdata(intf, devpriv);
 	if (devpriv->model == VMK8055_MODEL)

drivers/staging/erofs/data.c+1−1

@@ -298,7 +298,7 @@ submit_bio_retry: · 297 unmodified lines
298	*last_block = current_block;	298	*last_block = current_block;
299		299
300	/* shift in advance in case of it followed by too many gaps */	300	/* shift in advance in case of it followed by too many gaps */
301	if (unlikely(bio->bi_vcnt >= bio->bi_max_vecs)) {	301	if (bio->bi_iter.bi_size >= bio->bi_max_vecs * PAGE_SIZE) {
302	/* err should reassign to 0 after submitting */	302	/* err should reassign to 0 after submitting */
303	err = 0;	303	err = 0;
304	goto submit_bio_out;	304	goto submit_bio_out;

drivers/staging/iio/adc/ad7192.c+4−4

@@ -109,10 +109,10 @@ · 108 unmodified lines
109	#define AD7192_CH_AIN3 BIT(6) /* AIN3 - AINCOM */	109	#define AD7192_CH_AIN3 BIT(6) /* AIN3 - AINCOM */
110	#define AD7192_CH_AIN4 BIT(7) /* AIN4 - AINCOM */	110	#define AD7192_CH_AIN4 BIT(7) /* AIN4 - AINCOM */
111		111
112	#define AD7193_CH_AIN1P_AIN2M 0x000 /* AIN1(+) - AIN2(-) */	112	#define AD7193_CH_AIN1P_AIN2M 0x001 /* AIN1(+) - AIN2(-) */
113	#define AD7193_CH_AIN3P_AIN4M 0x001 /* AIN3(+) - AIN4(-) */	113	#define AD7193_CH_AIN3P_AIN4M 0x002 /* AIN3(+) - AIN4(-) */
114	#define AD7193_CH_AIN5P_AIN6M 0x002 /* AIN5(+) - AIN6(-) */	114	#define AD7193_CH_AIN5P_AIN6M 0x004 /* AIN5(+) - AIN6(-) */
115	#define AD7193_CH_AIN7P_AIN8M 0x004 /* AIN7(+) - AIN8(-) */	115	#define AD7193_CH_AIN7P_AIN8M 0x008 /* AIN7(+) - AIN8(-) */
116	#define AD7193_CH_TEMP 0x100 /* Temp senseor */	116	#define AD7193_CH_TEMP 0x100 /* Temp senseor */
117	#define AD7193_CH_AIN2P_AIN2M 0x200 /* AIN2(+) - AIN2(-) */	117	#define AD7193_CH_AIN2P_AIN2M 0x200 /* AIN2(+) - AIN2(-) */
118	#define AD7193_CH_AIN1 0x401 /* AIN1 - AINCOM */	118	#define AD7193_CH_AIN1 0x401 /* AIN1 - AINCOM */

drivers/staging/iio/meter/ade7854.c+1−1

@@ -269,7 +269,7 @@ static IIO_DEV_ATTR_VPEAK(0644, · 268 unmodified lines
269	static IIO_DEV_ATTR_IPEAK(0644,	269	static IIO_DEV_ATTR_IPEAK(0644,
270	ade7854_read_32bit,	270	ade7854_read_32bit,
271	ade7854_write_32bit,	271	ade7854_write_32bit,
272	ADE7854_VPEAK);	272	ADE7854_IPEAK);
273	static IIO_DEV_ATTR_APHCAL(0644,	273	static IIO_DEV_ATTR_APHCAL(0644,
274	ade7854_read_16bit,	274	ade7854_read_16bit,
275	ade7854_write_16bit,	275	ade7854_write_16bit,

drivers/staging/most/core.c+1−1

@@ -1431,7 +1431,7 @@ int most_register_interface(struct most_interface *iface) · 1430 unmodified lines
1431		1431
1432	INIT_LIST_HEAD(&iface->p->channel_list);	1432	INIT_LIST_HEAD(&iface->p->channel_list);
1433	iface->p->dev_id = id;	1433	iface->p->dev_id = id;
1434	snprintf(iface->p->name, STRING_SIZE, "mdev%d", id);	1434	strcpy(iface->p->name, iface->description);
1435	iface->dev.init_name = iface->p->name;	1435	iface->dev.init_name = iface->p->name;
1436	iface->dev.bus = &mc.bus;	1436	iface->dev.bus = &mc.bus;
1437	iface->dev.parent = &mc.dev;	1437	iface->dev.parent = &mc.dev;

drivers/tty/serial/sc16is7xx.c+3−1

 #endif
 	return ret;
+#ifdef CONFIG_SERIAL_SC16IS7XX_SPI
 err_spi:
+#endif
 #ifdef CONFIG_SERIAL_SC16IS7XX_I2C
 	i2c_del_driver(&sc16is7xx_i2c_uart_driver);
-#endif
 err_i2c:
+#endif
 	uart_unregister_driver(&sc16is7xx_uart);
 	return ret;
 }

drivers/tty/serial/sh-sci.c+4−2

 			 * center of the last stop bit in sampling clocks.
 			 */
 			int last_stop = bits * 2 - 1;
-			int deviation = min_err * srr * last_stop / 2 / baud;
+			int deviation = DIV_ROUND_CLOSEST(min_err * last_stop *
+							  (int)(srr + 1),
+							  2 * (int)baud);
 			if (abs(deviation) >= 2) {
 				/* At least two sampling clocks off at the
 				 * last stop bit; we can increase the error
 				 * margin by shifting the sampling point.
 				 */
-				int shift = min(-8, max(7, deviation / 2));
+				int shift = clamp(deviation / 2, -8, 7);
 				hssrr |= (shift << HSCIF_SRHP_SHIFT) &
 					 HSCIF_SRHP_MASK;

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

@@ -1520,7 +1520,8 @@ static void csi_J(struct vc_data *vc, int vpar) · 1519 unmodified lines
1520	return;	1520	return;
1521	}	1521	}
1522	scr_memsetw(start, vc->vc_video_erase_char, 2 * count);	1522	scr_memsetw(start, vc->vc_video_erase_char, 2 * count);
1523	update_region(vc, (unsigned long) start, count);	1523	if (con_should_update(vc))
		1524	do_update_region(vc, (unsigned long) start, count);
1524	vc->vc_need_wrap = 0;	1525	vc->vc_need_wrap = 0;
1525	}	1526	}
1526		1527

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/vhost/vhost.c+5−1

 				u64 start, u64 size, u64 end,
 				u64 userspace_addr, int perm)
 {
-	struct vhost_umem_node *tmp, *node = kmalloc(sizeof(*node), GFP_ATOMIC);
+	struct vhost_umem_node *tmp, *node;
+	if (!size)
+		return -EFAULT;
+	node = kmalloc(sizeof(*node), GFP_ATOMIC);
 	if (!node)
 		return -ENOMEM;

drivers/virtio/virtio_pci_common.c+5−3

 	for (i = 0; i < vp_dev->msix_used_vectors; ++i)
 		free_irq(pci_irq_vector(vp_dev->pci_dev, i), vp_dev);
-	for (i = 0; i < vp_dev->msix_vectors; i++)
+	if (vp_dev->msix_affinity_masks) {
-		if (vp_dev->msix_affinity_masks[i])
+		for (i = 0; i < vp_dev->msix_vectors; i++)
-			free_cpumask_var(vp_dev->msix_affinity_masks[i]);
+			if (vp_dev->msix_affinity_masks[i])
+				free_cpumask_var(vp_dev->msix_affinity_masks[i]);
+	}
 	if (vp_dev->msix_enabled) {
 		/* Disable the vector used for configuration */

drivers/virtio/virtio_ring.c+2−0

@@ -882,6 +882,8 @@ static struct virtqueue *vring_create_virtqueue_split( · 881 unmodified lines
882	GFP_KERNEL\|__GFP_NOWARN\|__GFP_ZERO);	882	GFP_KERNEL\|__GFP_NOWARN\|__GFP_ZERO);
883	if (queue)	883	if (queue)
884	break;	884	break;
		885	if (!may_reduce_num)
		886	return NULL;
885	}	887	}
886		888
887	if (!num)	889	if (!num)

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/afs/callback.c+1−2

@@ -203,8 +203,7 @@ void afs_put_cb_interest(struct afs_net net, struct afs_cb_interest cbi) · 202 unmodified lines
203	*/	203	*/
204	void afs_init_callback_state(struct afs_server *server)	204	void afs_init_callback_state(struct afs_server *server)
205	{	205	{
206	if (!test_and_clear_bit(AFS_SERVER_FL_NEW, &server->flags))	206	server->cb_s_break++;
207	server->cb_s_break++;
208	}	207	}
209		208
210	/*	209	/*

fs/afs/cmservice.c+1−1

@@ -34,7 +34,7 @@ static void SRXAFSCB_TellMeAboutYourself(struct work_struct *); · 33 unmodified lines
34	static int afs_deliver_yfs_cb_callback(struct afs_call *);	34	static int afs_deliver_yfs_cb_callback(struct afs_call *);
35		35
36	#define CM_NAME(name) \	36	#define CM_NAME(name) \
37	const char afs_SRXCB##name##_name[] __tracepoint_string = \	37	char afs_SRXCB##name##_name[] __tracepoint_string = \
38	"CB." #name	38	"CB." #name
39		39
40	/*	40	/*

fs/afs/inode.c+1−3

 	set_nlink(inode, 2);
 	inode->i_uid		= GLOBAL_ROOT_UID;
 	inode->i_gid		= GLOBAL_ROOT_GID;
-	inode->i_ctime.tv_sec	= get_seconds();
+	inode->i_ctime = inode->i_atime = inode->i_mtime = current_time(inode);
-	inode->i_ctime.tv_nsec	= 0;
-	inode->i_atime		= inode->i_mtime = inode->i_ctime;
 	inode->i_blocks		= 0;
 	inode_set_iversion_raw(inode, 0);
 	inode->i_generation	= 0;

fs/afs/internal.h+1−3

 	time64_t		put_time;	/* Time at which last put */
 	time64_t		update_at;	/* Time at which to next update the record */
 	unsigned long		flags;
-#define AFS_SERVER_FL_NEW	0		/* New server, don't inc cb_s_break */
 #define AFS_SERVER_FL_NOT_READY	1		/* The record is not ready for use */
 #define AFS_SERVER_FL_NOT_FOUND	2		/* VL server says no such server */
 #define AFS_SERVER_FL_VL_FAIL	3		/* Failed to access VL server */
 static inline unsigned int afs_calc_vnode_cb_break(struct afs_vnode *vnode)
 {
-	return vnode->cb_break + vnode->cb_s_break + vnode->cb_v_break;
+	return vnode->cb_break + vnode->cb_v_break;
 }
 static inline bool afs_cb_is_broken(unsigned int cb_break,
 				    const struct afs_cb_interest *cbi)
 {
 	return !cbi || cb_break != (vnode->cb_break +
-				    cbi->server->cb_s_break +
 				    vnode->volume->cb_v_break);
 }

fs/afs/rxrpc.c+22−8

 		case -ENODATA:
 		case -EBADMSG:
 		case -EMSGSIZE:
-		default:
 			abort_code = RXGEN_CC_UNMARSHAL;
 			if (state != AFS_CALL_CL_AWAIT_REPLY)
 				abort_code = RXGEN_SS_UNMARSHAL;
 			rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
 						abort_code, ret, "KUM");
 			goto local_abort;
+		default:
+			abort_code = RX_USER_ABORT;
+			rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
+						abort_code, ret, "KER");
+			goto local_abort;
 		}
 	}
 	bool stalled = false;
 	u64 rtt;
 	u32 life, last_life;
+	bool rxrpc_complete = false;
 	DECLARE_WAITQUEUE(myself, current);
 		rtt2 = 2;
 	timeout = rtt2;
-	last_life = rxrpc_kernel_check_life(call->net->socket, call->rxcall);
+	rxrpc_kernel_check_life(call->net->socket, call->rxcall, &last_life);
 	add_wait_queue(&call->waitq, &myself);
 	for (;;) {
 		if (afs_check_call_state(call, AFS_CALL_COMPLETE))
 			break;
-		life = rxrpc_kernel_check_life(call->net->socket, call->rxcall);
+		if (!rxrpc_kernel_check_life(call->net->socket, call->rxcall, &life)) {
+			/* rxrpc terminated the call. */
+			rxrpc_complete = true;
+			break;
+		}
 		if (timeout == 0 &&
 		    life == last_life && signal_pending(current)) {
 			if (stalled)
 	remove_wait_queue(&call->waitq, &myself);
 	__set_current_state(TASK_RUNNING);
-	/* Kill off the call if it's still live. */
 	if (!afs_check_call_state(call, AFS_CALL_COMPLETE)) {
-		_debug("call interrupted");
+		if (rxrpc_complete) {
-		if (rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
+			afs_set_call_complete(call, call->error, call->abort_code);
-					    RX_USER_ABORT, -EINTR, "KWI"))
+		} else {
-			afs_set_call_complete(call, -EINTR, 0);
+			/* Kill off the call if it's still live. */
+			_debug("call interrupted");
+			if (rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
+						    RX_USER_ABORT, -EINTR, "KWI"))
+				afs_set_call_complete(call, -EINTR, 0);
+		}
 	}
 	spin_lock_bh(&call->state_lock);

fs/afs/server.c+0−1

@@ -226,7 +226,6 @@ static struct afs_server afs_alloc_server(struct afs_net net, · 225 unmodified lines
226	RCU_INIT_POINTER(server->addresses, alist);	226	RCU_INIT_POINTER(server->addresses, alist);
227	server->addr_version = alist->version;	227	server->addr_version = alist->version;
228	server->uuid = *uuid;	228	server->uuid = *uuid;
229	server->flags = (1UL << AFS_SERVER_FL_NEW);
230	server->update_at = ktime_get_real_seconds() + afs_server_update_delay;	229	server->update_at = ktime_get_real_seconds() + afs_server_update_delay;
231	rwlock_init(&server->fs_lock);	230	rwlock_init(&server->fs_lock);
232	INIT_HLIST_HEAD(&server->cb_volumes);	231	INIT_HLIST_HEAD(&server->cb_volumes);

fs/afs/write.c+1−0

@@ -264,6 +264,7 @@ static void afs_kill_pages(struct address_space *mapping, · 263 unmodified lines
264	first = page->index + 1;	264	first = page->index + 1;
265	lock_page(page);	265	lock_page(page);
266	generic_error_remove_page(mapping, page);	266	generic_error_remove_page(mapping, page);
		267	unlock_page(page);
267	}	268	}
268		269
269	__pagevec_release(&pv);	270	__pagevec_release(&pv);

fs/aio.c+150−188

@@ -181,7 +181,7 @@ struct poll_iocb { · 180 unmodified lines
181	struct file *file;	181	struct file *file;
182	struct wait_queue_head *head;	182	struct wait_queue_head *head;
183	__poll_t events;	183	__poll_t events;
184	bool woken;	184	bool done;
185	bool cancelled;	185	bool cancelled;
186	struct wait_queue_entry wait;	186	struct wait_queue_entry wait;
187	struct work_struct work;	187	struct work_struct work;
@@ -204,8 +204,7 @@ struct aio_kiocb { · 16 unmodified lines
204	struct kioctx *ki_ctx;	204	struct kioctx *ki_ctx;
205	kiocb_cancel_fn *ki_cancel;	205	kiocb_cancel_fn *ki_cancel;
206		206
207	struct iocb __user ki_user_iocb; / user's aiocb */	207	struct io_event ki_res;
208	__u64 ki_user_data; /* user's data for completion */
209		208
210	struct list_head ki_list; /* the aio core uses this	209	struct list_head ki_list; /* the aio core uses this
211	* for cancellation */	210	* for cancellation */
@@ -1022,6 +1021,9 @@ static bool get_reqs_available(struct kioctx *ctx) · 810 unmodified lines
1022	/* aio_get_req	1021	/* aio_get_req
1023	* Allocate a slot for an aio request.	1022	* Allocate a slot for an aio request.
1024	* Returns NULL if no requests are free.	1023	* Returns NULL if no requests are free.
		1024	*
		1025	* The refcount is initialized to 2 - one for the async op completion,
		1026	* one for the synchronous code that does this.
1025	*/	1027	*/
1026	static inline struct aio_kiocb aio_get_req(struct kioctx ctx)	1028	static inline struct aio_kiocb aio_get_req(struct kioctx ctx)
1027	{	1029	{
@@ -1031,10 +1033,15 @@ static inline struct aio_kiocb aio_get_req(struct kioctx ctx) · 3 unmodified lines
1031	if (unlikely(!req))	1033	if (unlikely(!req))
1032	return NULL;	1034	return NULL;
1033		1035
		1036	if (unlikely(!get_reqs_available(ctx))) {
		1037	kmem_cache_free(kiocb_cachep, req);
		1038	return NULL;
		1039	}
		1040
1034	percpu_ref_get(&ctx->reqs);	1041	percpu_ref_get(&ctx->reqs);
1035	req->ki_ctx = ctx;	1042	req->ki_ctx = ctx;
1036	INIT_LIST_HEAD(&req->ki_list);	1043	INIT_LIST_HEAD(&req->ki_list);
1037	refcount_set(&req->ki_refcnt, 0);	1044	refcount_set(&req->ki_refcnt, 2);
1038	req->ki_eventfd = NULL;	1045	req->ki_eventfd = NULL;
1039	return req;	1046	return req;
1040	}	1047	}
@@ -1067,30 +1074,20 @@ out: · 26 unmodified lines
1067	return ret;	1074	return ret;
1068	}	1075	}
1069		1076
1070	static inline void iocb_put(struct aio_kiocb *iocb)	1077	static inline void iocb_destroy(struct aio_kiocb *iocb)
1071	{
1072	if (refcount_read(&iocb->ki_refcnt) == 0 \|\|
1073	refcount_dec_and_test(&iocb->ki_refcnt)) {
1074	if (iocb->ki_filp)
1075	fput(iocb->ki_filp);
1076	percpu_ref_put(&iocb->ki_ctx->reqs);
1077	kmem_cache_free(kiocb_cachep, iocb);
1078	}
1079	}
1080
1081	static void aio_fill_event(struct io_event ev, struct aio_kiocb iocb,
1082	long res, long res2)
1083	{	1078	{
1084	ev->obj = (u64)(unsigned long)iocb->ki_user_iocb;	1079	if (iocb->ki_eventfd)
1085	ev->data = iocb->ki_user_data;	1080	eventfd_ctx_put(iocb->ki_eventfd);
1086	ev->res = res;	1081	if (iocb->ki_filp)
1087	ev->res2 = res2;	1082	fput(iocb->ki_filp);
		1083	percpu_ref_put(&iocb->ki_ctx->reqs);
		1084	kmem_cache_free(kiocb_cachep, iocb);
1088	}	1085	}
1089		1086
1090	/* aio_complete	1087	/* aio_complete
1091	* Called when the io request on the given iocb is complete.	1088	* Called when the io request on the given iocb is complete.
1092	*/	1089	*/
1093	static void aio_complete(struct aio_kiocb *iocb, long res, long res2)	1090	static void aio_complete(struct aio_kiocb *iocb)
1094	{	1091	{
1095	struct kioctx *ctx = iocb->ki_ctx;	1092	struct kioctx *ctx = iocb->ki_ctx;
1096	struct aio_ring *ring;	1093	struct aio_ring *ring;
@@ -1114,14 +1111,14 @@ static void aio_complete(struct aio_kiocb *iocb, long res, long res2) · 17 unmodified lines
1114	ev_page = kmap_atomic(ctx->ring_pages[pos / AIO_EVENTS_PER_PAGE]);	1111	ev_page = kmap_atomic(ctx->ring_pages[pos / AIO_EVENTS_PER_PAGE]);
1115	event = ev_page + pos % AIO_EVENTS_PER_PAGE;	1112	event = ev_page + pos % AIO_EVENTS_PER_PAGE;
1116		1113
1117	aio_fill_event(event, iocb, res, res2);	1114	*event = iocb->ki_res;
1118		1115
1119	kunmap_atomic(ev_page);	1116	kunmap_atomic(ev_page);
1120	flush_dcache_page(ctx->ring_pages[pos / AIO_EVENTS_PER_PAGE]);	1117	flush_dcache_page(ctx->ring_pages[pos / AIO_EVENTS_PER_PAGE]);
1121		1118
1122	pr_debug("%p[%u]: %p: %p %Lx %lx %lx\n",	1119	pr_debug("%p[%u]: %p: %p %Lx %Lx %Lx\n", ctx, tail, iocb,
1123	ctx, tail, iocb, iocb->ki_user_iocb, iocb->ki_user_data,	1120	(void __user *)(unsigned long)iocb->ki_res.obj,
1124	res, res2);	1121	iocb->ki_res.data, iocb->ki_res.res, iocb->ki_res.res2);
1125		1122
1126	/* after flagging the request as done, we	1123	/* after flagging the request as done, we
1127	* must never even look at it again	1124	* must never even look at it again
@@ -1148,10 +1145,8 @@ static void aio_complete(struct aio_kiocb *iocb, long res, long res2) · 20 unmodified lines
1148	* eventfd. The eventfd_signal() function is safe to be called	1145	* eventfd. The eventfd_signal() function is safe to be called
1149	* from IRQ context.	1146	* from IRQ context.
1150	*/	1147	*/
1151	if (iocb->ki_eventfd) {	1148	if (iocb->ki_eventfd)
1152	eventfd_signal(iocb->ki_eventfd, 1);	1149	eventfd_signal(iocb->ki_eventfd, 1);
1153	eventfd_ctx_put(iocb->ki_eventfd);
1154	}
1155		1150
1156	/*	1151	/*
1157	* We have to order our ring_info tail store above and test	1152	* We have to order our ring_info tail store above and test
@@ -1163,7 +1158,14 @@ static void aio_complete(struct aio_kiocb *iocb, long res, long res2) · 5 unmodified lines
1163		1158
1164	if (waitqueue_active(&ctx->wait))	1159	if (waitqueue_active(&ctx->wait))
1165	wake_up(&ctx->wait);	1160	wake_up(&ctx->wait);
1166	iocb_put(iocb);	1161	}
		1162
		1163	static inline void iocb_put(struct aio_kiocb *iocb)
		1164	{
		1165	if (refcount_dec_and_test(&iocb->ki_refcnt)) {
		1166	aio_complete(iocb);
		1167	iocb_destroy(iocb);
		1168	}
1167	}	1169	}
1168		1170
1169	/* aio_read_events_ring	1171	/* aio_read_events_ring
@@ -1437,7 +1439,9 @@ static void aio_complete_rw(struct kiocb *kiocb, long res, long res2) · 267 unmodified lines
1437	file_end_write(kiocb->ki_filp);	1439	file_end_write(kiocb->ki_filp);
1438	}	1440	}
1439		1441
1440	aio_complete(iocb, res, res2);	1442	iocb->ki_res.res = res;
		1443	iocb->ki_res.res2 = res2;
		1444	iocb_put(iocb);
1441	}	1445	}
1442		1446
1443	static int aio_prep_rw(struct kiocb req, const struct iocb iocb)	1447	static int aio_prep_rw(struct kiocb req, const struct iocb iocb)
@@ -1514,13 +1518,13 @@ static inline void aio_rw_done(struct kiocb *req, ssize_t ret) · 70 unmodified lines
1514	}	1518	}
1515	}	1519	}
1516		1520
1517	static ssize_t aio_read(struct kiocb req, const struct iocb iocb,	1521	static int aio_read(struct kiocb req, const struct iocb iocb,
1518	bool vectored, bool compat)	1522	bool vectored, bool compat)
1519	{	1523	{
1520	struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;	1524	struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;
1521	struct iov_iter iter;	1525	struct iov_iter iter;
1522	struct file *file;	1526	struct file *file;
1523	ssize_t ret;	1527	int ret;
1524		1528
1525	ret = aio_prep_rw(req, iocb);	1529	ret = aio_prep_rw(req, iocb);
1526	if (ret)	1530	if (ret)
@@ -1542,13 +1546,13 @@ static ssize_t aio_read(struct kiocb req, const struct iocb iocb, · 15 unmodified lines
1542	return ret;	1546	return ret;
1543	}	1547	}
1544		1548
1545	static ssize_t aio_write(struct kiocb req, const struct iocb iocb,	1549	static int aio_write(struct kiocb req, const struct iocb iocb,
1546	bool vectored, bool compat)	1550	bool vectored, bool compat)
1547	{	1551	{
1548	struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;	1552	struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;
1549	struct iov_iter iter;	1553	struct iov_iter iter;
1550	struct file *file;	1554	struct file *file;
1551	ssize_t ret;	1555	int ret;
1552		1556
1553	ret = aio_prep_rw(req, iocb);	1557	ret = aio_prep_rw(req, iocb);
1554	if (ret)	1558	if (ret)
@@ -1585,11 +1589,10 @@ static ssize_t aio_write(struct kiocb req, const struct iocb iocb, · 30 unmodified lines
1585		1589
1586	static void aio_fsync_work(struct work_struct *work)	1590	static void aio_fsync_work(struct work_struct *work)
1587	{	1591	{
1588	struct fsync_iocb *req = container_of(work, struct fsync_iocb, work);	1592	struct aio_kiocb *iocb = container_of(work, struct aio_kiocb, fsync.work);
1589	int ret;
1590		1593
1591	ret = vfs_fsync(req->file, req->datasync);	1594	iocb->ki_res.res = vfs_fsync(iocb->fsync.file, iocb->fsync.datasync);
1592	aio_complete(container_of(req, struct aio_kiocb, fsync), ret, 0);	1595	iocb_put(iocb);
1593	}	1596	}
1594		1597
1595	static int aio_fsync(struct fsync_iocb req, const struct iocb iocb,	1598	static int aio_fsync(struct fsync_iocb req, const struct iocb iocb,
@@ -1608,11 +1611,6 @@ static int aio_fsync(struct fsync_iocb req, const struct iocb iocb, · 12 unmodified lines
1608	return 0;	1611	return 0;
1609	}	1612	}
1610		1613
1611	static inline void aio_poll_complete(struct aio_kiocb *iocb, __poll_t mask)
1612	{
1613	aio_complete(iocb, mangle_poll(mask), 0);
1614	}
1615
1616	static void aio_poll_complete_work(struct work_struct *work)	1614	static void aio_poll_complete_work(struct work_struct *work)
1617	{	1615	{
1618	struct poll_iocb *req = container_of(work, struct poll_iocb, work);	1616	struct poll_iocb *req = container_of(work, struct poll_iocb, work);
@@ -1638,9 +1636,11 @@ static void aio_poll_complete_work(struct work_struct *work) · 19 unmodified lines
1638	return;	1636	return;
1639	}	1637	}
1640	list_del_init(&iocb->ki_list);	1638	list_del_init(&iocb->ki_list);
		1639	iocb->ki_res.res = mangle_poll(mask);
		1640	req->done = true;
1641	spin_unlock_irq(&ctx->ctx_lock);	1641	spin_unlock_irq(&ctx->ctx_lock);
1642		1642
1643	aio_poll_complete(iocb, mask);	1643	iocb_put(iocb);
1644	}	1644	}
1645		1645
1646	/* assumes we are called with irqs disabled */	1646	/* assumes we are called with irqs disabled */
@@ -1668,31 +1668,27 @@ static int aio_poll_wake(struct wait_queue_entry *wait, unsigned mode, int sync, · 21 unmodified lines
1668	__poll_t mask = key_to_poll(key);	1668	__poll_t mask = key_to_poll(key);
1669	unsigned long flags;	1669	unsigned long flags;
1670		1670
1671	req->woken = true;
1672
1673	/* for instances that support it check for an event match first: */	1671	/* for instances that support it check for an event match first: */
1674	if (mask) {	1672	if (mask && !(mask & req->events))
1675	if (!(mask & req->events))	1673	return 0;
1676	return 0;	1674
		1675	list_del_init(&req->wait.entry);
1677		1676
		1677	if (mask && spin_trylock_irqsave(&iocb->ki_ctx->ctx_lock, flags)) {
1678	/*	1678	/*
1679	* Try to complete the iocb inline if we can. Use	1679	* Try to complete the iocb inline if we can. Use
1680	* irqsave/irqrestore because not all filesystems (e.g. fuse)	1680	* irqsave/irqrestore because not all filesystems (e.g. fuse)
1681	* call this function with IRQs disabled and because IRQs	1681	* call this function with IRQs disabled and because IRQs
1682	* have to be disabled before ctx_lock is obtained.	1682	* have to be disabled before ctx_lock is obtained.
1683	*/	1683	*/
1684	if (spin_trylock_irqsave(&iocb->ki_ctx->ctx_lock, flags)) {	1684	list_del(&iocb->ki_list);
1685	list_del(&iocb->ki_list);	1685	iocb->ki_res.res = mangle_poll(mask);
1686	spin_unlock_irqrestore(&iocb->ki_ctx->ctx_lock, flags);	1686	req->done = true;
1687		1687	spin_unlock_irqrestore(&iocb->ki_ctx->ctx_lock, flags);
1688	list_del_init(&req->wait.entry);	1688	iocb_put(iocb);
1689	aio_poll_complete(iocb, mask);	1689	} else {
1690	return 1;	1690	schedule_work(&req->work);
1691	}
1692	}	1691	}
1693
1694	list_del_init(&req->wait.entry);
1695	schedule_work(&req->work);
1696	return 1;	1692	return 1;
1697	}	1693	}
1698		1694
@@ -1719,11 +1715,12 @@ aio_poll_queue_proc(struct file file, struct wait_queue_head head, · 20 unmodified lines
1719	add_wait_queue(head, &pt->iocb->poll.wait);	1715	add_wait_queue(head, &pt->iocb->poll.wait);
1720	}	1716	}
1721		1717
1722	static ssize_t aio_poll(struct aio_kiocb aiocb, const struct iocb iocb)	1718	static int aio_poll(struct aio_kiocb aiocb, const struct iocb iocb)
1723	{	1719	{
1724	struct kioctx *ctx = aiocb->ki_ctx;	1720	struct kioctx *ctx = aiocb->ki_ctx;
1725	struct poll_iocb *req = &aiocb->poll;	1721	struct poll_iocb *req = &aiocb->poll;
1726	struct aio_poll_table apt;	1722	struct aio_poll_table apt;
		1723	bool cancel = false;
1727	__poll_t mask;	1724	__poll_t mask;
1728		1725
1729	/* reject any unknown events outside the normal event mask. */	1726	/* reject any unknown events outside the normal event mask. */
@@ -1737,7 +1734,7 @@ static ssize_t aio_poll(struct aio_kiocb aiocb, const struct iocb iocb) · 7 unmodified lines
1737	req->events = demangle_poll(iocb->aio_buf) \| EPOLLERR \| EPOLLHUP;	1734	req->events = demangle_poll(iocb->aio_buf) \| EPOLLERR \| EPOLLHUP;
1738		1735
1739	req->head = NULL;	1736	req->head = NULL;
1740	req->woken = false;	1737	req->done = false;
1741	req->cancelled = false;	1738	req->cancelled = false;
1742		1739
1743	apt.pt._qproc = aio_poll_queue_proc;	1740	apt.pt._qproc = aio_poll_queue_proc;
@@ -1749,156 +1746,135 @@ static ssize_t aio_poll(struct aio_kiocb aiocb, const struct iocb iocb) · 5 unmodified lines
1749	INIT_LIST_HEAD(&req->wait.entry);	1746	INIT_LIST_HEAD(&req->wait.entry);
1750	init_waitqueue_func_entry(&req->wait, aio_poll_wake);	1747	init_waitqueue_func_entry(&req->wait, aio_poll_wake);
1751		1748
1752	/* one for removal from waitqueue, one for this function */
1753	refcount_set(&aiocb->ki_refcnt, 2);
1754
1755	mask = vfs_poll(req->file, &apt.pt) & req->events;	1749	mask = vfs_poll(req->file, &apt.pt) & req->events;
1756	if (unlikely(!req->head)) {
1757	/* we did not manage to set up a waitqueue, done */
1758	goto out;
1759	}
1760
1761	spin_lock_irq(&ctx->ctx_lock);	1750	spin_lock_irq(&ctx->ctx_lock);
1762	spin_lock(&req->head->lock);	1751	if (likely(req->head)) {
1763	if (req->woken) {	1752	spin_lock(&req->head->lock);
1764	/* wake_up context handles the rest */	1753	if (unlikely(list_empty(&req->wait.entry))) {
1765	mask = 0;	1754	if (apt.error)
		1755	cancel = true;
		1756	apt.error = 0;
		1757	mask = 0;
		1758	}
		1759	if (mask \|\| apt.error) {
		1760	list_del_init(&req->wait.entry);
		1761	} else if (cancel) {
		1762	WRITE_ONCE(req->cancelled, true);
		1763	} else if (!req->done) { /* actually waiting for an event */
		1764	list_add_tail(&aiocb->ki_list, &ctx->active_reqs);
		1765	aiocb->ki_cancel = aio_poll_cancel;
		1766	}
		1767	spin_unlock(&req->head->lock);
		1768	}
		1769	if (mask) { /* no async, we'd stolen it */
		1770	aiocb->ki_res.res = mangle_poll(mask);
1766	apt.error = 0;	1771	apt.error = 0;
1767	} else if (mask \|\| apt.error) {
1768	/* if we get an error or a mask we are done */
1769	WARN_ON_ONCE(list_empty(&req->wait.entry));
1770	list_del_init(&req->wait.entry);
1771	} else {
1772	/* actually waiting for an event */
1773	list_add_tail(&aiocb->ki_list, &ctx->active_reqs);
1774	aiocb->ki_cancel = aio_poll_cancel;
1775	}	1772	}
1776	spin_unlock(&req->head->lock);
1777	spin_unlock_irq(&ctx->ctx_lock);	1773	spin_unlock_irq(&ctx->ctx_lock);
1778
1779	out:
1780	if (unlikely(apt.error))
1781	return apt.error;
1782
1783	if (mask)	1774	if (mask)
1784	aio_poll_complete(aiocb, mask);	1775	iocb_put(aiocb);
1785	iocb_put(aiocb);	1776	return apt.error;
1786	return 0;
1787	}	1777	}
1788		1778
1789	static int __io_submit_one(struct kioctx ctx, const struct iocb iocb,	1779	static int __io_submit_one(struct kioctx ctx, const struct iocb iocb,
1790	struct iocb __user *user_iocb, bool compat)	1780	struct iocb __user user_iocb, struct aio_kiocb req,
		1781	bool compat)
1791	{	1782	{
1792	struct aio_kiocb *req;
1793	ssize_t ret;
1794
1795	/* enforce forwards compatibility on users */
1796	if (unlikely(iocb->aio_reserved2)) {
1797	pr_debug("EINVAL: reserve field set\n");
1798	return -EINVAL;
1799	}
1800
1801	/* prevent overflows */
1802	if (unlikely(
1803	(iocb->aio_buf != (unsigned long)iocb->aio_buf) \|\|
1804	(iocb->aio_nbytes != (size_t)iocb->aio_nbytes) \|\|
1805	((ssize_t)iocb->aio_nbytes < 0)
1806	)) {
1807	pr_debug("EINVAL: overflow check\n");
1808	return -EINVAL;
1809	}
1810
1811	if (!get_reqs_available(ctx))
1812	return -EAGAIN;
1813
1814	ret = -EAGAIN;
1815	req = aio_get_req(ctx);
1816	if (unlikely(!req))
1817	goto out_put_reqs_available;
1818
1819	req->ki_filp = fget(iocb->aio_fildes);	1783	req->ki_filp = fget(iocb->aio_fildes);
1820	ret = -EBADF;
1821	if (unlikely(!req->ki_filp))	1784	if (unlikely(!req->ki_filp))
1822	goto out_put_req;	1785	return -EBADF;
1823		1786
1824	if (iocb->aio_flags & IOCB_FLAG_RESFD) {	1787	if (iocb->aio_flags & IOCB_FLAG_RESFD) {
		1788	struct eventfd_ctx *eventfd;
1825	/*	1789	/*
1826	* If the IOCB_FLAG_RESFD flag of aio_flags is set, get an	1790	* If the IOCB_FLAG_RESFD flag of aio_flags is set, get an
1827	* instance of the file* now. The file descriptor must be	1791	* instance of the file* now. The file descriptor must be
1828	* an eventfd() fd, and will be signaled for each completed	1792	* an eventfd() fd, and will be signaled for each completed
1829	* event using the eventfd_signal() function.	1793	* event using the eventfd_signal() function.
1830	*/	1794	*/
1831	req->ki_eventfd = eventfd_ctx_fdget((int) iocb->aio_resfd);	1795	eventfd = eventfd_ctx_fdget(iocb->aio_resfd);
1832	if (IS_ERR(req->ki_eventfd)) {	1796	if (IS_ERR(eventfd))
1833	ret = PTR_ERR(req->ki_eventfd);	1797	return PTR_ERR(eventfd);
1834	req->ki_eventfd = NULL;	1798
1835	goto out_put_req;	1799	req->ki_eventfd = eventfd;
1836	}
1837	}	1800	}
1838		1801
1839	ret = put_user(KIOCB_KEY, &user_iocb->aio_key);	1802	if (unlikely(put_user(KIOCB_KEY, &user_iocb->aio_key))) {
1840	if (unlikely(ret)) {
1841	pr_debug("EFAULT: aio_key\n");	1803	pr_debug("EFAULT: aio_key\n");
1842	goto out_put_req;	1804	return -EFAULT;
1843	}	1805	}
1844		1806
1845	req->ki_user_iocb = user_iocb;	1807	req->ki_res.obj = (u64)(unsigned long)user_iocb;
1846	req->ki_user_data = iocb->aio_data;	1808	req->ki_res.data = iocb->aio_data;
		1809	req->ki_res.res = 0;
		1810	req->ki_res.res2 = 0;
1847		1811
1848	switch (iocb->aio_lio_opcode) {	1812	switch (iocb->aio_lio_opcode) {
1849	case IOCB_CMD_PREAD:	1813	case IOCB_CMD_PREAD:
1850	ret = aio_read(&req->rw, iocb, false, compat);	1814	return aio_read(&req->rw, iocb, false, compat);
1851	break;
1852	case IOCB_CMD_PWRITE:	1815	case IOCB_CMD_PWRITE:
1853	ret = aio_write(&req->rw, iocb, false, compat);	1816	return aio_write(&req->rw, iocb, false, compat);
1854	break;
1855	case IOCB_CMD_PREADV:	1817	case IOCB_CMD_PREADV:
1856	ret = aio_read(&req->rw, iocb, true, compat);	1818	return aio_read(&req->rw, iocb, true, compat);
1857	break;
1858	case IOCB_CMD_PWRITEV:	1819	case IOCB_CMD_PWRITEV:
1859	ret = aio_write(&req->rw, iocb, true, compat);	1820	return aio_write(&req->rw, iocb, true, compat);
1860	break;
1861	case IOCB_CMD_FSYNC:	1821	case IOCB_CMD_FSYNC:
1862	ret = aio_fsync(&req->fsync, iocb, false);	1822	return aio_fsync(&req->fsync, iocb, false);
1863	break;
1864	case IOCB_CMD_FDSYNC:	1823	case IOCB_CMD_FDSYNC:
1865	ret = aio_fsync(&req->fsync, iocb, true);	1824	return aio_fsync(&req->fsync, iocb, true);
1866	break;
1867	case IOCB_CMD_POLL:	1825	case IOCB_CMD_POLL:
1868	ret = aio_poll(req, iocb);	1826	return aio_poll(req, iocb);
1869	break;
1870	default:	1827	default:
1871	pr_debug("invalid aio operation %d\n", iocb->aio_lio_opcode);	1828	pr_debug("invalid aio operation %d\n", iocb->aio_lio_opcode);
1872	ret = -EINVAL;	1829	return -EINVAL;
1873	break;
1874	}	1830	}
1875
1876	/*
1877	* If ret is 0, we'd either done aio_complete() ourselves or have
1878	* arranged for that to be done asynchronously. Anything non-zero
1879	* means that we need to destroy req ourselves.
1880	*/
1881	if (ret)
1882	goto out_put_req;
1883	return 0;
1884	out_put_req:
1885	if (req->ki_eventfd)
1886	eventfd_ctx_put(req->ki_eventfd);
1887	iocb_put(req);
1888	out_put_reqs_available:
1889	put_reqs_available(ctx, 1);
1890	return ret;
1891	}	1831	}
1892		1832
1893	static int io_submit_one(struct kioctx ctx, struct iocb __user user_iocb,	1833	static int io_submit_one(struct kioctx ctx, struct iocb __user user_iocb,
1894	bool compat)	1834	bool compat)
1895	{	1835	{
		1836	struct aio_kiocb *req;
1896	struct iocb iocb;	1837	struct iocb iocb;
		1838	int err;
1897		1839
1898	if (unlikely(copy_from_user(&iocb, user_iocb, sizeof(iocb))))	1840	if (unlikely(copy_from_user(&iocb, user_iocb, sizeof(iocb))))
1899	return -EFAULT;	1841	return -EFAULT;
1900		1842
1901	return __io_submit_one(ctx, &iocb, user_iocb, compat);	1843	/* enforce forwards compatibility on users */
		1844	if (unlikely(iocb.aio_reserved2)) {
		1845	pr_debug("EINVAL: reserve field set\n");
		1846	return -EINVAL;
		1847	}
		1848
		1849	/* prevent overflows */
		1850	if (unlikely(
		1851	(iocb.aio_buf != (unsigned long)iocb.aio_buf) \|\|
		1852	(iocb.aio_nbytes != (size_t)iocb.aio_nbytes) \|\|
		1853	((ssize_t)iocb.aio_nbytes < 0)
		1854	)) {
		1855	pr_debug("EINVAL: overflow check\n");
		1856	return -EINVAL;
		1857	}
		1858
		1859	req = aio_get_req(ctx);
		1860	if (unlikely(!req))
		1861	return -EAGAIN;
		1862
		1863	err = __io_submit_one(ctx, &iocb, user_iocb, req, compat);
		1864
		1865	/* Done with the synchronous reference */
		1866	iocb_put(req);
		1867
		1868	/*
		1869	* If err is 0, we'd either done aio_complete() ourselves or have
		1870	* arranged for that to be done asynchronously. Anything non-zero
		1871	* means that we need to destroy req ourselves.
		1872	*/
		1873	if (unlikely(err)) {
		1874	iocb_destroy(req);
		1875	put_reqs_available(ctx, 1);
		1876	}
		1877	return err;
1902	}	1878	}
1903		1879
1904	/* sys_io_submit:	1880	/* sys_io_submit:
@@ -1997,24 +1973,6 @@ COMPAT_SYSCALL_DEFINE3(io_submit, compat_aio_context_t, ctx_id, · 92 unmodified lines
1997	}	1973	}
1998	#endif	1974	#endif
1999		1975
2000	/* lookup_kiocb
2001	* Finds a given iocb for cancellation.
2002	*/
2003	static struct aio_kiocb *
2004	lookup_kiocb(struct kioctx ctx, struct iocb __user iocb)
2005	{
2006	struct aio_kiocb *kiocb;
2007
2008	assert_spin_locked(&ctx->ctx_lock);
2009
2010	/* TODO: use a hash or array, this sucks. */
2011	list_for_each_entry(kiocb, &ctx->active_reqs, ki_list) {
2012	if (kiocb->ki_user_iocb == iocb)
2013	return kiocb;
2014	}
2015	return NULL;
2016	}
2017
2018	/* sys_io_cancel:	1976	/* sys_io_cancel:
2019	* Attempts to cancel an iocb previously passed to io_submit. If	1977	* Attempts to cancel an iocb previously passed to io_submit. If
2020	* the operation is successfully cancelled, the resulting event is	1978	* the operation is successfully cancelled, the resulting event is
@@ -2032,6 +1990,7 @@ SYSCALL_DEFINE3(io_cancel, aio_context_t, ctx_id, struct iocb __user *, iocb, · 11 unmodified lines
2032	struct aio_kiocb *kiocb;	1990	struct aio_kiocb *kiocb;
2033	int ret = -EINVAL;	1991	int ret = -EINVAL;
2034	u32 key;	1992	u32 key;
		1993	u64 obj = (u64)(unsigned long)iocb;
2035		1994
2036	if (unlikely(get_user(key, &iocb->aio_key)))	1995	if (unlikely(get_user(key, &iocb->aio_key)))
2037	return -EFAULT;	1996	return -EFAULT;
@@ -2043,10 +2002,13 @@ SYSCALL_DEFINE3(io_cancel, aio_context_t, ctx_id, struct iocb __user *, iocb, · 5 unmodified lines
2043	return -EINVAL;	2002	return -EINVAL;
2044		2003
2045	spin_lock_irq(&ctx->ctx_lock);	2004	spin_lock_irq(&ctx->ctx_lock);
2046	kiocb = lookup_kiocb(ctx, iocb);	2005	/* TODO: use a hash or array, this sucks. */
2047	if (kiocb) {	2006	list_for_each_entry(kiocb, &ctx->active_reqs, ki_list) {
2048	ret = kiocb->ki_cancel(&kiocb->rw);	2007	if (kiocb->ki_res.obj == obj) {
2049	list_del_init(&kiocb->ki_list);	2008	ret = kiocb->ki_cancel(&kiocb->rw);
		2009	list_del_init(&kiocb->ki_list);
		2010	break;
		2011	}
2050	}	2012	}
2051	spin_unlock_irq(&ctx->ctx_lock);	2013	spin_unlock_irq(&ctx->ctx_lock);
2052		2014

fs/block_dev.c+4−4

@@ -307,10 +307,10 @@ static void blkdev_bio_end_io(struct bio *bio) · 306 unmodified lines
307	struct blkdev_dio *dio = bio->bi_private;	307	struct blkdev_dio *dio = bio->bi_private;
308	bool should_dirty = dio->should_dirty;	308	bool should_dirty = dio->should_dirty;
309		309
310	if (dio->multi_bio && !atomic_dec_and_test(&dio->ref)) {	310	if (bio->bi_status && !dio->bio.bi_status)
311	if (bio->bi_status && !dio->bio.bi_status)	311	dio->bio.bi_status = bio->bi_status;
312	dio->bio.bi_status = bio->bi_status;	312
313	} else {	313	if (!dio->multi_bio \|\| atomic_dec_and_test(&dio->ref)) {
314	if (!dio->is_sync) {	314	if (!dio->is_sync) {
315	struct kiocb *iocb = dio->iocb;	315	struct kiocb *iocb = dio->iocb;
316	ssize_t ret;	316	ssize_t ret;

fs/btrfs/ioctl.c+10−0

@@ -501,6 +501,16 @@ static noinline int btrfs_ioctl_fitrim(struct file file, void __user arg) · 500 unmodified lines
501	if (!capable(CAP_SYS_ADMIN))	501	if (!capable(CAP_SYS_ADMIN))
502	return -EPERM;	502	return -EPERM;
503		503
		504	/*
		505	* If the fs is mounted with nologreplay, which requires it to be
		506	* mounted in RO mode as well, we can not allow discard on free space
		507	* inside block groups, because log trees refer to extents that are not
		508	* pinned in a block group's free space cache (pinning the extents is
		509	* precisely the first phase of replaying a log tree).
		510	*/
		511	if (btrfs_test_opt(fs_info, NOLOGREPLAY))
		512	return -EROFS;
		513
504	rcu_read_lock();	514	rcu_read_lock();
505	list_for_each_entry_rcu(device, &fs_info->fs_devices->devices,	515	list_for_each_entry_rcu(device, &fs_info->fs_devices->devices,
506	dev_list) {	516	dev_list) {

fs/btrfs/props.c+4−4

@@ -366,11 +366,11 @@ int btrfs_subvol_inherit_props(struct btrfs_trans_handle *trans, · 365 unmodified lines
366		366
367	static int prop_compression_validate(const char *value, size_t len)	367	static int prop_compression_validate(const char *value, size_t len)
368	{	368	{
369	if (!strncmp("lzo", value, len))	369	if (!strncmp("lzo", value, 3))
370	return 0;	370	return 0;
371	else if (!strncmp("zlib", value, len))	371	else if (!strncmp("zlib", value, 4))
372	return 0;	372	return 0;
373	else if (!strncmp("zstd", value, len))	373	else if (!strncmp("zstd", value, 4))
374	return 0;	374	return 0;
375		375
376	return -EINVAL;	376	return -EINVAL;
@@ -396,7 +396,7 @@ static int prop_compression_apply(struct inode *inode, · 19 unmodified lines
396	btrfs_set_fs_incompat(fs_info, COMPRESS_LZO);	396	btrfs_set_fs_incompat(fs_info, COMPRESS_LZO);
397	} else if (!strncmp("zlib", value, 4)) {	397	} else if (!strncmp("zlib", value, 4)) {
398	type = BTRFS_COMPRESS_ZLIB;	398	type = BTRFS_COMPRESS_ZLIB;
399	} else if (!strncmp("zstd", value, len)) {	399	} else if (!strncmp("zstd", value, 4)) {
400	type = BTRFS_COMPRESS_ZSTD;	400	type = BTRFS_COMPRESS_ZSTD;
401	btrfs_set_fs_incompat(fs_info, COMPRESS_ZSTD);	401	btrfs_set_fs_incompat(fs_info, COMPRESS_ZSTD);
402	} else {	402	} else {

fs/cifs/cifsfs.c+2−0

@@ -559,6 +559,8 @@ cifs_show_options(struct seq_file s, struct dentry root) · 558 unmodified lines
559	tcon->ses->server->echo_interval / HZ);	559	tcon->ses->server->echo_interval / HZ);
560	if (tcon->snapshot_time)	560	if (tcon->snapshot_time)
561	seq_printf(s, ",snapshot=%llu", tcon->snapshot_time);	561	seq_printf(s, ",snapshot=%llu", tcon->snapshot_time);
		562	if (tcon->handle_timeout)
		563	seq_printf(s, ",handletimeout=%u", tcon->handle_timeout);
562	/* convert actimeo and display it in seconds */	564	/* convert actimeo and display it in seconds */
563	seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);	565	seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
564		566

fs/cifs/cifsglob.h+10−0

  */
 #define CIFS_MAX_ACTIMEO (1 << 30)
+/*
+ * Max persistent and resilient handle timeout (milliseconds).
+ * Windows durable max was 960000 (16 minutes)
+ */
+#define SMB3_MAX_HANDLE_TIMEOUT 960000
 /*
  * MAX_REQ is the maximum number of requests that WE will send
  * on one socket concurrently.
 	struct nls_table *local_nls;
 	unsigned int echo_interval; /* echo interval in secs */
 	__u64 snapshot_time; /* needed for timewarp tokens */
+	__u32 handle_timeout; /* persistent and durable handle timeout in ms */
 	unsigned int max_credits; /* smb3 max_credits 10 < credits < 60000 */
 };
 	__u32 vol_serial_number;
 	__le64 vol_create_time;
 	__u64 snapshot_time; /* for timewarp tokens - timestamp of snapshot */
+	__u32 handle_timeout; /* persistent and durable handle timeout in ms */
 	__u32 ss_flags;		/* sector size flags */
 	__u32 perf_sector_size; /* best sector size for perf */
 	__u32 max_chunks;
 }
 struct cifsFileInfo *cifsFileInfo_get(struct cifsFileInfo *cifs_file);
+void _cifsFileInfo_put(struct cifsFileInfo *cifs_file, bool wait_oplock_hdlr);
 void cifsFileInfo_put(struct cifsFileInfo *cifs_file);
 #define CIFS_CACHE_READ_FLG	1
 #endif /* CONFIG_CIFS_ACL */
 void cifs_oplock_break(struct work_struct *work);
+void cifs_queue_oplock_break(struct cifsFileInfo *cfile);
 extern const struct slow_work_ops cifs_oplock_break_ops;
 extern struct workqueue_struct *cifsiod_wq;

fs/cifs/connect.c+29−1

 	Opt_cruid, Opt_gid, Opt_file_mode,
 	Opt_dirmode, Opt_port,
 	Opt_blocksize, Opt_rsize, Opt_wsize, Opt_actimeo,
-	Opt_echo_interval, Opt_max_credits,
+	Opt_echo_interval, Opt_max_credits, Opt_handletimeout,
 	Opt_snapshot,
 	/* Mount options which take string value */
 	{ Opt_rsize, "rsize=%s" },
 	{ Opt_wsize, "wsize=%s" },
 	{ Opt_actimeo, "actimeo=%s" },
+	{ Opt_handletimeout, "handletimeout=%s" },
 	{ Opt_echo_interval, "echo_interval=%s" },
 	{ Opt_max_credits, "max_credits=%s" },
 	{ Opt_snapshot, "snapshot=%s" },
 	vol->actimeo = CIFS_DEF_ACTIMEO;
+	/* Most clients set timeout to 0, allows server to use its default */
+	vol->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
 	/* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
 	vol->ops = &smb30_operations;
 	vol->vals = &smbdefault_values;
 				goto cifs_parse_mount_err;
 			}
 			break;
+		case Opt_handletimeout:
+			if (get_option_ul(args, &option)) {
+				cifs_dbg(VFS, "%s: Invalid handletimeout value\n",
+					 __func__);
+				goto cifs_parse_mount_err;
+			}
+			vol->handle_timeout = option;
+			if (vol->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
+				cifs_dbg(VFS, "Invalid handle cache timeout, longer than 16 minutes\n");
+				goto cifs_parse_mount_err;
+			}
+			break;
 		case Opt_echo_interval:
 			if (get_option_ul(args, &option)) {
 				cifs_dbg(VFS, "%s: Invalid echo interval value\n",
 		return 0;
 	if (tcon->snapshot_time != volume_info->snapshot_time)
 		return 0;
+	if (tcon->handle_timeout != volume_info->handle_timeout)
+		return 0;
 	return 1;
 }
 			tcon->snapshot_time = volume_info->snapshot_time;
 	}
+	if (volume_info->handle_timeout) {
+		if (ses->server->vals->protocol_id == 0) {
+			cifs_dbg(VFS,
+			     "Use SMB2.1 or later for handle timeout option\n");
+			rc = -EOPNOTSUPP;
+			goto out_fail;
+		} else
+			tcon->handle_timeout = volume_info->handle_timeout;
+	}
 	tcon->ses = ses;
 	if (volume_info->password) {
 		tcon->password = kstrdup(volume_info->password, GFP_KERNEL);

fs/cifs/file.c+25−5

 	return cifs_file;
 }
-/*
+/**
- * Release a reference on the file private data. This may involve closing
+ * cifsFileInfo_put - release a reference of file priv data
- * the filehandle out on the server. Must be called without holding
+ *
- * tcon->open_file_lock and cifs_file->file_info_lock.
+ * Always potentially wait for oplock handler. See _cifsFileInfo_put().
  */
 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
+{
+	_cifsFileInfo_put(cifs_file, true);
+}
+/**
+ * _cifsFileInfo_put - release a reference of file priv data
+ *
+ * This may involve closing the filehandle @cifs_file out on the
+ * server. Must be called without holding tcon->open_file_lock and
+ * cifs_file->file_info_lock.
+ *
+ * If @wait_for_oplock_handler is true and we are releasing the last
+ * reference, wait for any running oplock break handler of the file
+ * and cancel any pending one. If calling this function from the
+ * oplock break handler, you need to pass false.
+ *
+ */
+void _cifsFileInfo_put(struct cifsFileInfo *cifs_file, bool wait_oplock_handler)
 {
 	struct inode *inode = d_inode(cifs_file->dentry);
 	struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
 	spin_unlock(&tcon->open_file_lock);
-	oplock_break_cancelled = cancel_work_sync(&cifs_file->oplock_break);
+	oplock_break_cancelled = wait_oplock_handler ?
+		cancel_work_sync(&cifs_file->oplock_break) : false;
 	if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
 		struct TCP_Server_Info *server = tcon->ses->server;
 							     cinode);
 		cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
 	}
+	_cifsFileInfo_put(cfile, false /* do not wait for ourself */);
 	cifs_done_oplock_break(cinode);
 }

fs/cifs/misc.c+23−2

@@ -501,8 +501,7 @@ is_valid_oplock_break(char buffer, struct TCP_Server_Info srv) · 500 unmodified lines
501	CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2,	501	CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2,
502	&pCifsInode->flags);	502	&pCifsInode->flags);
503		503
504	queue_work(cifsoplockd_wq,	504	cifs_queue_oplock_break(netfile);
505	&netfile->oplock_break);
506	netfile->oplock_break_cancelled = false;	505	netfile->oplock_break_cancelled = false;
507		506
508	spin_unlock(&tcon->open_file_lock);	507	spin_unlock(&tcon->open_file_lock);
@@ -607,6 +606,28 @@ void cifs_put_writer(struct cifsInodeInfo *cinode) · 98 unmodified lines
607	spin_unlock(&cinode->writers_lock);	606	spin_unlock(&cinode->writers_lock);
608	}	607	}
609		608
		609	/**
		610	* cifs_queue_oplock_break - queue the oplock break handler for cfile
		611	*
		612	* This function is called from the demultiplex thread when it
		613	* receives an oplock break for @cfile.
		614	*
		615	* Assumes the tcon->open_file_lock is held.
		616	* Assumes cfile->file_info_lock is NOT held.
		617	*/
		618	void cifs_queue_oplock_break(struct cifsFileInfo *cfile)
		619	{
		620	/*
		621	* Bump the handle refcount now while we hold the
		622	* open_file_lock to enforce the validity of it for the oplock
		623	* break handler. The matching put is done at the end of the
		624	* handler.
		625	*/
		626	cifsFileInfo_get(cfile);
		627
		628	queue_work(cifsoplockd_wq, &cfile->oplock_break);
		629	}
		630
610	void cifs_done_oplock_break(struct cifsInodeInfo *cinode)	631	void cifs_done_oplock_break(struct cifsInodeInfo *cinode)
611	{	632	{
612	clear_bit(CIFS_INODE_PENDING_OPLOCK_BREAK, &cinode->flags);	633	clear_bit(CIFS_INODE_PENDING_OPLOCK_BREAK, &cinode->flags);

fs/cifs/smb2file.c+4−2

 	 if (oparms->tcon->use_resilient) {
-		nr_ioctl_req.Timeout = 0; /* use server default (120 seconds) */
+		/* default timeout is 0, servers pick default (120 seconds) */
+		nr_ioctl_req.Timeout =
+			cpu_to_le32(oparms->tcon->handle_timeout);
 		nr_ioctl_req.Reserved = 0;
 		rc = SMB2_ioctl(xid, oparms->tcon, fid->persistent_fid,
 			fid->volatile_fid, FSCTL_LMR_REQUEST_RESILIENCY,
 			true /* is_fsctl */,
 			(char *)&nr_ioctl_req, sizeof(nr_ioctl_req),
-			NULL, NULL /* no return info */);
+			CIFSMaxBufSize, NULL, NULL /* no return info */);
 		if (rc == -EOPNOTSUPP) {
 			cifs_dbg(VFS,
 			     "resiliency not supported by server, disabling\n");

fs/cifs/smb2misc.c+3−3

@@ -555,7 +555,7 @@ smb2_tcon_has_lease(struct cifs_tcon tcon, struct smb2_lease_break rsp, · 554 unmodified lines
555	clear_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2,	555	clear_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2,
556	&cinode->flags);	556	&cinode->flags);
557		557
558	queue_work(cifsoplockd_wq, &cfile->oplock_break);	558	cifs_queue_oplock_break(cfile);
559	kfree(lw);	559	kfree(lw);
560	return true;	560	return true;
561	}	561	}
@@ -712,8 +712,8 @@ smb2_is_valid_oplock_break(char buffer, struct TCP_Server_Info server) · 150 unmodified lines
712	CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2,	712	CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2,
713	&cinode->flags);	713	&cinode->flags);
714	spin_unlock(&cfile->file_info_lock);	714	spin_unlock(&cfile->file_info_lock);
715	queue_work(cifsoplockd_wq,	715
716	&cfile->oplock_break);	716	cifs_queue_oplock_break(cfile);
717		717
718	spin_unlock(&tcon->open_file_lock);	718	spin_unlock(&tcon->open_file_lock);
719	spin_unlock(&cifs_tcp_ses_lock);	719	spin_unlock(&cifs_tcp_ses_lock);

fs/cifs/smb2ops.c+44−26

 	rc = SMB2_ioctl(xid, tcon, NO_FILE_ID, NO_FILE_ID,
 			FSCTL_QUERY_NETWORK_INTERFACE_INFO, true /* is_fsctl */,
 			NULL /* no data input */, 0 /* no data input */,
-			(char **)&out_buf, &ret_data_len);
+			CIFSMaxBufSize, (char **)&out_buf, &ret_data_len);
 	if (rc == -EOPNOTSUPP) {
 		cifs_dbg(FYI,
 			 "server does not support query network interfaces\n");
 	oparms.fid->mid = le64_to_cpu(o_rsp->sync_hdr.MessageId);
 #endif /* CIFS_DEBUG2 */
-	if (o_rsp->OplockLevel == SMB2_OPLOCK_LEVEL_LEASE)
-		oplock = smb2_parse_lease_state(server, o_rsp,
-						&oparms.fid->epoch,
-						oparms.fid->lease_key);
-	else
-		goto oshr_exit;
 	memcpy(tcon->crfid.fid, pfid, sizeof(struct cifs_fid));
 	tcon->crfid.tcon = tcon;
 	tcon->crfid.is_valid = true;
 	kref_init(&tcon->crfid.refcount);
-	kref_get(&tcon->crfid.refcount);
+	if (o_rsp->OplockLevel == SMB2_OPLOCK_LEVEL_LEASE) {
+		kref_get(&tcon->crfid.refcount);
+		oplock = smb2_parse_lease_state(server, o_rsp,
+						&oparms.fid->epoch,
+						oparms.fid->lease_key);
+	} else
+		goto oshr_exit;
 	qi_rsp = (struct smb2_query_info_rsp *)rsp_iov[1].iov_base;
 	if (le32_to_cpu(qi_rsp->OutputBufferLength) < sizeof(struct smb2_file_all_info))
 		goto oshr_exit;
-	rc = smb2_validate_and_copy_iov(
+	if (!smb2_validate_and_copy_iov(
 				le16_to_cpu(qi_rsp->OutputBufferOffset),
 				sizeof(struct smb2_file_all_info),
 				&rsp_iov[1], sizeof(struct smb2_file_all_info),
-				(char *)&tcon->crfid.file_all_info);
+				(char *)&tcon->crfid.file_all_info))
-	if (rc)
+		tcon->crfid.file_all_info_is_valid = 1;
-		goto oshr_exit;
-	tcon->crfid.file_all_info_is_valid = 1;
  oshr_exit:
 	mutex_unlock(&tcon->crfid.fid_mutex);
 	rc = SMB2_ioctl(xid, tcon, persistent_fid, volatile_fid,
 			FSCTL_SRV_REQUEST_RESUME_KEY, true /* is_fsctl */,
-			NULL, 0 /* no input */,
+			NULL, 0 /* no input */, CIFSMaxBufSize,
 			(char **)&res_key, &ret_data_len);
 	if (rc) {
 			rc = SMB2_ioctl_init(tcon, &rqst[1],
 					     COMPOUND_FID, COMPOUND_FID,
 					     qi.info_type, true, NULL,
-					     0);
+					     0, CIFSMaxBufSize);
 		}
 	} else if (qi.flags == PASSTHRU_QUERY_INFO) {
 		memset(&qi_iov, 0, sizeof(qi_iov));
 		rc = SMB2_ioctl(xid, tcon, trgtfile->fid.persistent_fid,
 			trgtfile->fid.volatile_fid, FSCTL_SRV_COPYCHUNK_WRITE,
 			true /* is_fsctl */, (char *)pcchunk,
-			sizeof(struct copychunk_ioctl),	(char **)&retbuf,
+			sizeof(struct copychunk_ioctl),	CIFSMaxBufSize,
-			&ret_data_len);
+			(char **)&retbuf, &ret_data_len);
 		if (rc == 0) {
 			if (ret_data_len !=
 					sizeof(struct copychunk_ioctl_rsp)) {
 	rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid,
 			cfile->fid.volatile_fid, FSCTL_SET_SPARSE,
 			true /* is_fctl */,
-			&setsparse, 1, NULL, NULL);
+			&setsparse, 1, CIFSMaxBufSize, NULL, NULL);
 	if (rc) {
 		tcon->broken_sparse_sup = true;
 		cifs_dbg(FYI, "set sparse rc = %d\n", rc);
 			true /* is_fsctl */,
 			(char *)&dup_ext_buf,
 			sizeof(struct duplicate_extents_to_file),
-			NULL,
+			CIFSMaxBufSize, NULL,
 			&ret_data_len);
 	if (ret_data_len > 0)
 			true /* is_fsctl */,
 			(char *)&integr_info,
 			sizeof(struct fsctl_set_integrity_information_req),
-			NULL,
+			CIFSMaxBufSize, NULL,
 			&ret_data_len);
 }
 /* GMT Token is @GMT-YYYY.MM.DD-HH.MM.SS Unicode which is 48 bytes + null */
 #define GMT_TOKEN_SIZE 50
+#define MIN_SNAPSHOT_ARRAY_SIZE 16 /* See MS-SMB2 section 3.3.5.15.1 */
 /*
  * Input buffer contains (empty) struct smb_snapshot array with size filled in
  * For output see struct SRV_SNAPSHOT_ARRAY in MS-SMB2 section 2.2.32.2
 	char *retbuf = NULL;
 	unsigned int ret_data_len = 0;
 	int rc;
+	u32 max_response_size;
 	struct smb_snapshot_array snapshot_in;
+	if (get_user(ret_data_len, (unsigned int __user *)ioc_buf))
+		return -EFAULT;
+	/*
+	 * Note that for snapshot queries that servers like Azure expect that
+	 * the first query be minimal size (and just used to get the number/size
+	 * of previous versions) so response size must be specified as EXACTLY
+	 * sizeof(struct snapshot_array) which is 16 when rounded up to multiple
+	 * of eight bytes.
+	 */
+	if (ret_data_len == 0)
+		max_response_size = MIN_SNAPSHOT_ARRAY_SIZE;
+	else
+		max_response_size = CIFSMaxBufSize;
 	rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid,
 			cfile->fid.volatile_fid,
 			FSCTL_SRV_ENUMERATE_SNAPSHOTS,
 			true /* is_fsctl */,
-			NULL, 0 /* no input data */,
+			NULL, 0 /* no input data */, max_response_size,
 			(char **)&retbuf,
 			&ret_data_len);
 	cifs_dbg(FYI, "enum snaphots ioctl returned %d and ret buflen is %d\n",
 		rc = SMB2_ioctl(xid, tcon, NO_FILE_ID, NO_FILE_ID,
 				FSCTL_DFS_GET_REFERRALS,
 				true /* is_fsctl */,
-				(char *)dfs_req, dfs_req_size,
+				(char *)dfs_req, dfs_req_size, CIFSMaxBufSize,
 				(char **)&dfs_rsp, &dfs_rsp_size);
 	} while (rc == -EAGAIN);
 	rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, &err_iov,
 		       &resp_buftype);
+	if (!rc)
+		SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
 	if (!rc || !err_iov.iov_base) {
 		rc = -ENOENT;
 		goto free_path;
 	rc = SMB2_ioctl_init(tcon, &rqst[num++], cfile->fid.persistent_fid,
 			     cfile->fid.volatile_fid, FSCTL_SET_ZERO_DATA,
 			     true /* is_fctl */, (char *)&fsctl_buf,
-			     sizeof(struct file_zero_data_information));
+			     sizeof(struct file_zero_data_information),
+			     CIFSMaxBufSize);
 	if (rc)
 		goto zero_range_exit;
 	rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid,
 			cfile->fid.volatile_fid, FSCTL_SET_ZERO_DATA,
 			true /* is_fctl */, (char *)&fsctl_buf,
-			sizeof(struct file_zero_data_information), NULL, NULL);
+			sizeof(struct file_zero_data_information),
+			CIFSMaxBufSize, NULL, NULL);
 	free_xid(xid);
 	return rc;
 }

fs/cifs/smb2pdu.c+40−20

 		} else if (rsp->DialectRevision == cpu_to_le16(SMB21_PROT_ID)) {
 			/* ops set to 3.0 by default for default so update */
 			ses->server->ops = &smb21_operations;
-		} else if (rsp->DialectRevision == cpu_to_le16(SMB311_PROT_ID))
+			ses->server->vals = &smb21_values;
+		} else if (rsp->DialectRevision == cpu_to_le16(SMB311_PROT_ID)) {
 			ses->server->ops = &smb311_operations;
+			ses->server->vals = &smb311_values;
+		}
 	} else if (le16_to_cpu(rsp->DialectRevision) !=
 				ses->server->vals->protocol_id) {
 		/* if requested single dialect ensure returned dialect matched */
 	rc = SMB2_ioctl(xid, tcon, NO_FILE_ID, NO_FILE_ID,
 		FSCTL_VALIDATE_NEGOTIATE_INFO, true /* is_fsctl */,
-		(char *)pneg_inbuf, inbuflen, (char **)&pneg_rsp, &rsplen);
+		(char *)pneg_inbuf, inbuflen, CIFSMaxBufSize,
+		(char **)&pneg_rsp, &rsplen);
 	if (rc == -EOPNOTSUPP) {
 		/*
 		 * Old Windows versions or Netapp SMB server can return
 }
 static struct create_durable_v2 *
-create_durable_v2_buf(struct cifs_fid *pfid)
+create_durable_v2_buf(struct cifs_open_parms *oparms)
 {
+	struct cifs_fid *pfid = oparms->fid;
 	struct create_durable_v2 *buf;
 	buf = kzalloc(sizeof(struct create_durable_v2), GFP_KERNEL);
 				(struct create_durable_v2, Name));
 	buf->ccontext.NameLength = cpu_to_le16(4);
-	buf->dcontext.Timeout = 0; /* Should this be configurable by workload */
+	/*
+	 * NB: Handle timeout defaults to 0, which allows server to choose
+	 * (most servers default to 120 seconds) and most clients default to 0.
+	 * This can be overridden at mount ("handletimeout=") if the user wants
+	 * a different persistent (or resilient) handle timeout for all opens
+	 * opens on a particular SMB3 mount.
+	 */
+	buf->dcontext.Timeout = cpu_to_le32(oparms->tcon->handle_timeout);
 	buf->dcontext.Flags = cpu_to_le32(SMB2_DHANDLE_FLAG_PERSISTENT);
 	generate_random_uuid(buf->dcontext.CreateGuid);
 	memcpy(pfid->create_guid, buf->dcontext.CreateGuid, 16);
 	struct smb2_create_req *req = iov[0].iov_base;
 	unsigned int num = *num_iovec;
-	iov[num].iov_base = create_durable_v2_buf(oparms->fid);
+	iov[num].iov_base = create_durable_v2_buf(oparms);
 	if (iov[num].iov_base == NULL)
 		return -ENOMEM;
 	iov[num].iov_len = sizeof(struct create_durable_v2);
 int
 SMB2_ioctl_init(struct cifs_tcon *tcon, struct smb_rqst *rqst,
 		u64 persistent_fid, u64 volatile_fid, u32 opcode,
-		bool is_fsctl, char *in_data, u32 indatalen)
+		bool is_fsctl, char *in_data, u32 indatalen,
+		__u32 max_response_size)
 {
 	struct smb2_ioctl_req *req;
 	struct kvec *iov = rqst->rq_iov;
 	req->OutputCount = 0; /* MBZ */
 	/*
-	 * Could increase MaxOutputResponse, but that would require more
+	 * In most cases max_response_size is set to 16K (CIFSMaxBufSize)
-	 * than one credit. Windows typically sets this smaller, but for some
+	 * We Could increase default MaxOutputResponse, but that could require
+	 * more credits. Windows typically sets this smaller, but for some
 	 * ioctls it may be useful to allow server to send more. No point
 	 * limiting what the server can send as long as fits in one credit
-	 * Unfortunately - we can not handle more than CIFS_MAX_MSG_SIZE
+	 * We can not handle more than CIFS_MAX_BUF_SIZE yet but may want
-	 * (by default, note that it can be overridden to make max larger)
+	 * to increase this limit up in the future.
-	 * in responses (except for read responses which can be bigger.
+	 * Note that for snapshot queries that servers like Azure expect that
-	 * We may want to bump this limit up
+	 * the first query be minimal size (and just used to get the number/size
+	 * of previous versions) so response size must be specified as EXACTLY
+	 * sizeof(struct snapshot_array) which is 16 when rounded up to multiple
+	 * of eight bytes.  Currently that is the only case where we set max
+	 * response size smaller.
 	 */
-	req->MaxOutputResponse = cpu_to_le32(CIFSMaxBufSize);
+	req->MaxOutputResponse = cpu_to_le32(max_response_size);
 	if (is_fsctl)
 		req->Flags = cpu_to_le32(SMB2_0_IOCTL_IS_FSCTL);
 		cifs_small_buf_release(rqst->rq_iov[0].iov_base); /* request */
 }
 /*
  *	SMB2 IOCTL is used for both IOCTLs and FSCTLs
  */
 int
 SMB2_ioctl(const unsigned int xid, struct cifs_tcon *tcon, u64 persistent_fid,
 	   u64 volatile_fid, u32 opcode, bool is_fsctl,
-	   char *in_data, u32 indatalen,
+	   char *in_data, u32 indatalen, u32 max_out_data_len,
 	   char **out_data, u32 *plen /* returned data len */)
 {
 	struct smb_rqst rqst;
 	rqst.rq_iov = iov;
 	rqst.rq_nvec = SMB2_IOCTL_IOV_SIZE;
-	rc = SMB2_ioctl_init(tcon, &rqst, persistent_fid, volatile_fid,
+	rc = SMB2_ioctl_init(tcon, &rqst, persistent_fid, volatile_fid, opcode,
-			     opcode, is_fsctl, in_data, indatalen);
+			     is_fsctl, in_data, indatalen, max_out_data_len);
 	if (rc)
 		goto ioctl_exit;
 	rc = SMB2_ioctl(xid, tcon, persistent_fid, volatile_fid,
 			FSCTL_SET_COMPRESSION, true /* is_fsctl */,
 			(char *)&fsctl_input /* data input */,
-			2 /* in data len */, &ret_data /* out data */, NULL);
+			2 /* in data len */, CIFSMaxBufSize /* max out data */,
+			&ret_data /* out data */, NULL);
 	cifs_dbg(FYI, "set compression rc %d\n", rc);
 	rqst.rq_nvec = 1;
 	rc = cifs_send_recv(xid, ses, &rqst, &resp_buftype, flags, &rsp_iov);
-	cifs_small_buf_release(req);
 	rsp = (struct smb2_read_rsp *)rsp_iov.iov_base;
 	if (rc) {
 				    io_parms->tcon->tid, ses->Suid,
 				    io_parms->offset, io_parms->length);
+	cifs_small_buf_release(req);
 	*nbytes = le32_to_cpu(rsp->DataLength);
 	if ((*nbytes > CIFS_MAX_MSGSIZE) ||
 	    (*nbytes > io_parms->length)) {
 	rc = cifs_send_recv(xid, io_parms->tcon->ses, &rqst,
 			    &resp_buftype, flags, &rsp_iov);
-	cifs_small_buf_release(req);
 	rsp = (struct smb2_write_rsp *)rsp_iov.iov_base;
 	if (rc) {
 				     io_parms->offset, *nbytes);
 	}
+	cifs_small_buf_release(req);
 	free_rsp_buf(resp_buftype, rsp);
 	return rc;
 }

fs/cifs/smb2proto.h+3−2

 extern void SMB2_open_free(struct smb_rqst *rqst);
 extern int SMB2_ioctl(const unsigned int xid, struct cifs_tcon *tcon,
 		     u64 persistent_fid, u64 volatile_fid, u32 opcode,
-		     bool is_fsctl, char *in_data, u32 indatalen,
+		     bool is_fsctl, char *in_data, u32 indatalen, u32 maxoutlen,
 		     char **out_data, u32 *plen /* returned data len */);
 extern int SMB2_ioctl_init(struct cifs_tcon *tcon, struct smb_rqst *rqst,
 			   u64 persistent_fid, u64 volatile_fid, u32 opcode,
-			   bool is_fsctl, char *in_data, u32 indatalen);
+			   bool is_fsctl, char *in_data, u32 indatalen,
+			   __u32 max_response_size);
 extern void SMB2_ioctl_free(struct smb_rqst *rqst);
 extern int SMB2_close(const unsigned int xid, struct cifs_tcon *tcon,
 		      u64 persistent_file_id, u64 volatile_file_id);

fs/dax.c+15−0

 #include <linux/sizes.h>
 #include <linux/mmu_notifier.h>
 #include <linux/iomap.h>
+#include <asm/pgalloc.h>
 #include "internal.h"
 #define CREATE_TRACE_POINTS
 {
 	struct address_space *mapping = vmf->vma->vm_file->f_mapping;
 	unsigned long pmd_addr = vmf->address & PMD_MASK;
+	struct vm_area_struct *vma = vmf->vma;
 	struct inode *inode = mapping->host;
+	pgtable_t pgtable = NULL;
 	struct page *zero_page;
 	spinlock_t *ptl;
 	pmd_t pmd_entry;
 	*entry = dax_insert_entry(xas, mapping, vmf, *entry, pfn,
 			DAX_PMD | DAX_ZERO_PAGE, false);
+	if (arch_needs_pgtable_deposit()) {
+		pgtable = pte_alloc_one(vma->vm_mm);
+		if (!pgtable)
+			return VM_FAULT_OOM;
+	}
 	ptl = pmd_lock(vmf->vma->vm_mm, vmf->pmd);
 	if (!pmd_none(*(vmf->pmd))) {
 		spin_unlock(ptl);
 		goto fallback;
 	}
+	if (pgtable) {
+		pgtable_trans_huge_deposit(vma->vm_mm, vmf->pmd, pgtable);
+		mm_inc_nr_ptes(vma->vm_mm);
+	}
 	pmd_entry = mk_pmd(zero_page, vmf->vma->vm_page_prot);
 	pmd_entry = pmd_mkhuge(pmd_entry);
 	set_pmd_at(vmf->vma->vm_mm, pmd_addr, vmf->pmd, pmd_entry);
 	return VM_FAULT_NOPAGE;
 fallback:
+	if (pgtable)
+		pte_free(vma->vm_mm, pgtable);
 	trace_dax_pmd_load_hole_fallback(inode, vmf, zero_page, *entry);
 	return VM_FAULT_FALLBACK;
 }

fs/debugfs/inode.c+9−4

 	return 0;
 }
-static void debugfs_evict_inode(struct inode *inode)
+static void debugfs_i_callback(struct rcu_head *head)
 {
-	truncate_inode_pages_final(&inode->i_data);
+	struct inode *inode = container_of(head, struct inode, i_rcu);
-	clear_inode(inode);
 	if (S_ISLNK(inode->i_mode))
 		kfree(inode->i_link);
+	free_inode_nonrcu(inode);
+}
+static void debugfs_destroy_inode(struct inode *inode)
+{
+	call_rcu(&inode->i_rcu, debugfs_i_callback);
 }
 static const struct super_operations debugfs_super_operations = {
 	.statfs		= simple_statfs,
 	.remount_fs	= debugfs_remount,
 	.show_options	= debugfs_show_options,
-	.evict_inode	= debugfs_evict_inode,
+	.destroy_inode	= debugfs_destroy_inode,
 };
 static void debugfs_release_dentry(struct dentry *dentry)

fs/fuse/dev.c+6−6

 		rem += pipe->bufs[(pipe->curbuf + idx) & (pipe->buffers - 1)].len;
 	ret = -EINVAL;
-	if (rem < len) {
+	if (rem < len)
-		pipe_unlock(pipe);
+		goto out_free;
-		goto out;
-	}
 	rem = len;
 	while (rem) {
 			pipe->curbuf = (pipe->curbuf + 1) & (pipe->buffers - 1);
 			pipe->nrbufs--;
 		} else {
-			pipe_buf_get(pipe, ibuf);
+			if (!pipe_buf_get(pipe, ibuf))
+				goto out_free;
 			*obuf = *ibuf;
 			obuf->flags &= ~PIPE_BUF_FLAG_GIFT;
 			obuf->len = rem;
 	ret = fuse_dev_do_write(fud, &cs, len);
 	pipe_lock(pipe);
+out_free:
 	for (idx = 0; idx < nbuf; idx++)
 		pipe_buf_release(pipe, &bufs[idx]);
 	pipe_unlock(pipe);
-out:
 	kvfree(bufs);
 	return ret;
 }

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+35−11

 	tail = ctx->cached_cq_tail;
 	/* See comment at the top of the file */
 	smp_rmb();
-	if (tail + 1 == READ_ONCE(ring->r.head))
+	if (tail - READ_ONCE(ring->r.head) == ring->ring_entries)
 		return NULL;
 	ctx->cached_cq_tail++;
 		list_add_tail(&req->list, &ctx->poll_list);
 }
-static void io_file_put(struct io_submit_state *state, struct file *file)
+static void io_file_put(struct io_submit_state *state)
 {
-	if (!state) {
+	if (state->file) {
-		fput(file);
-	} else if (state->file) {
 		int diff = state->has_refs - state->used_refs;
 		if (diff)
 			state->ios_left--;
 			return state->file;
 		}
-		io_file_put(state, NULL);
+		io_file_put(state);
 	}
 	state->file = fget_many(fd, state->ios_left);
 	if (!state->file)
 static void io_submit_state_end(struct io_submit_state *state)
 {
 	blk_finish_plug(&state->plug);
-	io_file_put(state, NULL);
+	io_file_put(state);
 	if (state->free_reqs)
 		kmem_cache_free_bulk(req_cachep, state->free_reqs,
 					&state->reqs[state->cur_req]);
 		unuse_mm(cur_mm);
 		mmput(cur_mm);
 	}
+	if (kthread_should_park())
+		kthread_parkme();
 	return 0;
 }
 	if (ctx->sqo_thread) {
 		ctx->sqo_stop = 1;
 		mb();
+		kthread_park(ctx->sqo_thread);
 		kthread_stop(ctx->sqo_thread);
 		ctx->sqo_thread = NULL;
 	}
 			fput(ctx->user_files[i]);
 		kfree(ctx->user_files);
+		ctx->user_files = NULL;
 		ctx->nr_user_files = 0;
 		return ret;
 	}
 	mmgrab(current->mm);
 	ctx->sqo_mm = current->mm;
-	ctx->sq_thread_idle = msecs_to_jiffies(p->sq_thread_idle);
-	if (!ctx->sq_thread_idle)
-		ctx->sq_thread_idle = HZ;
 	ret = -EINVAL;
 	if (!cpu_possible(p->sq_thread_cpu))
 		goto err;
 	if (ctx->flags & IORING_SETUP_SQPOLL) {
+		ret = -EPERM;
+		if (!capable(CAP_SYS_ADMIN))
+			goto err;
+		ctx->sq_thread_idle = msecs_to_jiffies(p->sq_thread_idle);
+		if (!ctx->sq_thread_idle)
+			ctx->sq_thread_idle = HZ;
 		if (p->flags & IORING_SETUP_SQ_AFF) {
 			int cpu;
 			cpu = array_index_nospec(p->sq_thread_cpu, NR_CPUS);
+			ret = -EINVAL;
+			if (!cpu_possible(p->sq_thread_cpu))
+				goto err;
 			ctx->sqo_thread = kthread_create_on_cpu(io_sq_thread,
 							ctx, cpu,
 							"io_uring-sq");
 static int __io_uring_register(struct io_ring_ctx *ctx, unsigned opcode,
 			       void __user *arg, unsigned nr_args)
+	__releases(ctx->uring_lock)
+	__acquires(ctx->uring_lock)
 {
 	int ret;
 	percpu_ref_kill(&ctx->refs);
+	/*
+	 * Drop uring mutex before waiting for references to exit. If another
+	 * thread is currently inside io_uring_enter() it might need to grab
+	 * the uring_lock to make progress. If we hold it here across the drain
+	 * wait, then we can deadlock. It's safe to drop the mutex here, since
+	 * no new references will come in after we've killed the percpu ref.
+	 */
+	mutex_unlock(&ctx->uring_lock);
 	wait_for_completion(&ctx->ctx_done);
+	mutex_lock(&ctx->uring_lock);
 	switch (opcode) {
 	case IORING_REGISTER_BUFFERS:

fs/jffs2/readinode.c+0−5

 	jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL);
-	if (f->target) {
-		kfree(f->target);
-		f->target = NULL;
-	}
 	fds = f->dents;
 	while(fds) {
 		fd = fds;

fs/jffs2/super.c+4−1

 static void jffs2_i_callback(struct rcu_head *head)
 {
 	struct inode *inode = container_of(head, struct inode, i_rcu);
-	kmem_cache_free(jffs2_inode_cachep, JFFS2_INODE_INFO(inode));
+	struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
+	kfree(f->target);
+	kmem_cache_free(jffs2_inode_cachep, f);
 }
 static void jffs2_destroy_inode(struct inode *inode)

fs/nfs/nfs42proc.c+0−3

@@ -329,9 +329,6 @@ ssize_t nfs42_proc_copy(struct file *src, loff_t pos_src, · 328 unmodified lines
329	};	329	};
330	ssize_t err, err2;	330	ssize_t err, err2;
331		331
332	if (!nfs_server_capable(file_inode(dst), NFS_CAP_COPY))
333	return -EOPNOTSUPP;
334
335	src_lock = nfs_get_lock_context(nfs_file_open_context(src));	332	src_lock = nfs_get_lock_context(nfs_file_open_context(src));
336	if (IS_ERR(src_lock))	333	if (IS_ERR(src_lock))
337	return PTR_ERR(src_lock);	334	return PTR_ERR(src_lock);

fs/nfs/nfs4file.c+3−1

 				    struct file *file_out, loff_t pos_out,
 				    size_t count, unsigned int flags)
 {
+	if (!nfs_server_capable(file_inode(file_out), NFS_CAP_COPY))
+		return -EOPNOTSUPP;
 	if (file_inode(file_in) == file_inode(file_out))
-		return -EINVAL;
+		return -EOPNOTSUPP;
 	return nfs42_proc_copy(file_in, pos_in, file_out, pos_out, count);
 }

fs/nfs/nfs4xdr.c+2−2

@@ -2589,7 +2589,7 @@ static void nfs4_xdr_enc_getacl(struct rpc_rqst req, struct xdr_stream xdr, · 2588 unmodified lines
2589	ARRAY_SIZE(nfs4_acl_bitmap), &hdr);	2589	ARRAY_SIZE(nfs4_acl_bitmap), &hdr);
2590		2590
2591	rpc_prepare_reply_pages(req, args->acl_pages, 0,	2591	rpc_prepare_reply_pages(req, args->acl_pages, 0,
2592	args->acl_len, replen);	2592	args->acl_len, replen + 1);
2593	encode_nops(&hdr);	2593	encode_nops(&hdr);
2594	}	2594	}
2595		2595
@@ -2811,7 +2811,7 @@ static void nfs4_xdr_enc_fs_locations(struct rpc_rqst *req, · 215 unmodified lines
2811	}	2811	}
2812		2812
2813	rpc_prepare_reply_pages(req, (struct page **)&args->page, 0,	2813	rpc_prepare_reply_pages(req, (struct page **)&args->page, 0,
2814	PAGE_SIZE, replen);	2814	PAGE_SIZE, replen + 1);
2815	encode_nops(&hdr);	2815	encode_nops(&hdr);
2816	}	2816	}
2817		2817

fs/nfs/super.c+2−1

@@ -2041,7 +2041,8 @@ static int nfs23_validate_mount_data(void *options, · 2040 unmodified lines
2041	memcpy(sap, &data->addr, sizeof(data->addr));	2041	memcpy(sap, &data->addr, sizeof(data->addr));
2042	args->nfs_server.addrlen = sizeof(data->addr);	2042	args->nfs_server.addrlen = sizeof(data->addr);
2043	args->nfs_server.port = ntohs(data->addr.sin_port);	2043	args->nfs_server.port = ntohs(data->addr.sin_port);
2044	if (!nfs_verify_server_address(sap))	2044	if (sap->sa_family != AF_INET \|\|
		2045	!nfs_verify_server_address(sap))
2045	goto out_no_address;	2046	goto out_no_address;
2046		2047
2047	if (!(data->flags & NFS_MOUNT_TCP))	2048	if (!(data->flags & NFS_MOUNT_TCP))

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/pipe.c+2−2

@@ -188,9 +188,9 @@ EXPORT_SYMBOL(generic_pipe_buf_steal); · 187 unmodified lines
188	* in the tee() system call, when we duplicate the buffers in one	188	* in the tee() system call, when we duplicate the buffers in one
189	* pipe into another.	189	* pipe into another.
190	*/	190	*/
191	void generic_pipe_buf_get(struct pipe_inode_info pipe, struct pipe_buffer buf)	191	bool generic_pipe_buf_get(struct pipe_inode_info pipe, struct pipe_buffer buf)
192	{	192	{
193	get_page(buf->page);	193	return try_get_page(buf->page);
194	}	194	}
195	EXPORT_SYMBOL(generic_pipe_buf_get);	195	EXPORT_SYMBOL(generic_pipe_buf_get);
196		196

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/proc/task_mmu.c+18−0

@@ -1143,6 +1143,24 @@ static ssize_t clear_refs_write(struct file file, const char __user buf, · 1142 unmodified lines
1143	count = -EINTR;	1143	count = -EINTR;
1144	goto out_mm;	1144	goto out_mm;
1145	}	1145	}
		1146	/*
		1147	* Avoid to modify vma->vm_flags
		1148	* without locked ops while the
		1149	* coredump reads the vm_flags.
		1150	*/
		1151	if (!mmget_still_valid(mm)) {
		1152	/*
		1153	* Silently return "count"
		1154	* like if get_task_mm()
		1155	* failed. FIXME: should this
		1156	* function have returned
		1157	* -ESRCH if get_task_mm()
		1158	* failed like if
		1159	* get_proc_task() fails?
		1160	*/
		1161	up_write(&mm->mmap_sem);
		1162	goto out_mm;
		1163	}
1146	for (vma = mm->mmap; vma; vma = vma->vm_next) {	1164	for (vma = mm->mmap; vma; vma = vma->vm_next) {
1147	vma->vm_flags &= ~VM_SOFTDIRTY;	1165	vma->vm_flags &= ~VM_SOFTDIRTY;
1148	vma_set_page_prot(vma);	1166	vma_set_page_prot(vma);

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)

fs/splice.c+10−2

 			 * Get a reference to this pipe buffer,
 			 * so we can copy the contents over.
 			 */
-			pipe_buf_get(ipipe, ibuf);
+			if (!pipe_buf_get(ipipe, ibuf)) {
+				if (ret == 0)
+					ret = -EFAULT;
+				break;
+			}
 			*obuf = *ibuf;
 			/*
 		 * Get a reference to this pipe buffer,
 		 * so we can copy the contents over.
 		 */
-		pipe_buf_get(ipipe, ibuf);
+		if (!pipe_buf_get(ipipe, ibuf)) {
+			if (ret == 0)
+				ret = -EFAULT;
+			break;
+		}
 		obuf = opipe->bufs + nbuf;
 		*obuf = *ibuf;

fs/ubifs/super.c+1−3

 {
 	struct inode *inode = container_of(head, struct inode, i_rcu);
 	struct ubifs_inode *ui = ubifs_inode(inode);
+	kfree(ui->data);
 	kmem_cache_free(ubifs_inode_slab, ui);
 }
 static void ubifs_destroy_inode(struct inode *inode)
 {
-	struct ubifs_inode *ui = ubifs_inode(inode);
-	kfree(ui->data);
 	call_rcu(&inode->i_rcu, ubifs_i_callback);
 }

fs/userfaultfd.c+9−0

 		/* the various vma->vm_userfaultfd_ctx still points to it */
 		down_write(&mm->mmap_sem);
+		/* no task can run (and in turn coredump) yet */
+		VM_WARN_ON(!mmget_still_valid(mm));
 		for (vma = mm->mmap; vma; vma = vma->vm_next)
 			if (vma->vm_userfaultfd_ctx.ctx == release_new_ctx) {
 				vma->vm_userfaultfd_ctx = NULL_VM_UFFD_CTX;
 	 * taking the mmap_sem for writing.
 	 */
 	down_write(&mm->mmap_sem);
+	if (!mmget_still_valid(mm))
+		goto skip_mm;
 	prev = NULL;
 	for (vma = mm->mmap; vma; vma = vma->vm_next) {
 		cond_resched();
 		vma->vm_flags = new_flags;
 		vma->vm_userfaultfd_ctx = NULL_VM_UFFD_CTX;
 	}
+skip_mm:
 	up_write(&mm->mmap_sem);
 	mmput(mm);
 wakeup:
 		goto out;
 	down_write(&mm->mmap_sem);
+	if (!mmget_still_valid(mm))
+		goto out_unlock;
 	vma = find_vma_prev(mm, start, &prev);
 	if (!vma)
 		goto out_unlock;
 		goto out;
 	down_write(&mm->mmap_sem);
+	if (!mmget_still_valid(mm))
+		goto out_unlock;
 	vma = find_vma_prev(mm, start, &prev);
 	if (!vma)
 		goto out_unlock;

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/drm/drm_modeset_helper_vtables.h+4−0

 	 * Drivers can use the @old_crtc_state input parameter if the operations
 	 * needed to enable the CRTC don't depend solely on the new state but
 	 * also on the transition between the old state and the new state.
+	 *
+	 * This function is optional.
 	 */
 	void (*atomic_enable)(struct drm_crtc *crtc,
 			      struct drm_crtc_state *old_crtc_state);
 	 * parameter @old_crtc_state which could be used to access the old
 	 * state. Atomic drivers should consider to use this one instead
 	 * of @disable.
+	 *
+	 * This function is optional.
 	 */
 	void (*atomic_disable)(struct drm_crtc *crtc,
 			       struct drm_crtc_state *old_crtc_state);

include/dt-bindings/clock/sifive-fu540-prci.h+18−0

@@ -0,0 +1,18 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	/*
	3	* Copyright (C) 2018-2019 SiFive, Inc.
	4	* Wesley Terpstra
	5	* Paul Walmsley
	6	*/
	7
	8	#ifndef __DT_BINDINGS_CLOCK_SIFIVE_FU540_PRCI_H
	9	#define __DT_BINDINGS_CLOCK_SIFIVE_FU540_PRCI_H
	10
	11	/* Clock indexes for use by Device Tree data and the PRCI driver */
	12
	13	#define PRCI_CLK_COREPLL 0
	14	#define PRCI_CLK_DDRPLL 1
	15	#define PRCI_CLK_GEMGXLPLL 2
	16	#define PRCI_CLK_TLCLK 3
	17
	18	#endif

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/bio.h+12−8

@@ -120,19 +120,23 @@ static inline bool bio_full(struct bio *bio) · 119 unmodified lines
120	return bio->bi_vcnt >= bio->bi_max_vecs;	120	return bio->bi_vcnt >= bio->bi_max_vecs;
121	}	121	}
122		122
123	#define mp_bvec_for_each_segment(bv, bvl, i, iter_all) \	123	static inline bool bio_next_segment(const struct bio *bio,
124	for (bv = bvec_init_iter_all(&iter_all); \	124	struct bvec_iter_all *iter)
125	(iter_all.done < (bvl)->bv_len) && \	125	{
126	(mp_bvec_next_segment((bvl), &iter_all), 1); \	126	if (iter->idx >= bio->bi_vcnt)
127	iter_all.done += bv->bv_len, i += 1)	127	return false;
		128
		129	bvec_advance(&bio->bi_io_vec[iter->idx], iter);
		130	return true;
		131	}
128		132
129	/*	133	/*
130	* drivers should _never_ use the all version - the bio may have been split	134	* drivers should _never_ use the all version - the bio may have been split
131	* before it got to the driver and the driver won't own all of it	135	* before it got to the driver and the driver won't own all of it
132	*/	136	*/
133	#define bio_for_each_segment_all(bvl, bio, i, iter_all) \	137	#define bio_for_each_segment_all(bvl, bio, i, iter) \
134	for (i = 0, iter_all.idx = 0; iter_all.idx < (bio)->bi_vcnt; iter_all.idx++) \	138	for (i = 0, bvl = bvec_init_iter_all(&iter); \
135	mp_bvec_for_each_segment(bvl, &((bio)->bi_io_vec[iter_all.idx]), i, iter_all)	139	bio_next_segment((bio), &iter); i++)
136		140
137	static inline void bio_advance_iter(struct bio bio, struct bvec_iter iter,	141	static inline void bio_advance_iter(struct bio bio, struct bvec_iter iter,
138	unsigned bytes)	142	unsigned bytes)

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/blk-mq.h+1−0

@@ -302,6 +302,7 @@ void blk_mq_requeue_request(struct request *rq, bool kick_requeue_list); · 301 unmodified lines
302	void blk_mq_kick_requeue_list(struct request_queue *q);	302	void blk_mq_kick_requeue_list(struct request_queue *q);
303	void blk_mq_delay_kick_requeue_list(struct request_queue *q, unsigned long msecs);	303	void blk_mq_delay_kick_requeue_list(struct request_queue *q, unsigned long msecs);
304	bool blk_mq_complete_request(struct request *rq);	304	bool blk_mq_complete_request(struct request *rq);
		305	void blk_mq_complete_request_sync(struct request *rq);
305	bool blk_mq_bio_list_merge(struct request_queue q, struct list_head list,	306	bool blk_mq_bio_list_merge(struct request_queue q, struct list_head list,
306	struct bio *bio);	307	struct bio *bio);
307	bool blk_mq_queue_stopped(struct request_queue *q);	308	bool blk_mq_queue_stopped(struct request_queue *q);

include/linux/blkdev.h+0−1

@@ -548,7 +548,6 @@ struct request_queue { · 547 unmodified lines
548	struct rcu_head rcu_head;	548	struct rcu_head rcu_head;
549	wait_queue_head_t mq_freeze_wq;	549	wait_queue_head_t mq_freeze_wq;
550	struct percpu_ref q_usage_counter;	550	struct percpu_ref q_usage_counter;
551	struct list_head all_q_node;
552		551
553	struct blk_mq_tag_set *tag_set;	552	struct blk_mq_tag_set *tag_set;
554	struct list_head tag_set_list;	553	struct list_head tag_set_list;

include/linux/bvec.h+18−6

 static inline struct bio_vec *bvec_init_iter_all(struct bvec_iter_all *iter_all)
 {
-	iter_all->bv.bv_page = NULL;
 	iter_all->done = 0;
+	iter_all->idx = 0;
 	return &iter_all->bv;
 }
-static inline void mp_bvec_next_segment(const struct bio_vec *bvec,
+static inline struct page *bvec_nth_page(struct page *page, int idx)
-					struct bvec_iter_all *iter_all)
+{
+	return idx == 0 ? page : nth_page(page, idx);
+}
+static inline void bvec_advance(const struct bio_vec *bvec,
+				struct bvec_iter_all *iter_all)
 {
 	struct bio_vec *bv = &iter_all->bv;
-	if (bv->bv_page) {
+	if (iter_all->done) {
 		bv->bv_page++;
 		bv->bv_offset = 0;
 	} else {
-		bv->bv_page = bvec->bv_page;
+		bv->bv_page = bvec_nth_page(bvec->bv_page, bvec->bv_offset /
-		bv->bv_offset = bvec->bv_offset;
+					    PAGE_SIZE);
+		bv->bv_offset = bvec->bv_offset & ~PAGE_MASK;
 	}
 	bv->bv_len = min_t(unsigned int, PAGE_SIZE - bv->bv_offset,
 			   bvec->bv_len - iter_all->done);
+	iter_all->done += bv->bv_len;
+	if (iter_all->done == bvec->bv_len) {
+		iter_all->idx++;
+		iter_all->done = 0;
+	}
 }
 /*

include/linux/efi.h+6−1

 			   struct screen_info *si, efi_guid_t *proto,
 			   unsigned long size);
-bool efi_runtime_disabled(void);
+#ifdef CONFIG_EFI
+extern bool efi_runtime_disabled(void);
+#else
+static inline bool efi_runtime_disabled(void) { return true; }
+#endif
 extern void efi_call_virt_check_flags(unsigned long flags, const char *call);
 extern unsigned long efi_call_virt_save_flags(void);

include/linux/elevator.h+1−0

@@ -31,6 +31,7 @@ struct elevator_mq_ops { · 30 unmodified lines
31	void (exit_sched)(struct elevator_queue );	31	void (exit_sched)(struct elevator_queue );
32	int (init_hctx)(struct blk_mq_hw_ctx , unsigned int);	32	int (init_hctx)(struct blk_mq_hw_ctx , unsigned int);
33	void (exit_hctx)(struct blk_mq_hw_ctx , unsigned int);	33	void (exit_hctx)(struct blk_mq_hw_ctx , unsigned int);
		34	void (depth_updated)(struct blk_mq_hw_ctx );
34		35
35	bool (allow_merge)(struct request_queue , struct request , struct bio );	36	bool (allow_merge)(struct request_queue , struct request , struct bio );
36	bool (bio_merge)(struct blk_mq_hw_ctx , struct bio *);	37	bool (bio_merge)(struct blk_mq_hw_ctx , struct bio *);

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/kernel.h+2−2

@@ -48,8 +48,8 @@ · 47 unmodified lines
48		48
49	#define u64_to_user_ptr(x) ( \	49	#define u64_to_user_ptr(x) ( \
50	{ \	50	{ \
51	typecheck(u64, x); \	51	typecheck(u64, (x)); \
52	(void __user *)(uintptr_t)x; \	52	(void __user *)(uintptr_t)(x); \
53	} \	53	} \
54	)	54	)
55		55

include/linux/kprobes.h+1−0

@@ -173,6 +173,7 @@ struct kretprobe_instance { · 172 unmodified lines
173	struct kretprobe *rp;	173	struct kretprobe *rp;
174	kprobe_opcode_t *ret_addr;	174	kprobe_opcode_t *ret_addr;
175	struct task_struct *task;	175	struct task_struct *task;
		176	void *fp;
176	char data[0];	177	char data[0];
177	};	178	};
178		179

include/linux/kvm_host.h+6−4

@@ -28,6 +28,7 @@ · 27 unmodified lines
28	#include <linux/irqbypass.h>	28	#include <linux/irqbypass.h>
29	#include <linux/swait.h>	29	#include <linux/swait.h>
30	#include <linux/refcount.h>	30	#include <linux/refcount.h>
		31	#include <linux/nospec.h>
31	#include <asm/signal.h>	32	#include <asm/signal.h>
32		33
33	#include <linux/kvm.h>	34	#include <linux/kvm.h>
@@ -513,10 +514,10 @@ static inline struct kvm_io_bus kvm_get_bus(struct kvm kvm, enum kvm_bus idx) · 479 unmodified lines
513		514
514	static inline struct kvm_vcpu kvm_get_vcpu(struct kvm kvm, int i)	515	static inline struct kvm_vcpu kvm_get_vcpu(struct kvm kvm, int i)
515	{	516	{
516	/* Pairs with smp_wmb() in kvm_vm_ioctl_create_vcpu, in case	517	int num_vcpus = atomic_read(&kvm->online_vcpus);
517	* the caller has read kvm->online_vcpus before (as is the case	518	i = array_index_nospec(i, num_vcpus);
518	* for kvm_for_each_vcpu, for example).	519
519	*/	520	/* Pairs with smp_wmb() in kvm_vm_ioctl_create_vcpu. */
520	smp_rmb();	521	smp_rmb();
521	return kvm->vcpus[i];	522	return kvm->vcpus[i];
522	}	523	}
@@ -600,6 +601,7 @@ void kvm_put_kvm(struct kvm *kvm); · 77 unmodified lines
600		601
601	static inline struct kvm_memslots __kvm_memslots(struct kvm kvm, int as_id)	602	static inline struct kvm_memslots __kvm_memslots(struct kvm kvm, int as_id)
602	{	603	{
		604	as_id = array_index_nospec(as_id, KVM_ADDRESS_SPACE_NUM);
603	return srcu_dereference_check(kvm->memslots[as_id], &kvm->srcu,	605	return srcu_dereference_check(kvm->memslots[as_id], &kvm->srcu,
604	lockdep_is_held(&kvm->slots_lock) \|\|	606	lockdep_is_held(&kvm->slots_lock) \|\|
605	!refcount_read(&kvm->users_count));	607	!refcount_read(&kvm->users_count));

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/mii.h+1−1

@@ -469,7 +469,7 @@ static inline u32 linkmode_adv_to_lcl_adv_t(unsigned long *advertising) · 468 unmodified lines
469	if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,	469	if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
470	advertising))	470	advertising))
471	lcl_adv \|= ADVERTISE_PAUSE_CAP;	471	lcl_adv \|= ADVERTISE_PAUSE_CAP;
472	if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,	472	if (linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
473	advertising))	473	advertising))
474	lcl_adv \|= ADVERTISE_PAUSE_ASYM;	474	lcl_adv \|= ADVERTISE_PAUSE_ASYM;
475		475

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

@@ -594,6 +594,8 @@ enum mlx5_pagefault_type_flags { · 593 unmodified lines
594	};	594	};
595		595
596	struct mlx5_td {	596	struct mlx5_td {
		597	/* protects tirs list changes while tirs refresh */
		598	struct mutex list_lock;
597	struct list_head tirs_list;	599	struct list_head tirs_list;
598	u32 tdn;	600	u32 tdn;
599	};	601	};

include/linux/mm.h+14−1

 }
 #endif /* CONFIG_DEV_PAGEMAP_OPS */
+/* 127: arbitrary random number, small enough to assemble well */
+#define page_ref_zero_or_close_to_overflow(page) \
+	((unsigned int) page_ref_count(page) + 127u <= 127u)
 static inline void get_page(struct page *page)
 {
 	page = compound_head(page);
 	 * Getting a normal page or the head of a compound page
 	 * requires to already have an elevated page->_refcount.
 	 */
-	VM_BUG_ON_PAGE(page_ref_count(page) <= 0, page);
+	VM_BUG_ON_PAGE(page_ref_zero_or_close_to_overflow(page), page);
+	page_ref_inc(page);
+}
+static inline __must_check bool try_get_page(struct page *page)
+{
+	page = compound_head(page);
+	if (WARN_ON_ONCE(page_ref_count(page) <= 0))
+		return false;
 	page_ref_inc(page);
+	return true;
 }
 static inline void put_page(struct page *page)

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/netdevice.h+3−0

  * @IFF_FAILOVER: device is a failover master device
  * @IFF_FAILOVER_SLAVE: device is lower dev of a failover master device
  * @IFF_L3MDEV_RX_HANDLER: only invoke the rx handler of L3 master device
+ * @IFF_LIVE_RENAME_OK: rename is allowed while device is up and running
  */
 enum netdev_priv_flags {
 	IFF_802_1Q_VLAN			= 1<<0,
 	IFF_FAILOVER			= 1<<27,
 	IFF_FAILOVER_SLAVE		= 1<<28,
 	IFF_L3MDEV_RX_HANDLER		= 1<<29,
+	IFF_LIVE_RENAME_OK		= 1<<30,
 };
 #define IFF_802_1Q_VLAN			IFF_802_1Q_VLAN
 #define IFF_FAILOVER			IFF_FAILOVER
 #define IFF_FAILOVER_SLAVE		IFF_FAILOVER_SLAVE
 #define IFF_L3MDEV_RX_HANDLER		IFF_L3MDEV_RX_HANDLER
+#define IFF_LIVE_RENAME_OK		IFF_LIVE_RENAME_OK
 /**
  *	struct net_device - The DEVICE structure.

include/linux/nvme.h+7−2

 	__le16			numdl;
 	__le16			numdu;
 	__u16			rsvd11;
-	__le32			lpol;
+	union {
-	__le32			lpou;
+		struct {
+			__le32 lpol;
+			__le32 lpou;
+		};
+		__le64 lpo;
+	};
 	__u32			rsvd14[2];
 };

include/linux/pipe_fs_i.h+6−4

 	/*
 	 * Get a reference to the pipe buffer.
 	 */
-	void (*get)(struct pipe_inode_info *, struct pipe_buffer *);
+	bool (*get)(struct pipe_inode_info *, struct pipe_buffer *);
 };
 /**
  * pipe_buf_get - get a reference to a pipe_buffer
  * @pipe:	the pipe that the buffer belongs to
  * @buf:	the buffer to get a reference to
+ *
+ * Return: %true if the reference was successfully obtained.
  */
-static inline void pipe_buf_get(struct pipe_inode_info *pipe,
+static inline __must_check bool pipe_buf_get(struct pipe_inode_info *pipe,
 				struct pipe_buffer *buf)
 {
-	buf->ops->get(pipe, buf);
+	return buf->ops->get(pipe, buf);
 }
 /**
 void free_pipe_info(struct pipe_inode_info *);
 /* Generic pipe buffer ops functions */
-void generic_pipe_buf_get(struct pipe_inode_info *, struct pipe_buffer *);
+bool generic_pipe_buf_get(struct pipe_inode_info *, struct pipe_buffer *);
 int generic_pipe_buf_confirm(struct pipe_inode_info *, struct pipe_buffer *);
 int generic_pipe_buf_steal(struct pipe_inode_info *, struct pipe_buffer *);
 void generic_pipe_buf_release(struct pipe_inode_info *, struct pipe_buffer *);

include/linux/platform_data/x86/clk-pmc-atom.h+3−0

  *
  * @base:	PMC clock register base offset
  * @clks:	pointer to set of registered clocks, typically 0..5
+ * @critical:	flag to indicate if firmware enabled pmc_plt_clks
+ *		should be marked as critial or not
  */
 struct pmc_clk_data {
 	void __iomem *base;
 	const struct pmc_clk *clks;
+	bool critical;
 };
 #endif /* __PLATFORM_DATA_X86_CLK_PMC_ATOM_H */

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/sched/mm.h+21−0

@@ -49,6 +49,27 @@ static inline void mmdrop(struct mm_struct *mm) · 48 unmodified lines
49	__mmdrop(mm);	49	__mmdrop(mm);
50	}	50	}
51		51
		52	/*
		53	* This has to be called after a get_task_mm()/mmget_not_zero()
		54	* followed by taking the mmap_sem for writing before modifying the
		55	* vmas or anything the coredump pretends not to change from under it.
		56	*
		57	* NOTE: find_extend_vma() called from GUP context is the only place
		58	* that can modify the "mm" (notably the vm_start/end) under mmap_sem
		59	* for reading and outside the context of the process, so it is also
		60	* the only case that holds the mmap_sem for reading that must call
		61	* this function. Generally if the mmap_sem is hold for reading
		62	* there's no need of this check after get_task_mm()/mmget_not_zero().
		63	*
		64	* This function can be obsoleted and the check can be removed, after
		65	* the coredump code will hold the mmap_sem for writing before
		66	* invoking the ->core_dump methods.
		67	*/
		68	static inline bool mmget_still_valid(struct mm_struct *mm)
		69	{
		70	return likely(!mm->core_state);
		71	}
		72
52	/**	73	/**
53	* mmget() - Pin the address space associated with a &struct mm_struct.	74	* mmget() - Pin the address space associated with a &struct mm_struct.
54	* @mm: The address space to pin.	75	* @mm: The address space to pin.

include/linux/shmem_fs.h+1−0

@@ -21,6 +21,7 @@ struct shmem_inode_info { · 20 unmodified lines
21	struct list_head swaplist; /* chain of maybes on swap */	21	struct list_head swaplist; /* chain of maybes on swap */
22	struct shared_policy policy; /* NUMA memory alloc policy */	22	struct shared_policy policy; /* NUMA memory alloc policy */
23	struct simple_xattrs xattrs; /* list of xattrs */	23	struct simple_xattrs xattrs; /* list of xattrs */
		24	atomic_t stop_eviction; /* hold when working on inode */
24	struct inode vfs_inode;	25	struct inode vfs_inode;
25	};	26	};
26		27

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/linux/sunrpc/sched.h+0−8

@@ -304,12 +304,4 @@ rpc_clnt_swap_deactivate(struct rpc_clnt *clnt) · 303 unmodified lines
304	}	304	}
305	#endif /* CONFIG_SUNRPC_SWAP */	305	#endif /* CONFIG_SUNRPC_SWAP */
306		306
307	static inline bool
308	rpc_task_need_resched(const struct rpc_task *task)
309	{
310	if (RPC_IS_QUEUED(task) \|\| task->tk_callback)
311	return true;
312	return false;
313	}
314
315	#endif /* _LINUX_SUNRPC_SCHED_H_ */	307	#endif /* _LINUX_SUNRPC_SCHED_H_ */

include/linux/virtio_ring.h+1−1

@@ -63,7 +63,7 @@ struct virtqueue; · 62 unmodified lines
63	/*	63	/*
64	* Creates a virtqueue and allocates the descriptor ring. If	64	* Creates a virtqueue and allocates the descriptor ring. If
65	* may_reduce_num is set, then this may allocate a smaller ring than	65	* may_reduce_num is set, then this may allocate a smaller ring than
66	* expected. The caller should query virtqueue_get_ring_size to learn	66	* expected. The caller should query virtqueue_get_vring_size to learn
67	* the actual size of the ring.	67	* the actual size of the ring.
68	*/	68	*/
69	struct virtqueue *vring_create_virtqueue(unsigned int index,	69	struct virtqueue *vring_create_virtqueue(unsigned int index,

include/net/af_rxrpc.h+3−1

 			       rxrpc_user_attach_call_t, unsigned long, gfp_t,
 			       unsigned int);
 void rxrpc_kernel_set_tx_length(struct socket *, struct rxrpc_call *, s64);
-u32 rxrpc_kernel_check_life(const struct socket *, const struct rxrpc_call *);
+bool rxrpc_kernel_check_life(const struct socket *, const struct rxrpc_call *,
+			     u32 *);
 void rxrpc_kernel_probe_life(struct socket *, struct rxrpc_call *);
 u32 rxrpc_kernel_get_epoch(struct socket *, struct rxrpc_call *);
 bool rxrpc_kernel_get_reply_time(struct socket *, struct rxrpc_call *,
 				 ktime_t *);
+bool rxrpc_kernel_call_is_complete(struct rxrpc_call *);
 #endif /* _NET_RXRPC_H */

include/net/cfg80211.h+5−0

 #define wiphy_info(wiphy, format, args...)			\
 	dev_info(&(wiphy)->dev, format, ##args)
+#define wiphy_err_ratelimited(wiphy, format, args...)		\
+	dev_err_ratelimited(&(wiphy)->dev, format, ##args)
+#define wiphy_warn_ratelimited(wiphy, format, args...)		\
+	dev_warn_ratelimited(&(wiphy)->dev, format, ##args)
 #define wiphy_debug(wiphy, format, args...)			\
 	wiphy_printk(KERN_DEBUG, wiphy, format, ##args)

include/net/ip.h+1−1

@@ -677,7 +677,7 @@ int ip_options_get_from_user(struct net net, struct ip_options_rcu *optp, · 676 unmodified lines
677	unsigned char __user *data, int optlen);	677	unsigned char __user *data, int optlen);
678	void ip_options_undo(struct ip_options *opt);	678	void ip_options_undo(struct ip_options *opt);
679	void ip_forward_options(struct sk_buff *skb);	679	void ip_forward_options(struct sk_buff *skb);
680	int ip_options_rcv_srr(struct sk_buff *skb);	680	int ip_options_rcv_srr(struct sk_buff skb, struct net_device dev);
681		681
682	/*	682	/*
683	* Functions provided by ip_sockglue.c	683	* Functions provided by ip_sockglue.c

include/net/mac80211.h+34−29

@@ -6231,8 +6231,6 @@ struct sk_buff ieee80211_tx_dequeue(struct ieee80211_hw hw, · 6230 unmodified lines
6231	* @hw: pointer as obtained from ieee80211_alloc_hw()	6231	* @hw: pointer as obtained from ieee80211_alloc_hw()
6232	* @ac: AC number to return packets from.	6232	* @ac: AC number to return packets from.
6233	*	6233	*
6234	* Should only be called between calls to ieee80211_txq_schedule_start()
6235	* and ieee80211_txq_schedule_end().
6236	* Returns the next txq if successful, %NULL if no queue is eligible. If a txq	6234	* Returns the next txq if successful, %NULL if no queue is eligible. If a txq
6237	* is returned, it should be returned with ieee80211_return_txq() after the	6235	* is returned, it should be returned with ieee80211_return_txq() after the
6238	* driver has finished scheduling it.	6236	* driver has finished scheduling it.
@@ -6240,51 +6238,58 @@ struct sk_buff ieee80211_tx_dequeue(struct ieee80211_hw hw, · 1 unmodified line
6240	struct ieee80211_txq ieee80211_next_txq(struct ieee80211_hw hw, u8 ac);	6238	struct ieee80211_txq ieee80211_next_txq(struct ieee80211_hw hw, u8 ac);
6241		6239
6242	/**	6240	/**
6243	* ieee80211_return_txq - return a TXQ previously acquired by ieee80211_next_txq()	6241	* ieee80211_txq_schedule_start - start new scheduling round for TXQs
6244	*
6245	* @hw: pointer as obtained from ieee80211_alloc_hw()
6246	* @txq: pointer obtained from station or virtual interface
6247	*
6248	* Should only be called between calls to ieee80211_txq_schedule_start()
6249	* and ieee80211_txq_schedule_end().
6250	*/
6251	void ieee80211_return_txq(struct ieee80211_hw hw, struct ieee80211_txq txq);
6252
6253	/**
6254	* ieee80211_txq_schedule_start - acquire locks for safe scheduling of an AC
6255	*	6242	*
6256	* @hw: pointer as obtained from ieee80211_alloc_hw()	6243	* @hw: pointer as obtained from ieee80211_alloc_hw()
6257	* @ac: AC number to acquire locks for	6244	* @ac: AC number to acquire locks for
6258	*	6245	*
6259	* Acquire locks needed to schedule TXQs from the given AC. Should be called	6246	* Should be called before ieee80211_next_txq() or ieee80211_return_txq().
6260	* before ieee80211_next_txq() or ieee80211_return_txq().	6247	* The driver must not call multiple TXQ scheduling rounds concurrently.
6261	*/	6248	*/
6262	void ieee80211_txq_schedule_start(struct ieee80211_hw *hw, u8 ac)	6249	void ieee80211_txq_schedule_start(struct ieee80211_hw *hw, u8 ac);
6263	__acquires(txq_lock);	6250
		6251	/* (deprecated) */
		6252	static inline void ieee80211_txq_schedule_end(struct ieee80211_hw *hw, u8 ac)
		6253	{
		6254	}
		6255
		6256	void __ieee80211_schedule_txq(struct ieee80211_hw *hw,
		6257	struct ieee80211_txq *txq, bool force);
6264		6258
6265	/**	6259	/**
6266	* ieee80211_txq_schedule_end - release locks for safe scheduling of an AC	6260	* ieee80211_schedule_txq - schedule a TXQ for transmission
6267	*	6261	*
6268	* @hw: pointer as obtained from ieee80211_alloc_hw()	6262	* @hw: pointer as obtained from ieee80211_alloc_hw()
6269	* @ac: AC number to acquire locks for	6263	* @txq: pointer obtained from station or virtual interface
6270	*	6264	*
6271	* Release locks previously acquired by ieee80211_txq_schedule_end().	6265	* Schedules a TXQ for transmission if it is not already scheduled,
		6266	* even if mac80211 does not have any packets buffered.
		6267	*
		6268	* The driver may call this function if it has buffered packets for
		6269	* this TXQ internally.
6272	*/	6270	*/
6273	void ieee80211_txq_schedule_end(struct ieee80211_hw *hw, u8 ac)	6271	static inline void
6274	__releases(txq_lock);	6272	ieee80211_schedule_txq(struct ieee80211_hw hw, struct ieee80211_txq txq)
		6273	{
		6274	__ieee80211_schedule_txq(hw, txq, true);
		6275	}
6275		6276
6276	/**	6277	/**
6277	* ieee80211_schedule_txq - schedule a TXQ for transmission	6278	* ieee80211_return_txq - return a TXQ previously acquired by ieee80211_next_txq()
6278	*	6279	*
6279	* @hw: pointer as obtained from ieee80211_alloc_hw()	6280	* @hw: pointer as obtained from ieee80211_alloc_hw()
6280	* @txq: pointer obtained from station or virtual interface	6281	* @txq: pointer obtained from station or virtual interface
		6282	* @force: schedule txq even if mac80211 does not have any buffered packets.
6281	*	6283	*
6282	* Schedules a TXQ for transmission if it is not already scheduled. Takes a	6284	* The driver may set force=true if it has buffered packets for this TXQ
6283	* lock, which means it must not be called between	6285	* internally.
6284	* ieee80211_txq_schedule_start() and ieee80211_txq_schedule_end()
6285	*/	6286	*/
6286	void ieee80211_schedule_txq(struct ieee80211_hw hw, struct ieee80211_txq txq)	6287	static inline void
6287	__acquires(txq_lock) __releases(txq_lock);	6288	ieee80211_return_txq(struct ieee80211_hw hw, struct ieee80211_txq txq,
		6289	bool force)
		6290	{
		6291	__ieee80211_schedule_txq(hw, txq, force);
		6292	}
6288		6293
6289	/**	6294	/**
6290	* ieee80211_txq_may_transmit - check whether TXQ is allowed to transmit	6295	* ieee80211_txq_may_transmit - check whether TXQ is allowed to transmit

include/net/net_namespace.h+1−0

@@ -59,6 +59,7 @@ struct net { · 58 unmodified lines
59	*/	59	*/
60	spinlock_t rules_mod_lock;	60	spinlock_t rules_mod_lock;
61		61
		62	u32 hash_mix;
62	atomic64_t cookie_gen;	63	atomic64_t cookie_gen;
63		64
64	struct list_head list; /* list of network namespaces */	65	struct list_head list; /* list of network namespaces */

include/net/netns/hash.h+2−8

 #ifndef __NET_NS_HASH_H__
 #define __NET_NS_HASH_H__
-#include <asm/cache.h>
+#include <net/net_namespace.h>
-struct net;
 static inline u32 net_hash_mix(const struct net *net)
 {
-#ifdef CONFIG_NET_NS
+	return net->hash_mix;
-	return (u32)(((unsigned long)net) >> ilog2(sizeof(*net)));
-#else
-	return 0;
-#endif
 }
 #endif

include/net/netrom.h+1−1

@@ -266,7 +266,7 @@ void nr_stop_idletimer(struct sock *); · 265 unmodified lines
266	int nr_t1timer_running(struct sock *);	266	int nr_t1timer_running(struct sock *);
267		267
268	/* sysctl_net_netrom.c */	268	/* sysctl_net_netrom.c */
269	void nr_register_sysctl(void);	269	int nr_register_sysctl(void);
270	void nr_unregister_sysctl(void);	270	void nr_unregister_sysctl(void);
271		271
272	#endif	272	#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/net/sch_generic.h+37−7

@@ -923,6 +923,41 @@ static inline void qdisc_qstats_overlimit(struct Qdisc *sch) · 922 unmodified lines
923	sch->qstats.overlimits++;	923	sch->qstats.overlimits++;
924	}	924	}
925		925
		926	static inline int qdisc_qstats_copy(struct gnet_dump d, struct Qdisc sch)
		927	{
		928	__u32 qlen = qdisc_qlen_sum(sch);
		929
		930	return gnet_stats_copy_queue(d, sch->cpu_qstats, &sch->qstats, qlen);
		931	}
		932
		933	static inline void qdisc_qstats_qlen_backlog(struct Qdisc sch, __u32 qlen,
		934	__u32 *backlog)
		935	{
		936	struct gnet_stats_queue qstats = { 0 };
		937	__u32 len = qdisc_qlen_sum(sch);
		938
		939	__gnet_stats_copy_queue(&qstats, sch->cpu_qstats, &sch->qstats, len);
		940	*qlen = qstats.qlen;
		941	*backlog = qstats.backlog;
		942	}
		943
		944	static inline void qdisc_tree_flush_backlog(struct Qdisc *sch)
		945	{
		946	__u32 qlen, backlog;
		947
		948	qdisc_qstats_qlen_backlog(sch, &qlen, &backlog);
		949	qdisc_tree_reduce_backlog(sch, qlen, backlog);
		950	}
		951
		952	static inline void qdisc_purge_queue(struct Qdisc *sch)
		953	{
		954	__u32 qlen, backlog;
		955
		956	qdisc_qstats_qlen_backlog(sch, &qlen, &backlog);
		957	qdisc_reset(sch);
		958	qdisc_tree_reduce_backlog(sch, qlen, backlog);
		959	}
		960
926	static inline void qdisc_skb_head_init(struct qdisc_skb_head *qh)	961	static inline void qdisc_skb_head_init(struct qdisc_skb_head *qh)
927	{	962	{
928	qh->head = NULL;	963	qh->head = NULL;
@@ -1106,13 +1141,8 @@ static inline struct Qdisc qdisc_replace(struct Qdisc sch, struct Qdisc *new, · 177 unmodified lines
1106	sch_tree_lock(sch);	1141	sch_tree_lock(sch);
1107	old = *pold;	1142	old = *pold;
1108	*pold = new;	1143	*pold = new;
1109	if (old != NULL) {	1144	if (old != NULL)
1110	unsigned int qlen = old->q.qlen;	1145	qdisc_tree_flush_backlog(old);
1111	unsigned int backlog = old->qstats.backlog;
1112
1113	qdisc_reset(old);
1114	qdisc_tree_reduce_backlog(old, qlen, backlog);
1115	}
1116	sch_tree_unlock(sch);	1146	sch_tree_unlock(sch);
1117		1147
1118	return old;	1148	return old;

include/net/sock.h+0−6

  * @p:              poll_table
  *
  * See the comments in the wq_has_sleeper function.
- *
- * Do not derive sock from filp->private_data here. An SMC socket establishes
- * an internal TCP socket that is used in the fallback case. All socket
- * operations on the SMC socket are then forwarded to the TCP socket. In case of
- * poll, the filp->private_data pointer references the SMC socket because the
- * TCP socket has no file assigned.
  */
 static inline void sock_poll_wait(struct file *filp, struct socket *sock,
 				  poll_table *p)

include/net/tls.h+3−1

 int tls_device_sendpage(struct sock *sk, struct page *page,
 			int offset, size_t size, int flags);
 void tls_device_sk_destruct(struct sock *sk);
+void tls_device_free_resources_tx(struct sock *sk);
 void tls_device_init(void);
 void tls_device_cleanup(void);
 int tls_tx_records(struct sock *sk, int flags);
 		int flags);
 int tls_push_partial_record(struct sock *sk, struct tls_context *ctx,
 			    int flags);
+bool tls_free_partial_record(struct sock *sk, struct tls_context *ctx);
 static inline struct tls_msg *tls_msg(struct sk_buff *skb)
 {
 static inline bool tls_is_sk_tx_device_offloaded(struct sock *sk)
 {
 #ifdef CONFIG_SOCK_VALIDATE_XMIT
-	return sk_fullsock(sk) &
+	return sk_fullsock(sk) &&
 	       (smp_load_acquire(&sk->sk_validate_xmit_skb) ==
 	       &tls_validate_xmit_skb);
 #else

include/sound/soc.h+9−2

 	int probe_order;
 	int remove_order;
-	/* signal if the module handling the component cannot be removed */
+	/*
-	unsigned int ignore_module_refcount:1;
+	 * signal if the module handling the component should not be removed
+	 * if a pcm is open. Setting this would prevent the module
+	 * refcount being incremented in probe() but allow it be incremented
+	 * when a pcm is opened and decremented when it is closed.
+	 */
+	unsigned int module_get_upon_open:1;
 	/* bits */
 	unsigned int idle_bias_on:1;
 	struct mutex mutex;
 	struct mutex dapm_mutex;
+	spinlock_t dpcm_lock;
 	bool instantiated;
 	bool topology_shortname_created;

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

@@ -1591,7 +1591,7 @@ enum ethtool_link_mode_bit_indices { · 1590 unmodified lines
1591		1591
1592	static inline int ethtool_validate_speed(__u32 speed)	1592	static inline int ethtool_validate_speed(__u32 speed)
1593	{	1593	{
1594	return speed <= INT_MAX \|\| speed == SPEED_UNKNOWN;	1594	return speed <= INT_MAX \|\| speed == (__u32)SPEED_UNKNOWN;
1595	}	1595	}
1596		1596
1597	/* Duplex, half or full. */	1597	/* Duplex, half or full. */

include/uapi/linux/input-event-codes.h+4−2

 #define KEY_TITLE		0x171
 #define KEY_SUBTITLE		0x172
 #define KEY_ANGLE		0x173
-#define KEY_ZOOM		0x174
+#define KEY_FULL_SCREEN		0x174	/* AC View Toggle */
+#define KEY_ZOOM		KEY_FULL_SCREEN
 #define KEY_MODE		0x175
 #define KEY_KEYBOARD		0x176
-#define KEY_SCREEN		0x177
+#define KEY_ASPECT_RATIO	0x177	/* HUTRR37: Aspect */
+#define KEY_SCREEN		KEY_ASPECT_RATIO
 #define KEY_PC			0x178	/* Media Select Computer */
 #define KEY_TV			0x179	/* Media Select TV */
 #define KEY_TV2			0x17a	/* Media Select Cable */

include/uapi/sound/asound.h+1−0

@@ -32,6 +32,7 @@ · 31 unmodified lines
32		32
33	#ifndef __KERNEL__	33	#ifndef __KERNEL__
34	#include <stdlib.h>	34	#include <stdlib.h>
		35	#include <time.h>
35	#endif	36	#endif
36		37
37	/*	38	/*

init/main.c+2−2

 	page_alloc_init();
 	pr_notice("Kernel command line: %s\n", boot_command_line);
+	/* parameters may set static keys */
+	jump_label_init();
 	parse_early_param();
 	after_dashes = parse_args("Booting kernel",
 				  static_command_line, __start___param,
 		parse_args("Setting init args", after_dashes, NULL, 0, -1, -1,
 			   NULL, set_init_arg);
-	jump_label_init();
 	/*
 	 * These use large bootmem allocations and must precede
 	 * kmem_cache_init()

kernel/bpf/cpumap.c+10−3

 static struct sk_buff *cpu_map_build_skb(struct bpf_cpu_map_entry *rcpu,
 					 struct xdp_frame *xdpf)
 {
+	unsigned int hard_start_headroom;
 	unsigned int frame_size;
 	void *pkt_data_start;
 	struct sk_buff *skb;
+	/* Part of headroom was reserved to xdpf */
+	hard_start_headroom = sizeof(struct xdp_frame) +  xdpf->headroom;
 	/* build_skb need to place skb_shared_info after SKB end, and
 	 * also want to know the memory "truesize".  Thus, need to
 	 * know the memory frame size backing xdp_buff.
 	 * is not at a fixed memory location, with mixed length
 	 * packets, which is bad for cache-line hotness.
 	 */
-	frame_size = SKB_DATA_ALIGN(xdpf->len + xdpf->headroom) +
+	frame_size = SKB_DATA_ALIGN(xdpf->len + hard_start_headroom) +
 		SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
-	pkt_data_start = xdpf->data - xdpf->headroom;
+	pkt_data_start = xdpf->data - hard_start_headroom;
 	skb = build_skb(pkt_data_start, frame_size);
 	if (!skb)
 		return NULL;
-	skb_reserve(skb, xdpf->headroom);
+	skb_reserve(skb, hard_start_headroom);
 	__skb_put(skb, xdpf->len);
 	if (xdpf->metasize)
 		skb_metadata_set(skb, xdpf->metasize);
 	 * - RX ring dev queue index	(skb_record_rx_queue)
 	 */
+	/* Allow SKB to reuse area used by xdp_frame */
+	xdp_scrub_frame(xdpf);
 	return skb;
 }

kernel/bpf/inode.c+18−14

 }
 EXPORT_SYMBOL(bpf_prog_get_type_path);
-static void bpf_evict_inode(struct inode *inode)
-{
-	enum bpf_type type;
-	truncate_inode_pages_final(&inode->i_data);
-	clear_inode(inode);
-	if (S_ISLNK(inode->i_mode))
-		kfree(inode->i_link);
-	if (!bpf_inode_type(inode, &type))
-		bpf_any_put(inode->i_private, type);
-}
 /*
  * Display the mount options in /proc/mounts.
  */
 	return 0;
 }
+static void bpf_destroy_inode_deferred(struct rcu_head *head)
+{
+	struct inode *inode = container_of(head, struct inode, i_rcu);
+	enum bpf_type type;
+	if (S_ISLNK(inode->i_mode))
+		kfree(inode->i_link);
+	if (!bpf_inode_type(inode, &type))
+		bpf_any_put(inode->i_private, type);
+	free_inode_nonrcu(inode);
+}
+static void bpf_destroy_inode(struct inode *inode)
+{
+	call_rcu(&inode->i_rcu, bpf_destroy_inode_deferred);
+}
 static const struct super_operations bpf_super_ops = {
 	.statfs		= simple_statfs,
 	.drop_inode	= generic_delete_inode,
 	.show_options	= bpf_show_options,
-	.evict_inode	= bpf_evict_inode,
+	.destroy_inode	= bpf_destroy_inode,
 };
 enum {

kernel/bpf/verifier.c+3−2

 		}
 		frame++;
 		if (frame >= MAX_CALL_FRAMES) {
-			WARN_ONCE(1, "verifier bug. Call stack is too deep\n");
+			verbose(env, "the call stack of %d frames is too deep !\n",
-			return -EFAULT;
+				frame);
+			return -E2BIG;
 		}
 		goto process_func;
 	}

kernel/dma/debug.c+1−1

@@ -706,7 +706,7 @@ static struct dma_debug_entry *dma_entry_alloc(void) · 705 unmodified lines
706	#ifdef CONFIG_STACKTRACE	706	#ifdef CONFIG_STACKTRACE
707	entry->stacktrace.max_entries = DMA_DEBUG_STACKTRACE_ENTRIES;	707	entry->stacktrace.max_entries = DMA_DEBUG_STACKTRACE_ENTRIES;
708	entry->stacktrace.entries = entry->st_entries;	708	entry->stacktrace.entries = entry->st_entries;
709	entry->stacktrace.skip = 2;	709	entry->stacktrace.skip = 1;
710	save_stack_trace(&entry->stacktrace);	710	save_stack_trace(&entry->stacktrace);
711	#endif	711	#endif
712		712

kernel/events/core.c+64−25

@@ -2009,8 +2009,8 @@ event_sched_out(struct perf_event *event, · 2008 unmodified lines
2009	event->pmu->del(event, 0);	2009	event->pmu->del(event, 0);
2010	event->oncpu = -1;	2010	event->oncpu = -1;
2011		2011
2012	if (event->pending_disable) {	2012	if (READ_ONCE(event->pending_disable) >= 0) {
2013	event->pending_disable = 0;	2013	WRITE_ONCE(event->pending_disable, -1);
2014	state = PERF_EVENT_STATE_OFF;	2014	state = PERF_EVENT_STATE_OFF;
2015	}	2015	}
2016	perf_event_set_state(event, state);	2016	perf_event_set_state(event, state);
@@ -2198,7 +2198,8 @@ EXPORT_SYMBOL_GPL(perf_event_disable); · 181 unmodified lines
2198		2198
2199	void perf_event_disable_inatomic(struct perf_event *event)	2199	void perf_event_disable_inatomic(struct perf_event *event)
2200	{	2200	{
2201	event->pending_disable = 1;	2201	WRITE_ONCE(event->pending_disable, smp_processor_id());
		2202	/* can fail, see perf_pending_event_disable() */
2202	irq_work_queue(&event->pending);	2203	irq_work_queue(&event->pending);
2203	}	2204	}
2204		2205
@@ -5810,10 +5811,45 @@ void perf_event_wakeup(struct perf_event *event) · 3605 unmodified lines
5810	}	5811	}
5811	}	5812	}
5812		5813
		5814	static void perf_pending_event_disable(struct perf_event *event)
		5815	{
		5816	int cpu = READ_ONCE(event->pending_disable);
		5817
		5818	if (cpu < 0)
		5819	return;
		5820
		5821	if (cpu == smp_processor_id()) {
		5822	WRITE_ONCE(event->pending_disable, -1);
		5823	perf_event_disable_local(event);
		5824	return;
		5825	}
		5826
		5827	/*
		5828	* CPU-A CPU-B
		5829	*
		5830	* perf_event_disable_inatomic()
		5831	* @pending_disable = CPU-A;
		5832	* irq_work_queue();
		5833	*
		5834	* sched-out
		5835	* @pending_disable = -1;
		5836	*
		5837	* sched-in
		5838	* perf_event_disable_inatomic()
		5839	* @pending_disable = CPU-B;
		5840	* irq_work_queue(); // FAILS
		5841	*
		5842	* irq_work_run()
		5843	* perf_pending_event()
		5844	*
		5845	* But the event runs on CPU-B and wants disabling there.
		5846	*/
		5847	irq_work_queue_on(&event->pending, cpu);
		5848	}
		5849
5813	static void perf_pending_event(struct irq_work *entry)	5850	static void perf_pending_event(struct irq_work *entry)
5814	{	5851	{
5815	struct perf_event *event = container_of(entry,	5852	struct perf_event *event = container_of(entry, struct perf_event, pending);
5816	struct perf_event, pending);
5817	int rctx;	5853	int rctx;
5818		5854
5819	rctx = perf_swevent_get_recursion_context();	5855	rctx = perf_swevent_get_recursion_context();
@@ -5822,10 +5858,7 @@ static void perf_pending_event(struct irq_work *entry) · 2 unmodified lines
5822	* and we won't recurse 'further'.	5858	* and we won't recurse 'further'.
5823	*/	5859	*/
5824		5860
5825	if (event->pending_disable) {	5861	perf_pending_event_disable(event);
5826	event->pending_disable = 0;
5827	perf_event_disable_local(event);
5828	}
5829		5862
5830	if (event->pending_wakeup) {	5863	if (event->pending_wakeup) {
5831	event->pending_wakeup = 0;	5864	event->pending_wakeup = 0;
@@ -9044,26 +9077,29 @@ static void perf_event_addr_filters_apply(struct perf_event *event) · 3212 unmodified lines
9044	if (task == TASK_TOMBSTONE)	9077	if (task == TASK_TOMBSTONE)
9045	return;	9078	return;
9046		9079
9047	if (!ifh->nr_file_filters)	9080	if (ifh->nr_file_filters) {
9048	return;	9081	mm = get_task_mm(event->ctx->task);
9049		9082	if (!mm)
9050	mm = get_task_mm(event->ctx->task);	9083	goto restart;
9051	if (!mm)
9052	goto restart;
9053		9084
9054	down_read(&mm->mmap_sem);	9085	down_read(&mm->mmap_sem);
		9086	}
9055		9087
9056	raw_spin_lock_irqsave(&ifh->lock, flags);	9088	raw_spin_lock_irqsave(&ifh->lock, flags);
9057	list_for_each_entry(filter, &ifh->list, entry) {	9089	list_for_each_entry(filter, &ifh->list, entry) {
9058	event->addr_filter_ranges[count].start = 0;	9090	if (filter->path.dentry) {
9059	event->addr_filter_ranges[count].size = 0;	9091	/*
		9092	* Adjust base offset if the filter is associated to a
		9093	* binary that needs to be mapped:
		9094	*/
		9095	event->addr_filter_ranges[count].start = 0;
		9096	event->addr_filter_ranges[count].size = 0;
9060		9097
9061	/*
9062	* Adjust base offset if the filter is associated to a binary
9063	* that needs to be mapped:
9064	*/
9065	if (filter->path.dentry)
9066	perf_addr_filter_apply(filter, mm, &event->addr_filter_ranges[count]);	9098	perf_addr_filter_apply(filter, mm, &event->addr_filter_ranges[count]);
		9099	} else {
		9100	event->addr_filter_ranges[count].start = filter->offset;
		9101	event->addr_filter_ranges[count].size = filter->size;
		9102	}
9067		9103
9068	count++;	9104	count++;
9069	}	9105	}
@@ -9071,9 +9107,11 @@ static void perf_event_addr_filters_apply(struct perf_event *event) · 1 unmodified line
9071	event->addr_filters_gen++;	9107	event->addr_filters_gen++;
9072	raw_spin_unlock_irqrestore(&ifh->lock, flags);	9108	raw_spin_unlock_irqrestore(&ifh->lock, flags);
9073		9109
9074	up_read(&mm->mmap_sem);	9110	if (ifh->nr_file_filters) {
		9111	up_read(&mm->mmap_sem);
9075		9112
9076	mmput(mm);	9113	mmput(mm);
		9114	}
9077		9115
9078	restart:	9116	restart:
9079	perf_event_stop(event, 1);	9117	perf_event_stop(event, 1);
@@ -10236,6 +10274,7 @@ perf_event_alloc(struct perf_event_attr *attr, int cpu, · 1156 unmodified lines
10236		10274
10237		10275
10238	init_waitqueue_head(&event->waitq);	10276	init_waitqueue_head(&event->waitq);
		10277	event->pending_disable = -1;
10239	init_irq_work(&event->pending, perf_pending_event);	10278	init_irq_work(&event->pending, perf_pending_event);
10240		10279
10241	mutex_init(&event->mmap_mutex);	10280	mutex_init(&event->mmap_mutex);

kernel/events/ring_buffer.c+17−20

@@ -392,7 +392,7 @@ void perf_aux_output_begin(struct perf_output_handle handle, · 391 unmodified lines
392	* store that will be enabled on successful return	392	* store that will be enabled on successful return
393	*/	393	*/
394	if (!handle->size) { /* A, matches D */	394	if (!handle->size) { /* A, matches D */
395	event->pending_disable = 1;	395	event->pending_disable = smp_processor_id();
396	perf_output_wakeup(handle);	396	perf_output_wakeup(handle);
397	local_set(&rb->aux_nest, 0);	397	local_set(&rb->aux_nest, 0);
398	goto err_put;	398	goto err_put;
@@ -455,24 +455,21 @@ void perf_aux_output_end(struct perf_output_handle *handle, unsigned long size) · 56 unmodified lines
455	rb->aux_head += size;	455	rb->aux_head += size;
456	}	456	}
457		457
458	if (size \|\| handle->aux_flags) {	458	/*
459	/*	459	* Only send RECORD_AUX if we have something useful to communicate
460	* Only send RECORD_AUX if we have something useful to communicate	460	*
461	*	461	* Note: the OVERWRITE records by themselves are not considered
462	* Note: the OVERWRITE records by themselves are not considered	462	* useful, as they don't communicate any new information,
463	* useful, as they don't communicate any new information,	463	* aside from the short-lived offset, that becomes history at
464	* aside from the short-lived offset, that becomes history at	464	* the next event sched-in and therefore isn't useful.
465	* the next event sched-in and therefore isn't useful.	465	* The userspace that needs to copy out AUX data in overwrite
466	* The userspace that needs to copy out AUX data in overwrite	466	* mode should know to use user_page::aux_head for the actual
467	* mode should know to use user_page::aux_head for the actual	467	* offset. So, from now on we don't output AUX records that
468	* offset. So, from now on we don't output AUX records that	468	* have only OVERWRITE flag set.
469	* have only OVERWRITE flag set.	469	*/
470	*/	470	if (size \|\| (handle->aux_flags & ~(u64)PERF_AUX_FLAG_OVERWRITE))
471		471	perf_event_aux_event(handle->event, aux_head, size,
472	if (handle->aux_flags & ~(u64)PERF_AUX_FLAG_OVERWRITE)	472	handle->aux_flags);
473	perf_event_aux_event(handle->event, aux_head, size,
474	handle->aux_flags);
475	}
476		473
477	rb->user_page->aux_head = rb->aux_head;	474	rb->user_page->aux_head = rb->aux_head;
478	if (rb_need_aux_wakeup(rb))	475	if (rb_need_aux_wakeup(rb))
@@ -480,7 +477,7 @@ void perf_aux_output_end(struct perf_output_handle *handle, unsigned long size) · 1 unmodified line
480		477
481	if (wakeup) {	478	if (wakeup) {
482	if (handle->aux_flags & PERF_AUX_FLAG_TRUNCATED)	479	if (handle->aux_flags & PERF_AUX_FLAG_TRUNCATED)
483	handle->event->pending_disable = 1;	480	handle->event->pending_disable = smp_processor_id();
484	perf_output_wakeup(handle);	481	perf_output_wakeup(handle);
485	}	482	}
486		483

kernel/irq/chip.c+4−0

@@ -1449,6 +1449,10 @@ int irq_chip_set_vcpu_affinity_parent(struct irq_data data, void vcpu_info) · 1448 unmodified lines
1449	int irq_chip_set_wake_parent(struct irq_data *data, unsigned int on)	1449	int irq_chip_set_wake_parent(struct irq_data *data, unsigned int on)
1450	{	1450	{
1451	data = data->parent_data;	1451	data = data->parent_data;
		1452
		1453	if (data->chip->flags & IRQCHIP_SKIP_SET_WAKE)
		1454	return 0;
		1455
1452	if (data->chip->irq_set_wake)	1456	if (data->chip->irq_set_wake)
1453	return data->chip->irq_set_wake(data, on);	1457	return data->chip->irq_set_wake(data, on);
1454		1458

kernel/irq/irqdesc.c+1−0

@@ -558,6 +558,7 @@ int __init early_irq_init(void) · 557 unmodified lines
558	alloc_masks(&desc[i], node);	558	alloc_masks(&desc[i], node);
559	raw_spin_lock_init(&desc[i].lock);	559	raw_spin_lock_init(&desc[i].lock);
560	lockdep_set_class(&desc[i].lock, &irq_desc_lock_class);	560	lockdep_set_class(&desc[i].lock, &irq_desc_lock_class);
		561	mutex_init(&desc[i].request_mutex);
561	desc_set_defaults(i, &desc[i], node, NULL, NULL);	562	desc_set_defaults(i, &desc[i], node, NULL, NULL);
562	}	563	}
563	return arch_early_irq_init();	564	return arch_early_irq_init();

kernel/kprobes.c+2−4

 static int reuse_unused_kprobe(struct kprobe *ap)
 {
 	struct optimized_kprobe *op;
-	int ret;
 	/*
 	 * Unused kprobe MUST be on the way of delayed unoptimizing (means
 	/* Enable the probe again */
 	ap->flags &= ~KPROBE_FLAG_DISABLED;
 	/* Optimize it again (remove from op->list) */
-	ret = kprobe_optready(ap);
+	if (!kprobe_optready(ap))
-	if (ret)
+		return -EINVAL;
-		return ret;
 	optimize_kprobe(ap);
 	return 0;

kernel/locking/lockdep.c+8−12

@@ -4689,8 +4689,8 @@ static void free_zapped_rcu(struct rcu_head *ch) · 4688 unmodified lines
4689	return;	4689	return;
4690		4690
4691	raw_local_irq_save(flags);	4691	raw_local_irq_save(flags);
4692	if (!graph_lock())	4692	arch_spin_lock(&lockdep_lock);
4693	goto out_irq;	4693	current->lockdep_recursion = 1;
4694		4694
4695	/* closed head */	4695	/* closed head */
4696	pf = delayed_free.pf + (delayed_free.index ^ 1);	4696	pf = delayed_free.pf + (delayed_free.index ^ 1);
@@ -4702,8 +4702,8 @@ static void free_zapped_rcu(struct rcu_head *ch) · 5 unmodified lines
4702	*/	4702	*/
4703	call_rcu_zapped(delayed_free.pf + delayed_free.index);	4703	call_rcu_zapped(delayed_free.pf + delayed_free.index);
4704		4704
4705	graph_unlock();	4705	current->lockdep_recursion = 0;
4706	out_irq:	4706	arch_spin_unlock(&lockdep_lock);
4707	raw_local_irq_restore(flags);	4707	raw_local_irq_restore(flags);
4708	}	4708	}
4709		4709
@@ -4744,21 +4744,17 @@ static void lockdep_free_key_range_reg(void *start, unsigned long size) · 34 unmodified lines
4744	{	4744	{
4745	struct pending_free *pf;	4745	struct pending_free *pf;
4746	unsigned long flags;	4746	unsigned long flags;
4747	int locked;
4748		4747
4749	init_data_structures_once();	4748	init_data_structures_once();
4750		4749
4751	raw_local_irq_save(flags);	4750	raw_local_irq_save(flags);
4752	locked = graph_lock();	4751	arch_spin_lock(&lockdep_lock);
4753	if (!locked)	4752	current->lockdep_recursion = 1;
4754	goto out_irq;
4755
4756	pf = get_pending_free();	4753	pf = get_pending_free();
4757	__lockdep_free_key_range(pf, start, size);	4754	__lockdep_free_key_range(pf, start, size);
4758	call_rcu_zapped(pf);	4755	call_rcu_zapped(pf);
4759		4756	current->lockdep_recursion = 0;
4760	graph_unlock();	4757	arch_spin_unlock(&lockdep_lock);
4761	out_irq:
4762	raw_local_irq_restore(flags);	4758	raw_local_irq_restore(flags);
4763		4759
4764	/*	4760	/*

kernel/sched/deadline.c+1−2

 	if (dl_entity_is_special(dl_se))
 		return;
-	WARN_ON(hrtimer_active(&dl_se->inactive_timer));
 	WARN_ON(dl_se->dl_non_contending);
 	zerolag_time = dl_se->deadline -
 	 * If the "0-lag time" already passed, decrease the active
 	 * utilization now, instead of starting a timer
 	 */
-	if (zerolag_time < 0) {
+	if ((zerolag_time < 0) || hrtimer_active(&dl_se->inactive_timer)) {
 		if (dl_task(p))
 			sub_running_bw(dl_se, dl_rq);
 		if (!dl_task(p) || p->state == TASK_DEAD) {

kernel/sched/fair.c+28−3

 	return HRTIMER_NORESTART;
 }
+extern const u64 max_cfs_quota_period;
 static enum hrtimer_restart sched_cfs_period_timer(struct hrtimer *timer)
 {
 	struct cfs_bandwidth *cfs_b =
 	unsigned long flags;
 	int overrun;
 	int idle = 0;
+	int count = 0;
 	raw_spin_lock_irqsave(&cfs_b->lock, flags);
 	for (;;) {
 		if (!overrun)
 			break;
+		if (++count > 3) {
+			u64 new, old = ktime_to_ns(cfs_b->period);
+			new = (old * 147) / 128; /* ~115% */
+			new = min(new, max_cfs_quota_period);
+			cfs_b->period = ns_to_ktime(new);
+			/* since max is 1s, this is limited to 1e9^2, which fits in u64 */
+			cfs_b->quota *= new;
+			cfs_b->quota = div64_u64(cfs_b->quota, old);
+			pr_warn_ratelimited(
+	"cfs_period_timer[cpu%d]: period too short, scaling up (new cfs_period_us %lld, cfs_quota_us = %lld)\n",
+				smp_processor_id(),
+				div_u64(new, NSEC_PER_USEC),
+				div_u64(cfs_b->quota, NSEC_PER_USEC));
+			/* reset count so we don't come right back in here */
+			count = 0;
+		}
 		idle = do_sched_cfs_period_timer(cfs_b, overrun, flags);
 	}
 	if (idle)
 	if (cfs_rq->last_h_load_update == now)
 		return;
-	cfs_rq->h_load_next = NULL;
+	WRITE_ONCE(cfs_rq->h_load_next, NULL);
 	for_each_sched_entity(se) {
 		cfs_rq = cfs_rq_of(se);
-		cfs_rq->h_load_next = se;
+		WRITE_ONCE(cfs_rq->h_load_next, se);
 		if (cfs_rq->last_h_load_update == now)
 			break;
 	}
 		cfs_rq->last_h_load_update = now;
 	}
-	while ((se = cfs_rq->h_load_next) != NULL) {
+	while ((se = READ_ONCE(cfs_rq->h_load_next)) != NULL) {
 		load = cfs_rq->h_load;
 		load = div64_ul(load * se->avg.load_avg,
 			cfs_rq_load_avg(cfs_rq) + 1);

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/signal.c+5−10

 	if (flags)
 		return -EINVAL;
-	f = fdget_raw(pidfd);
+	f = fdget(pidfd);
 	if (!f.file)
 		return -EBADF;
 		if (unlikely(sig != kinfo.si_signo))
 			goto err;
+		/* Only allow sending arbitrary signals to yourself. */
+		ret = -EPERM;
 		if ((task_pid(current) != pid) &&
-		    (kinfo.si_code >= 0 || kinfo.si_code == SI_TKILL)) {
+		    (kinfo.si_code >= 0 || kinfo.si_code == SI_TKILL))
-			/* Only allow sending arbitrary signals to yourself. */
+			goto err;
-			ret = -EPERM;
-			if (kinfo.si_code != SI_USER)
-				goto err;
-			/* Turn this into a regular kill signal. */
-			prepare_kill_siginfo(sig, &kinfo);
-		}
 	} else {
 		prepare_kill_siginfo(sig, &kinfo);
 	}

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/time/alarmtimer.c+1−1

@@ -594,7 +594,7 @@ static ktime_t alarm_timer_remaining(struct k_itimer *timr, ktime_t now) · 593 unmodified lines
594	{	594	{
595	struct alarm *alarm = &timr->it.alarm.alarmtimer;	595	struct alarm *alarm = &timr->it.alarm.alarmtimer;
596		596
597	return ktime_sub(now, alarm->node.expires);	597	return ktime_sub(alarm->node.expires, now);
598	}	598	}
599		599
600	/**	600	/**

kernel/time/sched_clock.c+2−2

@@ -272,7 +272,7 @@ static u64 notrace suspended_sched_clock_read(void) · 271 unmodified lines
272	return cd.read_data[seq & 1].epoch_cyc;	272	return cd.read_data[seq & 1].epoch_cyc;
273	}	273	}
274		274
275	static int sched_clock_suspend(void)	275	int sched_clock_suspend(void)
276	{	276	{
277	struct clock_read_data *rd = &cd.read_data[0];	277	struct clock_read_data *rd = &cd.read_data[0];
278		278
@@ -283,7 +283,7 @@ static int sched_clock_suspend(void) · 4 unmodified lines
283	return 0;	283	return 0;
284	}	284	}
285		285
286	static void sched_clock_resume(void)	286	void sched_clock_resume(void)
287	{	287	{
288	struct clock_read_data *rd = &cd.read_data[0];	288	struct clock_read_data *rd = &cd.read_data[0];
289		289

kernel/time/tick-common.c+2−0

 		trace_suspend_resume(TPS("timekeeping_freeze"),
 				     smp_processor_id(), true);
 		system_state = SYSTEM_SUSPEND;
+		sched_clock_suspend();
 		timekeeping_suspend();
 	} else {
 		tick_suspend_local();
 	if (tick_freeze_depth == num_online_cpus()) {
 		timekeeping_resume();
+		sched_clock_resume();
 		system_state = SYSTEM_RUNNING;
 		trace_suspend_resume(TPS("timekeeping_freeze"),
 				     smp_processor_id(), false);

kernel/time/timekeeping.h+7−0

@@ -14,6 +14,13 @@ extern u64 timekeeping_max_deferment(void); · 13 unmodified lines
14	extern void timekeeping_warp_clock(void);	14	extern void timekeeping_warp_clock(void);
15	extern int timekeeping_suspend(void);	15	extern int timekeeping_suspend(void);
16	extern void timekeeping_resume(void);	16	extern void timekeeping_resume(void);
		17	#ifdef CONFIG_GENERIC_SCHED_CLOCK
		18	extern int sched_clock_suspend(void);
		19	extern void sched_clock_resume(void);
		20	#else
		21	static inline int sched_clock_suspend(void) { return 0; }
		22	static inline void sched_clock_resume(void) { }
		23	#endif
17		24
18	extern void do_timer(unsigned long ticks);	25	extern void do_timer(unsigned long ticks);
19	extern void update_wall_time(void);	26	extern void update_wall_time(void);

kernel/trace/ftrace.c+5−1

 #include <linux/list.h>
 #include <linux/hash.h>
 #include <linux/rcupdate.h>
+#include <linux/kprobes.h>
 #include <trace/events/sched.h>
 	tr->ops->func = ftrace_stub;
 }
-static inline void
+static nokprobe_inline void
 __ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,
 		       struct ftrace_ops *ignored, struct pt_regs *regs)
 {
 {
 	__ftrace_ops_list_func(ip, parent_ip, NULL, regs);
 }
+NOKPROBE_SYMBOL(ftrace_ops_list_func);
 #else
 static void ftrace_ops_no_ops(unsigned long ip, unsigned long parent_ip)
 {
 	__ftrace_ops_list_func(ip, parent_ip, NULL, NULL);
 }
+NOKPROBE_SYMBOL(ftrace_ops_no_ops);
 #endif
 /*
 	preempt_enable_notrace();
 	trace_clear_recursion(bit);
 }
+NOKPROBE_SYMBOL(ftrace_ops_assist_func);
 /**
  * ftrace_ops_get_func - get the function a trampoline should call

kernel/trace/trace.c+5−1

 	buf->private = 0;
 }
-static void buffer_pipe_buf_get(struct pipe_inode_info *pipe,
+static bool buffer_pipe_buf_get(struct pipe_inode_info *pipe,
 				struct pipe_buffer *buf)
 {
 	struct buffer_ref *ref = (struct buffer_ref *)buf->private;
+	if (ref->ref > INT_MAX/2)
+		return false;
 	ref->ref++;
+	return true;
 }
 /* Pipe buffer operations for a buffer. */

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)) ||

kernel/watchdog_hld.c+2−1

@@ -135,7 +135,8 @@ static void watchdog_overflow_callback(struct perf_event *event, · 134 unmodified lines
135	if (__this_cpu_read(hard_watchdog_warn) == true)	135	if (__this_cpu_read(hard_watchdog_warn) == true)
136	return;	136	return;
137		137
138	pr_emerg("Watchdog detected hard LOCKUP on cpu %d", this_cpu);	138	pr_emerg("Watchdog detected hard LOCKUP on cpu %d\n",
		139	this_cpu);
139	print_modules();	140	print_modules();
140	print_irqtrace_events(current);	141	print_irqtrace_events(current);
141	if (regs)	142	if (regs)

lib/Kconfig.debug+3−3

@@ -753,9 +753,9 @@ endmenu # "Memory Debugging" · 752 unmodified lines
753	config ARCH_HAS_KCOV	753	config ARCH_HAS_KCOV
754	bool	754	bool
755	help	755	help
756	KCOV does not have any arch-specific code, but currently it is enabled	756	An architecture should select this when it can successfully
757	only for x86_64. KCOV requires testing on other archs, and most likely	757	build and run with CONFIG_KCOV. This typically requires
758	disabling of instrumentation for some early boot code.	758	disabling instrumentation for some early boot code.
759		759
760	config CC_HAS_SANCOV_TRACE_PC	760	config CC_HAS_SANCOV_TRACE_PC
761	def_bool $(cc-option,-fsanitize-coverage=trace-pc)	761	def_bool $(cc-option,-fsanitize-coverage=trace-pc)

lib/iov_iter.c+4−0

 size_t hash_and_copy_to_iter(const void *addr, size_t bytes, void *hashp,
 		struct iov_iter *i)
 {
+#ifdef CONFIG_CRYPTO
 	struct ahash_request *hash = hashp;
 	struct scatterlist sg;
 	size_t copied;
 	ahash_request_set_crypt(hash, &sg, NULL, copied);
 	crypto_ahash_update(hash);
 	return copied;
+#else
+	return 0;
+#endif
 }
 EXPORT_SYMBOL(hash_and_copy_to_iter);

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/compaction.c+18−11

 							bool check_target)
 {
 	struct page *page = pfn_to_online_page(pfn);
+	struct page *block_page;
 	struct page *end_page;
 	unsigned long block_pfn;
 	    get_pageblock_migratetype(page) != MIGRATE_MOVABLE)
 		return false;
+	/* Ensure the start of the pageblock or zone is online and valid */
+	block_pfn = pageblock_start_pfn(pfn);
+	block_page = pfn_to_online_page(max(block_pfn, zone->zone_start_pfn));
+	if (block_page) {
+		page = block_page;
+		pfn = block_pfn;
+	}
+	/* Ensure the end of the pageblock or zone is online and valid */
+	block_pfn += pageblock_nr_pages;
+	block_pfn = min(block_pfn, zone_end_pfn(zone) - 1);
+	end_page = pfn_to_online_page(block_pfn);
+	if (!end_page)
+		return false;
 	/*
 	 * Only clear the hint if a sample indicates there is either a
 	 * free page or an LRU page in the block. One or other condition
 	 * is necessary for the block to be a migration source/target.
 	 */
-	block_pfn = pageblock_start_pfn(pfn);
-	pfn = max(block_pfn, zone->zone_start_pfn);
-	page = pfn_to_page(pfn);
-	if (zone != page_zone(page))
-		return false;
-	pfn = block_pfn + pageblock_nr_pages;
-	pfn = min(pfn, zone_end_pfn(zone));
-	end_page = pfn_to_page(pfn);
 	do {
 		if (pfn_valid_within(pfn)) {
 			if (check_source && PageLRU(page)) {
 static void __reset_isolation_suitable(struct zone *zone)
 {
 	unsigned long migrate_pfn = zone->zone_start_pfn;
-	unsigned long free_pfn = zone_end_pfn(zone);
+	unsigned long free_pfn = zone_end_pfn(zone) - 1;
 	unsigned long reset_migrate = free_pfn;
 	unsigned long reset_free = migrate_pfn;
 	bool source_set = false;
 				count_compact_events(COMPACTISOLATED, nr_isolated);
 			} else {
 				/* If isolation fails, abort the search */
-				order = -1;
+				order = cc->search_order + 1;
 				page = NULL;
 			}
 		}

mm/gup.c+36−12

 		goto retry;
 	}
-	if (flags & FOLL_GET)
+	if (flags & FOLL_GET) {
-		get_page(page);
+		if (unlikely(!try_get_page(page))) {
+			page = ERR_PTR(-ENOMEM);
+			goto out;
+		}
+	}
 	if (flags & FOLL_TOUCH) {
 		if ((flags & FOLL_WRITE) &&
 		    !pte_dirty(pte) && !PageDirty(page))
 			if (pmd_trans_unstable(pmd))
 				ret = -EBUSY;
 		} else {
-			get_page(page);
+			if (unlikely(!try_get_page(page))) {
+				spin_unlock(ptl);
+				return ERR_PTR(-ENOMEM);
+			}
 			spin_unlock(ptl);
 			lock_page(page);
 			ret = split_huge_page(page);
 		if (is_device_public_page(*page))
 			goto unmap;
 	}
-	get_page(*page);
+	if (unlikely(!try_get_page(*page))) {
+		ret = -ENOMEM;
+		goto unmap;
+	}
 out:
 	ret = 0;
 unmap:
 	}
 }
+/*
+ * Return the compund head page with ref appropriately incremented,
+ * or NULL if that failed.
+ */
+static inline struct page *try_get_compound_head(struct page *page, int refs)
+{
+	struct page *head = compound_head(page);
+	if (WARN_ON_ONCE(page_ref_count(head) < 0))
+		return NULL;
+	if (unlikely(!page_cache_add_speculative(head, refs)))
+		return NULL;
+	return head;
+}
 #ifdef CONFIG_ARCH_HAS_PTE_SPECIAL
 static int gup_pte_range(pmd_t pmd, unsigned long addr, unsigned long end,
 			 int write, struct page **pages, int *nr)
 		VM_BUG_ON(!pfn_valid(pte_pfn(pte)));
 		page = pte_page(pte);
-		head = compound_head(page);
-		if (!page_cache_get_speculative(head))
+		head = try_get_compound_head(page, 1);
+		if (!head)
 			goto pte_unmap;
 		if (unlikely(pte_val(pte) != pte_val(*ptep))) {
 		refs++;
 	} while (addr += PAGE_SIZE, addr != end);
-	head = compound_head(pmd_page(orig));
+	head = try_get_compound_head(pmd_page(orig), refs);
-	if (!page_cache_add_speculative(head, refs)) {
+	if (!head) {
 		*nr -= refs;
 		return 0;
 	}
 		refs++;
 	} while (addr += PAGE_SIZE, addr != end);
-	head = compound_head(pud_page(orig));
+	head = try_get_compound_head(pud_page(orig), refs);
-	if (!page_cache_add_speculative(head, refs)) {
+	if (!head) {
 		*nr -= refs;
 		return 0;
 	}
 		refs++;
 	} while (addr += PAGE_SIZE, addr != end);
-	head = compound_head(pgd_page(orig));
+	head = try_get_compound_head(pgd_page(orig), refs);
-	if (!page_cache_add_speculative(head, refs)) {
+	if (!head) {
 		*nr -= refs;
 		return 0;
 	}

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/hugetlb.c+13−0

@@ -4299,6 +4299,19 @@ long follow_hugetlb_page(struct mm_struct mm, struct vm_area_struct vma, · 4298 unmodified lines
4299		4299
4300	pfn_offset = (vaddr & ~huge_page_mask(h)) >> PAGE_SHIFT;	4300	pfn_offset = (vaddr & ~huge_page_mask(h)) >> PAGE_SHIFT;
4301	page = pte_page(huge_ptep_get(pte));	4301	page = pte_page(huge_ptep_get(pte));
		4302
		4303	/*
		4304	* Instead of doing 'try_get_page()' below in the same_page
		4305	* loop, just check the count once here.
		4306	*/
		4307	if (unlikely(page_count(page) <= 0)) {
		4308	if (pages) {
		4309	spin_unlock(ptl);
		4310	remainder = 0;
		4311	err = -ENOMEM;
		4312	break;
		4313	}
		4314	}
4302	same_page:	4315	same_page:
4303	if (pages) {	4316	if (pages) {
4304	pages[i] = mem_map_offset(page, pfn_offset);	4317	pages[i] = mem_map_offset(page, pfn_offset);

mm/kmemleak.c+13−5

 /*
  * Scan a large memory block in MAX_SCAN_SIZE chunks to reduce the latency.
  */
+#ifdef CONFIG_SMP
 static void scan_large_block(void *start, void *end)
 {
 	void *next;
 		cond_resched();
 	}
 }
+#endif
 /*
  * Scan a memory block corresponding to a kmemleak_object. A condition is
 	}
 	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/mmap.c+6−1

 #include <linux/moduleparam.h>
 #include <linux/pkeys.h>
 #include <linux/oom.h>
+#include <linux/sched/mm.h>
 #include <linux/uaccess.h>
 #include <asm/cacheflush.h>
 	vma = find_vma_prev(mm, addr, &prev);
 	if (vma && (vma->vm_start <= addr))
 		return vma;
-	if (!prev || expand_stack(prev, addr))
+	/* don't alter vm_end if the coredump is running */
+	if (!prev || !mmget_still_valid(mm) || expand_stack(prev, addr))
 		return NULL;
 	if (prev->vm_flags & VM_LOCKED)
 		populate_vma_page_range(prev, addr, prev->vm_end, NULL);
 		return vma;
 	if (!(vma->vm_flags & VM_GROWSDOWN))
 		return NULL;
+	/* don't alter vm_start if the coredump is running */
+	if (!mmget_still_valid(mm))
+		return NULL;
 	start = vma->vm_start;
 	if (expand_stack(vma, addr))
 		return NULL;

mm/page_alloc.c+18−12

 bool has_unmovable_pages(struct zone *zone, struct page *page, int count,
 			 int migratetype, int flags)
 {
-	unsigned long pfn, iter, found;
+	unsigned long found;
+	unsigned long iter = 0;
+	unsigned long pfn = page_to_pfn(page);
+	const char *reason = "unmovable page";
 	/*
 	 * TODO we could make this much more efficient by not checking every
 	 * can still lead to having bootmem allocations in zone_movable.
 	 */
-	/*
+	if (is_migrate_cma_page(page)) {
-	 * CMA allocations (alloc_contig_range) really need to mark isolate
+		/*
-	 * CMA pageblocks even when they are not movable in fact so consider
+		 * CMA allocations (alloc_contig_range) really need to mark
-	 * them movable here.
+		 * isolate CMA pageblocks even when they are not movable in fact
-	 */
+		 * so consider them movable here.
-	if (is_migrate_cma(migratetype) &&
+		 */
-			is_migrate_cma(get_pageblock_migratetype(page)))
+		if (is_migrate_cma(migratetype))
-		return false;
+			return false;
+		reason = "CMA page";
+		goto unmovable;
+	}
-	pfn = page_to_pfn(page);
+	for (found = 0; iter < pageblock_nr_pages; iter++) {
-	for (found = 0, iter = 0; iter < pageblock_nr_pages; iter++) {
 		unsigned long check = pfn + iter;
 		if (!pfn_valid_within(check))
 unmovable:
 	WARN_ON_ONCE(zone_idx(zone) == ZONE_MOVABLE);
 	if (flags & REPORT_FAILURE)
-		dump_page(pfn_to_page(pfn+iter), "unmovable page");
+		dump_page(pfn_to_page(pfn + iter), reason);
 	return true;
 }

mm/percpu.c+4−4

@@ -2567,8 +2567,8 @@ int __init pcpu_embed_first_chunk(size_t reserved_size, size_t dyn_size, · 2566 unmodified lines
2567	ai->groups[group].base_offset = areas[group] - base;	2567	ai->groups[group].base_offset = areas[group] - base;
2568	}	2568	}
2569		2569
2570	pr_info("Embedded %zu pages/cpu @%p s%zu r%zu d%zu u%zu\n",	2570	pr_info("Embedded %zu pages/cpu s%zu r%zu d%zu u%zu\n",
2571	PFN_DOWN(size_sum), base, ai->static_size, ai->reserved_size,	2571	PFN_DOWN(size_sum), ai->static_size, ai->reserved_size,
2572	ai->dyn_size, ai->unit_size);	2572	ai->dyn_size, ai->unit_size);
2573		2573
2574	rc = pcpu_setup_first_chunk(ai, base);	2574	rc = pcpu_setup_first_chunk(ai, base);
@@ -2692,8 +2692,8 @@ int __init pcpu_page_first_chunk(size_t reserved_size, · 117 unmodified lines
2692	}	2692	}
2693		2693
2694	/* we're ready, commit */	2694	/* we're ready, commit */
2695	pr_info("%d %s pages/cpu @%p s%zu r%zu d%zu\n",	2695	pr_info("%d %s pages/cpu s%zu r%zu d%zu\n",
2696	unit_pages, psize_str, vm.addr, ai->static_size,	2696	unit_pages, psize_str, ai->static_size,
2697	ai->reserved_size, ai->dyn_size);	2697	ai->reserved_size, ai->dyn_size);
2698		2698
2699	rc = pcpu_setup_first_chunk(ai, vm.addr);	2699	rc = pcpu_setup_first_chunk(ai, vm.addr);

mm/shmem.c+27−31

@@ -1081,9 +1081,14 @@ static void shmem_evict_inode(struct inode *inode) · 1080 unmodified lines
1081	}	1081	}
1082	spin_unlock(&sbinfo->shrinklist_lock);	1082	spin_unlock(&sbinfo->shrinklist_lock);
1083	}	1083	}
1084	if (!list_empty(&info->swaplist)) {	1084	while (!list_empty(&info->swaplist)) {
		1085	/* Wait while shmem_unuse() is scanning this inode... */
		1086	wait_var_event(&info->stop_eviction,
		1087	!atomic_read(&info->stop_eviction));
1085	mutex_lock(&shmem_swaplist_mutex);	1088	mutex_lock(&shmem_swaplist_mutex);
1086	list_del_init(&info->swaplist);	1089	/* ...but beware of the race if we peeked too early */
		1090	if (!atomic_read(&info->stop_eviction))
		1091	list_del_init(&info->swaplist);
1087	mutex_unlock(&shmem_swaplist_mutex);	1092	mutex_unlock(&shmem_swaplist_mutex);
1088	}	1093	}
1089	}	1094	}
@@ -1099,10 +1104,11 @@ extern struct swap_info_struct *swap_info[]; · 9 unmodified lines
1099	static int shmem_find_swap_entries(struct address_space *mapping,	1104	static int shmem_find_swap_entries(struct address_space *mapping,
1100	pgoff_t start, unsigned int nr_entries,	1105	pgoff_t start, unsigned int nr_entries,
1101	struct page *entries, pgoff_t indices,	1106	struct page *entries, pgoff_t indices,
1102	bool frontswap)	1107	unsigned int type, bool frontswap)
1103	{	1108	{
1104	XA_STATE(xas, &mapping->i_pages, start);	1109	XA_STATE(xas, &mapping->i_pages, start);
1105	struct page *page;	1110	struct page *page;
		1111	swp_entry_t entry;
1106	unsigned int ret = 0;	1112	unsigned int ret = 0;
1107		1113
1108	if (!nr_entries)	1114	if (!nr_entries)
@@ -1116,13 +1122,12 @@ static int shmem_find_swap_entries(struct address_space *mapping, · 7 unmodified lines
1116	if (!xa_is_value(page))	1122	if (!xa_is_value(page))
1117	continue;	1123	continue;
1118		1124
1119	if (frontswap) {	1125	entry = radix_to_swp_entry(page);
1120	swp_entry_t entry = radix_to_swp_entry(page);	1126	if (swp_type(entry) != type)
1121		1127	continue;
1122	if (!frontswap_test(swap_info[swp_type(entry)],	1128	if (frontswap &&
1123	swp_offset(entry)))	1129	!frontswap_test(swap_info[type], swp_offset(entry)))
1124	continue;	1130	continue;
1125	}
1126		1131
1127	indices[ret] = xas.xa_index;	1132	indices[ret] = xas.xa_index;
1128	entries[ret] = page;	1133	entries[ret] = page;
@@ -1194,7 +1199,7 @@ static int shmem_unuse_inode(struct inode *inode, unsigned int type, · 65 unmodified lines
1194		1199
1195	pvec.nr = shmem_find_swap_entries(mapping, start, nr_entries,	1200	pvec.nr = shmem_find_swap_entries(mapping, start, nr_entries,
1196	pvec.pages, indices,	1201	pvec.pages, indices,
1197	frontswap);	1202	type, frontswap);
1198	if (pvec.nr == 0) {	1203	if (pvec.nr == 0) {
1199	ret = 0;	1204	ret = 0;
1200	break;	1205	break;
@@ -1227,36 +1232,27 @@ int shmem_unuse(unsigned int type, bool frontswap, · 26 unmodified lines
1227	unsigned long *fs_pages_to_unuse)	1232	unsigned long *fs_pages_to_unuse)
1228	{	1233	{
1229	struct shmem_inode_info info, next;	1234	struct shmem_inode_info info, next;
1230	struct inode *inode;
1231	struct inode *prev_inode = NULL;
1232	int error = 0;	1235	int error = 0;
1233		1236
1234	if (list_empty(&shmem_swaplist))	1237	if (list_empty(&shmem_swaplist))
1235	return 0;	1238	return 0;
1236		1239
1237	mutex_lock(&shmem_swaplist_mutex);	1240	mutex_lock(&shmem_swaplist_mutex);
1238
1239	/*
1240	* The extra refcount on the inode is necessary to safely dereference
1241	* p->next after re-acquiring the lock. New shmem inodes with swap
1242	* get added to the end of the list and we will scan them all.
1243	*/
1244	list_for_each_entry_safe(info, next, &shmem_swaplist, swaplist) {	1241	list_for_each_entry_safe(info, next, &shmem_swaplist, swaplist) {
1245	if (!info->swapped) {	1242	if (!info->swapped) {
1246	list_del_init(&info->swaplist);	1243	list_del_init(&info->swaplist);
1247	continue;	1244	continue;
1248	}	1245	}
1249		1246	/*
1250	inode = igrab(&info->vfs_inode);	1247	* Drop the swaplist mutex while searching the inode for swap;
1251	if (!inode)	1248	* but before doing so, make sure shmem_evict_inode() will not
1252	continue;	1249	* remove placeholder inode from swaplist, nor let it be freed
1253		1250	* (igrab() would protect from unlink, but not from unmount).
		1251	*/
		1252	atomic_inc(&info->stop_eviction);
1254	mutex_unlock(&shmem_swaplist_mutex);	1253	mutex_unlock(&shmem_swaplist_mutex);
1255	if (prev_inode)
1256	iput(prev_inode);
1257	prev_inode = inode;
1258		1254
1259	error = shmem_unuse_inode(inode, type, frontswap,	1255	error = shmem_unuse_inode(&info->vfs_inode, type, frontswap,
1260	fs_pages_to_unuse);	1256	fs_pages_to_unuse);
1261	cond_resched();	1257	cond_resched();
1262		1258
@@ -1264,14 +1260,13 @@ int shmem_unuse(unsigned int type, bool frontswap, · 1 unmodified line
1264	next = list_next_entry(info, swaplist);	1260	next = list_next_entry(info, swaplist);
1265	if (!info->swapped)	1261	if (!info->swapped)
1266	list_del_init(&info->swaplist);	1262	list_del_init(&info->swaplist);
		1263	if (atomic_dec_and_test(&info->stop_eviction))
		1264	wake_up_var(&info->stop_eviction);
1267	if (error)	1265	if (error)
1268	break;	1266	break;
1269	}	1267	}
1270	mutex_unlock(&shmem_swaplist_mutex);	1268	mutex_unlock(&shmem_swaplist_mutex);
1271		1269
1272	if (prev_inode)
1273	iput(prev_inode);
1274
1275	return error;	1270	return error;
1276	}	1271	}
1277		1272
@@ -2238,6 +2233,7 @@ static struct inode shmem_get_inode(struct super_block sb, const struct inode · 960 unmodified lines
2238	info = SHMEM_I(inode);	2233	info = SHMEM_I(inode);
2239	memset(info, 0, (char )inode - (char )info);	2234	memset(info, 0, (char )inode - (char )info);
2240	spin_lock_init(&info->lock);	2235	spin_lock_init(&info->lock);
		2236	atomic_set(&info->stop_eviction, 0);
2241	info->seals = F_SEAL_SEAL;	2237	info->seals = F_SEAL_SEAL;
2242	info->flags = flags & VM_NORESERVE;	2238	info->flags = flags & VM_NORESERVE;
2243	INIT_LIST_HEAD(&info->shrinklist);	2239	INIT_LIST_HEAD(&info->shrinklist);

mm/slab.c+2−2

 		/* Slab management obj is off-slab. */
 		freelist = kmem_cache_alloc_node(cachep->freelist_cache,
 					      local_flags, nodeid);
-		freelist = kasan_reset_tag(freelist);
 		if (!freelist)
 			return NULL;
 	} else {
 static int leaks_show(struct seq_file *m, void *p)
 {
-	struct kmem_cache *cachep = list_entry(p, struct kmem_cache, list);
+	struct kmem_cache *cachep = list_entry(p, struct kmem_cache,
+					       root_caches_node);
 	struct page *page;
 	struct kmem_cache_node *n;
 	const char *name;

mm/swapfile.c+17−15

@@ -2023,7 +2023,6 @@ static unsigned int find_next_to_unuse(struct swap_info_struct *si, · 2022 unmodified lines
2023	* If the boolean frontswap is true, only unuse pages_to_unuse pages;	2023	* If the boolean frontswap is true, only unuse pages_to_unuse pages;
2024	* pages_to_unuse==0 means all pages; ignored if frontswap is false	2024	* pages_to_unuse==0 means all pages; ignored if frontswap is false
2025	*/	2025	*/
2026	#define SWAP_UNUSE_MAX_TRIES 3
2027	int try_to_unuse(unsigned int type, bool frontswap,	2026	int try_to_unuse(unsigned int type, bool frontswap,
2028	unsigned long pages_to_unuse)	2027	unsigned long pages_to_unuse)
2029	{	2028	{
@@ -2035,7 +2034,6 @@ int try_to_unuse(unsigned int type, bool frontswap, · 5 unmodified lines
2035	struct page *page;	2034	struct page *page;
2036	swp_entry_t entry;	2035	swp_entry_t entry;
2037	unsigned int i;	2036	unsigned int i;
2038	int retries = 0;
2039		2037
2040	if (!si->inuse_pages)	2038	if (!si->inuse_pages)
2041	return 0;	2039	return 0;
@@ -2053,11 +2051,9 @@ retry: · 11 unmodified lines
2053		2051
2054	spin_lock(&mmlist_lock);	2052	spin_lock(&mmlist_lock);
2055	p = &init_mm.mmlist;	2053	p = &init_mm.mmlist;
2056	while ((p = p->next) != &init_mm.mmlist) {	2054	while (si->inuse_pages &&
2057	if (signal_pending(current)) {	2055	!signal_pending(current) &&
2058	retval = -EINTR;	2056	(p = p->next) != &init_mm.mmlist) {
2059	break;
2060	}
2061		2057
2062	mm = list_entry(p, struct mm_struct, mmlist);	2058	mm = list_entry(p, struct mm_struct, mmlist);
2063	if (!mmget_not_zero(mm))	2059	if (!mmget_not_zero(mm))
@@ -2084,7 +2080,9 @@ retry: · 20 unmodified lines
2084	mmput(prev_mm);	2080	mmput(prev_mm);
2085		2081
2086	i = 0;	2082	i = 0;
2087	while ((i = find_next_to_unuse(si, i, frontswap)) != 0) {	2083	while (si->inuse_pages &&
		2084	!signal_pending(current) &&
		2085	(i = find_next_to_unuse(si, i, frontswap)) != 0) {
2088		2086
2089	entry = swp_entry(type, i);	2087	entry = swp_entry(type, i);
2090	page = find_get_page(swap_address_space(entry), i);	2088	page = find_get_page(swap_address_space(entry), i);
@@ -2117,14 +2115,18 @@ retry: · 26 unmodified lines
2117	* If yes, we would need to do retry the unuse logic again.	2115	* If yes, we would need to do retry the unuse logic again.
2118	* Under global memory pressure, swap entries can be reinserted back	2116	* Under global memory pressure, swap entries can be reinserted back
2119	* into process space after the mmlist loop above passes over them.	2117	* into process space after the mmlist loop above passes over them.
2120	* Its not worth continuosuly retrying to unuse the swap in this case.	2118	*
2121	* So we try SWAP_UNUSE_MAX_TRIES times.	2119	* Limit the number of retries? No: when mmget_not_zero() above fails,
		2120	* that mm is likely to be freeing swap from exit_mmap(), which proceeds
		2121	* at its own independent pace; and even shmem_writepage() could have
		2122	* been preempted after get_swap_page(), temporarily hiding that swap.
		2123	* It's easy and robust (though cpu-intensive) just to keep retrying.
2122	*/	2124	*/
2123	if (++retries >= SWAP_UNUSE_MAX_TRIES)	2125	if (si->inuse_pages) {
2124	retval = -EBUSY;	2126	if (!signal_pending(current))
2125	else if (si->inuse_pages)	2127	goto retry;
2126	goto retry;	2128	retval = -EINTR;
2127		2129	}
2128	out:	2130	out:
2129	return (retval == FRONTSWAP_PAGES_UNUSED) ? 0 : retval;	2131	return (retval == FRONTSWAP_PAGES_UNUSED) ? 0 : retval;
2130	}	2132	}

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	{

mm/vmscan.c+9−20

  *   10TB     320        32GB
  */
 static bool inactive_list_is_low(struct lruvec *lruvec, bool file,
-				 struct mem_cgroup *memcg,
 				 struct scan_control *sc, bool actual_reclaim)
 {
 	enum lru_list active_lru = file * LRU_FILE + LRU_ACTIVE;
 	inactive = lruvec_lru_size(lruvec, inactive_lru, sc->reclaim_idx);
 	active = lruvec_lru_size(lruvec, active_lru, sc->reclaim_idx);
-	if (memcg)
-		refaults = memcg_page_state(memcg, WORKINGSET_ACTIVATE);
-	else
-		refaults = node_page_state(pgdat, WORKINGSET_ACTIVATE);
 	/*
 	 * When refaults are being observed, it means a new workingset
 	 * is being established. Disable active list protection to get
 	 * rid of the stale workingset quickly.
 	 */
+	refaults = lruvec_page_state(lruvec, WORKINGSET_ACTIVATE);
 	if (file && actual_reclaim && lruvec->refaults != refaults) {
 		inactive_ratio = 0;
 	} else {
 }
 static unsigned long shrink_list(enum lru_list lru, unsigned long nr_to_scan,
-				 struct lruvec *lruvec, struct mem_cgroup *memcg,
+				 struct lruvec *lruvec, struct scan_control *sc)
-				 struct scan_control *sc)
 {
 	if (is_active_lru(lru)) {
-		if (inactive_list_is_low(lruvec, is_file_lru(lru),
+		if (inactive_list_is_low(lruvec, is_file_lru(lru), sc, true))
-					 memcg, sc, true))
 			shrink_active_list(nr_to_scan, lruvec, sc, lru);
 		return 0;
 	}
 			 * anonymous pages on the LRU in eligible zones.
 			 * Otherwise, the small LRU gets thrashed.
 			 */
-			if (!inactive_list_is_low(lruvec, false, memcg, sc, false) &&
+			if (!inactive_list_is_low(lruvec, false, sc, false) &&
 			    lruvec_lru_size(lruvec, LRU_INACTIVE_ANON, sc->reclaim_idx)
 					>> sc->priority) {
 				scan_balance = SCAN_ANON;
 	 * lruvec even if it has plenty of old anonymous pages unless the
 	 * system is under heavy pressure.
 	 */
-	if (!inactive_list_is_low(lruvec, true, memcg, sc, false) &&
+	if (!inactive_list_is_low(lruvec, true, sc, false) &&
 	    lruvec_lru_size(lruvec, LRU_INACTIVE_FILE, sc->reclaim_idx) >> sc->priority) {
 		scan_balance = SCAN_FILE;
 		goto out;
 				nr[lru] -= nr_to_scan;
 				nr_reclaimed += shrink_list(lru, nr_to_scan,
-							    lruvec, memcg, sc);
+							    lruvec, sc);
 			}
 		}
 	 * Even if we did not try to evict anon pages at all, we want to
 	 * rebalance the anon lru active/inactive ratio.
 	 */
-	if (inactive_list_is_low(lruvec, false, memcg, sc, true))
+	if (inactive_list_is_low(lruvec, false, sc, true))
 		shrink_active_list(SWAP_CLUSTER_MAX, lruvec,
 				   sc, LRU_ACTIVE_ANON);
 }
 		unsigned long refaults;
 		struct lruvec *lruvec;
-		if (memcg)
-			refaults = memcg_page_state(memcg, WORKINGSET_ACTIVATE);
-		else
-			refaults = node_page_state(pgdat, WORKINGSET_ACTIVATE);
 		lruvec = mem_cgroup_lruvec(pgdat, memcg);
+		refaults = lruvec_page_state(lruvec, WORKINGSET_ACTIVATE);
 		lruvec->refaults = refaults;
 	} while ((memcg = mem_cgroup_iter(root_memcg, memcg, NULL)));
 }
 	do {
 		struct lruvec *lruvec = mem_cgroup_lruvec(pgdat, memcg);
-		if (inactive_list_is_low(lruvec, false, memcg, sc, true))
+		if (inactive_list_is_low(lruvec, false, sc, true))
 			shrink_active_list(SWAP_CLUSTER_MAX, lruvec,
 					   sc, LRU_ACTIVE_ANON);

mm/vmstat.c+0−5

 #endif
 #endif /* CONFIG_MEMORY_BALLOON */
 #ifdef CONFIG_DEBUG_TLBFLUSH
-#ifdef CONFIG_SMP
 	"nr_tlb_remote_flush",
 	"nr_tlb_remote_flush_received",
-#else
-	"", /* nr_tlb_remote_flush */
-	"", /* nr_tlb_remote_flush_received */
-#endif /* CONFIG_SMP */
 	"nr_tlb_local_flush_all",
 	"nr_tlb_local_flush_one",
 #endif /* CONFIG_DEBUG_TLBFLUSH */

net/8021q/vlan_dev.c+15−11

 	return rc;
 }
-static int vlan_dev_fcoe_get_wwn(struct net_device *dev, u64 *wwn, int type)
+static int vlan_dev_fcoe_ddp_target(struct net_device *dev, u16 xid,
+				    struct scatterlist *sgl, unsigned int sgc)
 {
 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
 	const struct net_device_ops *ops = real_dev->netdev_ops;
-	int rc = -EINVAL;
+	int rc = 0;
+	if (ops->ndo_fcoe_ddp_target)
+		rc = ops->ndo_fcoe_ddp_target(real_dev, xid, sgl, sgc);
-	if (ops->ndo_fcoe_get_wwn)
-		rc = ops->ndo_fcoe_get_wwn(real_dev, wwn, type);
 	return rc;
 }
+#endif
-static int vlan_dev_fcoe_ddp_target(struct net_device *dev, u16 xid,
+#ifdef NETDEV_FCOE_WWNN
-				    struct scatterlist *sgl, unsigned int sgc)
+static int vlan_dev_fcoe_get_wwn(struct net_device *dev, u64 *wwn, int type)
 {
 	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
 	const struct net_device_ops *ops = real_dev->netdev_ops;
-	int rc = 0;
+	int rc = -EINVAL;
-	if (ops->ndo_fcoe_ddp_target)
-		rc = ops->ndo_fcoe_ddp_target(real_dev, xid, sgl, sgc);
+	if (ops->ndo_fcoe_get_wwn)
+		rc = ops->ndo_fcoe_get_wwn(real_dev, wwn, type);
 	return rc;
 }
 #endif
 	.ndo_fcoe_ddp_done	= vlan_dev_fcoe_ddp_done,
 	.ndo_fcoe_enable	= vlan_dev_fcoe_enable,
 	.ndo_fcoe_disable	= vlan_dev_fcoe_disable,
-	.ndo_fcoe_get_wwn	= vlan_dev_fcoe_get_wwn,
 	.ndo_fcoe_ddp_target	= vlan_dev_fcoe_ddp_target,
 #endif
+#ifdef NETDEV_FCOE_WWNN
+	.ndo_fcoe_get_wwn	= vlan_dev_fcoe_get_wwn,
+#endif
 #ifdef CONFIG_NET_POLL_CONTROLLER
 	.ndo_poll_controller	= vlan_dev_poll_controller,
 	.ndo_netpoll_setup	= vlan_dev_netpoll_setup,

net/atm/lec.c+5−1

 static int lec_mcast_attach(struct atm_vcc *vcc, int arg)
 {
-	if (arg < 0 || arg >= MAX_LEC_ITF || !dev_lec[arg])
+	if (arg < 0 || arg >= MAX_LEC_ITF)
+		return -EINVAL;
+	arg = array_index_nospec(arg, MAX_LEC_ITF);
+	if (!dev_lec[arg])
 		return -EINVAL;
 	vcc->proto_data = dev_lec[arg];
 	return lec_mcast_make(netdev_priv(dev_lec[arg]), vcc);
 		i = arg;
 	if (arg >= MAX_LEC_ITF)
 		return -EINVAL;
+	i = array_index_nospec(arg, MAX_LEC_ITF);
 	if (!dev_lec[i]) {
 		int size;

net/batman-adv/bat_v_elp.c+4−2

@@ -104,8 +104,10 @@ static u32 batadv_v_elp_get_throughput(struct batadv_hardif_neigh_node *neigh) · 103 unmodified lines
104		104
105	ret = cfg80211_get_station(real_netdev, neigh->addr, &sinfo);	105	ret = cfg80211_get_station(real_netdev, neigh->addr, &sinfo);
106		106
107	/* free the TID stats immediately */	107	if (!ret) {
108	cfg80211_sinfo_release_content(&sinfo);	108	/* free the TID stats immediately */
		109	cfg80211_sinfo_release_content(&sinfo);
		110	}
109		111
110	dev_put(real_netdev);	112	dev_put(real_netdev);
111	if (ret == -ENOENT) {	113	if (ret == -ENOENT) {

net/batman-adv/bridge_loop_avoidance.c+13−3

 				 const u8 *mac, const unsigned short vid)
 {
 	struct batadv_bla_claim search_claim, *claim;
+	struct batadv_bla_claim *claim_removed_entry;
+	struct hlist_node *claim_removed_node;
 	ether_addr_copy(search_claim.addr, mac);
 	search_claim.vid = vid;
 	batadv_dbg(BATADV_DBG_BLA, bat_priv, "%s(): %pM, vid %d\n", __func__,
 		   mac, batadv_print_vid(vid));
-	batadv_hash_remove(bat_priv->bla.claim_hash, batadv_compare_claim,
+	claim_removed_node = batadv_hash_remove(bat_priv->bla.claim_hash,
-			   batadv_choose_claim, claim);
+						batadv_compare_claim,
-	batadv_claim_put(claim); /* reference from the hash is gone */
+						batadv_choose_claim, claim);
+	if (!claim_removed_node)
+		goto free_claim;
+	/* reference from the hash is gone */
+	claim_removed_entry = hlist_entry(claim_removed_node,
+					  struct batadv_bla_claim, hash_entry);
+	batadv_claim_put(claim_removed_entry);
+free_claim:
 	/* don't need the reference from hash_find() anymore */
 	batadv_claim_put(claim);
 }

net/batman-adv/sysfs.c+5−2

 						struct attribute *attr,
 						char *buff, size_t count)
 {
-	struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
 	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
 	struct batadv_hard_iface *hard_iface;
+	struct batadv_priv *bat_priv;
 	u32 tp_override;
 	u32 old_tp_override;
 	bool ret;
 	atomic_set(&hard_iface->bat_v.throughput_override, tp_override);
-	batadv_netlink_notify_hardif(bat_priv, hard_iface);
+	if (hard_iface->soft_iface) {
+		bat_priv = netdev_priv(hard_iface->soft_iface);
+		batadv_netlink_notify_hardif(bat_priv, hard_iface);
+	}
 out:
 	batadv_hardif_put(hard_iface);

net/batman-adv/translation-table.c+24−8

 				  struct batadv_tt_global_entry *tt_global,
 				  const char *message)
 {
+	struct batadv_tt_global_entry *tt_removed_entry;
+	struct hlist_node *tt_removed_node;
 	batadv_dbg(BATADV_DBG_TT, bat_priv,
 		   "Deleting global tt entry %pM (vid: %d): %s\n",
 		   tt_global->common.addr,
 		   batadv_print_vid(tt_global->common.vid), message);
-	batadv_hash_remove(bat_priv->tt.global_hash, batadv_compare_tt,
+	tt_removed_node = batadv_hash_remove(bat_priv->tt.global_hash,
-			   batadv_choose_tt, &tt_global->common);
+					     batadv_compare_tt,
-	batadv_tt_global_entry_put(tt_global);
+					     batadv_choose_tt,
+					     &tt_global->common);
+	if (!tt_removed_node)
+		return;
+	/* drop reference of remove hash entry */
+	tt_removed_entry = hlist_entry(tt_removed_node,
+				       struct batadv_tt_global_entry,
+				       common.hash_entry);
+	batadv_tt_global_entry_put(tt_removed_entry);
 }
 /**
 			   unsigned short vid, const char *message,
 			   bool roaming)
 {
+	struct batadv_tt_local_entry *tt_removed_entry;
 	struct batadv_tt_local_entry *tt_local_entry;
 	u16 flags, curr_flags = BATADV_NO_FLAGS;
-	void *tt_entry_exists;
+	struct hlist_node *tt_removed_node;
 	tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);
 	if (!tt_local_entry)
 	 */
 	batadv_tt_local_event(bat_priv, tt_local_entry, BATADV_TT_CLIENT_DEL);
-	tt_entry_exists = batadv_hash_remove(bat_priv->tt.local_hash,
+	tt_removed_node = batadv_hash_remove(bat_priv->tt.local_hash,
 					     batadv_compare_tt,
 					     batadv_choose_tt,
 					     &tt_local_entry->common);
-	if (!tt_entry_exists)
+	if (!tt_removed_node)
 		goto out;
-	/* extra call to free the local tt entry */
+	/* drop reference of remove hash entry */
-	batadv_tt_local_entry_put(tt_local_entry);
+	tt_removed_entry = hlist_entry(tt_removed_node,
+				       struct batadv_tt_local_entry,
+				       common.hash_entry);
+	batadv_tt_local_entry_put(tt_removed_entry);
 out:
 	if (tt_local_entry)

net/bluetooth/sco.c+2−2

 	struct sock *sk = sock->sk;
 	int err = 0;
-	BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
 	if (!addr || addr_len < sizeof(struct sockaddr_sco) ||
 	    addr->sa_family != AF_BLUETOOTH)
 		return -EINVAL;
+	BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
 	lock_sock(sk);
 	if (sk->sk_state != BT_OPEN) {

net/bridge/br_input.c+14−9

 /* note: already called with rcu_read_lock */
 static int br_handle_local_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
 {
-	struct net_bridge_port *p = br_port_get_rcu(skb->dev);
 	__br_handle_local_finish(skb);
-	BR_INPUT_SKB_CB(skb)->brdev = p->br->dev;
+	/* return 1 to signal the okfn() was called so it's ok to use the skb */
-	br_pass_frame_up(skb);
+	return 1;
-	return 0;
 }
 /*
 				goto forward;
 		}
-		/* Deliver packet to local host only */
+		/* The else clause should be hit when nf_hook():
-		NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN, dev_net(skb->dev),
+		 *   - returns < 0 (drop/error)
-			NULL, skb, skb->dev, NULL, br_handle_local_finish);
+		 *   - returns = 0 (stolen/nf_queue)
-		return RX_HANDLER_CONSUMED;
+		 * Thus return 1 from the okfn() to signal the skb is ok to pass
+		 */
+		if (NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN,
+			    dev_net(skb->dev), NULL, skb, skb->dev, NULL,
+			    br_handle_local_finish) == 1) {
+			return RX_HANDLER_PASS;
+		} else {
+			return RX_HANDLER_CONSUMED;
+		}
 	}
 forward:

net/bridge/br_multicast.c+6−1

 	if (ipv4_is_local_multicast(group))
 		return 0;
+	memset(&br_group, 0, sizeof(br_group));
 	br_group.u.ip4 = group;
 	br_group.proto = htons(ETH_P_IP);
 	br_group.vid = vid;
 	own_query = port ? &port->ip4_own_query : &br->ip4_own_query;
+	memset(&br_group, 0, sizeof(br_group));
 	br_group.u.ip4 = group;
 	br_group.proto = htons(ETH_P_IP);
 	br_group.vid = vid;
 	own_query = port ? &port->ip6_own_query : &br->ip6_own_query;
+	memset(&br_group, 0, sizeof(br_group));
 	br_group.u.ip6 = *group;
 	br_group.proto = htons(ETH_P_IPV6);
 	br_group.vid = vid;
 	__br_multicast_open(br, query);
-	list_for_each_entry(port, &br->port_list, list) {
+	rcu_read_lock();
+	list_for_each_entry_rcu(port, &br->port_list, list) {
 		if (port->state == BR_STATE_DISABLED ||
 		    port->state == BR_STATE_BLOCKING)
 			continue;
 			br_multicast_enable(&port->ip6_own_query);
 #endif
 	}
+	rcu_read_unlock();
 }
 int br_multicast_toggle(struct net_bridge *br, unsigned long val)

net/bridge/br_netlink.c+1−1

@@ -1441,7 +1441,7 @@ static int br_fill_info(struct sk_buff skb, const struct net_device brdev) · 1440 unmodified lines
1441	nla_put_u8(skb, IFLA_BR_VLAN_STATS_ENABLED,	1441	nla_put_u8(skb, IFLA_BR_VLAN_STATS_ENABLED,
1442	br_opt_get(br, BROPT_VLAN_STATS_ENABLED)) \|\|	1442	br_opt_get(br, BROPT_VLAN_STATS_ENABLED)) \|\|
1443	nla_put_u8(skb, IFLA_BR_VLAN_STATS_PER_PORT,	1443	nla_put_u8(skb, IFLA_BR_VLAN_STATS_PER_PORT,
1444	br_opt_get(br, IFLA_BR_VLAN_STATS_PER_PORT)))	1444	br_opt_get(br, BROPT_VLAN_STATS_PER_PORT)))
1445	return -EMSGSIZE;	1445	return -EMSGSIZE;
1446	#endif	1446	#endif
1447	#ifdef CONFIG_BRIDGE_IGMP_SNOOPING	1447	#ifdef CONFIG_BRIDGE_IGMP_SNOOPING

net/core/datagram.c+1−1

@@ -279,7 +279,7 @@ struct sk_buff __skb_try_recv_datagram(struct sock sk, unsigned int flags, · 278 unmodified lines
279	break;	279	break;
280		280
281	sk_busy_loop(sk, flags & MSG_DONTWAIT);	281	sk_busy_loop(sk, flags & MSG_DONTWAIT);
282	} while (!skb_queue_empty(&sk->sk_receive_queue));	282	} while (sk->sk_receive_queue.prev != *last);
283		283
284	error = -EAGAIN;	284	error = -EAGAIN;
285		285

net/core/dev.c+18−2

@@ -1184,7 +1184,21 @@ int dev_change_name(struct net_device dev, const char newname) · 1183 unmodified lines
1184	BUG_ON(!dev_net(dev));	1184	BUG_ON(!dev_net(dev));
1185		1185
1186	net = dev_net(dev);	1186	net = dev_net(dev);
1187	if (dev->flags & IFF_UP)	1187
		1188	/* Some auto-enslaved devices e.g. failover slaves are
		1189	* special, as userspace might rename the device after
		1190	* the interface had been brought up and running since
		1191	* the point kernel initiated auto-enslavement. Allow
		1192	* live name change even when these slave devices are
		1193	* up and running.
		1194	*
		1195	* Typically, users of these auto-enslaving devices
		1196	* don't actually care about slave name change, as
		1197	* they are supposed to operate on master interface
		1198	* directly.
		1199	*/
		1200	if (dev->flags & IFF_UP &&
		1201	likely(!(dev->priv_flags & IFF_LIVE_RENAME_OK)))
1188	return -EBUSY;	1202	return -EBUSY;
1189		1203
1190	write_seqcount_begin(&devnet_rename_seq);	1204	write_seqcount_begin(&devnet_rename_seq);
@@ -5014,8 +5028,10 @@ static inline void __netif_receive_skb_list_ptype(struct list_head *head, · 3823 unmodified lines
5014	if (pt_prev->list_func != NULL)	5028	if (pt_prev->list_func != NULL)
5015	pt_prev->list_func(head, pt_prev, orig_dev);	5029	pt_prev->list_func(head, pt_prev, orig_dev);
5016	else	5030	else
5017	list_for_each_entry_safe(skb, next, head, list)	5031	list_for_each_entry_safe(skb, next, head, list) {
		5032	skb_list_del_init(skb);
5018	pt_prev->func(skb, skb->dev, pt_prev, orig_dev);	5033	pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
		5034	}
5019	}	5035	}
5020		5036
5021	static void __netif_receive_skb_list_core(struct list_head *head, bool pfmemalloc)	5037	static void __netif_receive_skb_list_core(struct list_head *head, bool pfmemalloc)

net/core/ethtool.c+30−16

 	WARN_ON_ONCE(!ret);
 	gstrings.len = ret;
-	data = vzalloc(array_size(gstrings.len, ETH_GSTRING_LEN));
-	if (gstrings.len && !data)
-		return -ENOMEM;
-	__ethtool_get_strings(dev, gstrings.string_set, data);
+	if (gstrings.len) {
+		data = vzalloc(array_size(gstrings.len, ETH_GSTRING_LEN));
+		if (!data)
+			return -ENOMEM;
+		__ethtool_get_strings(dev, gstrings.string_set, data);
+	} else {
+		data = NULL;
+	}
 	ret = -EFAULT;
 	if (copy_to_user(useraddr, &gstrings, sizeof(gstrings)))
 		return -EFAULT;
 	stats.n_stats = n_stats;
-	data = vzalloc(array_size(n_stats, sizeof(u64)));
-	if (n_stats && !data)
-		return -ENOMEM;
-	ops->get_ethtool_stats(dev, &stats, data);
+	if (n_stats) {
+		data = vzalloc(array_size(n_stats, sizeof(u64)));
+		if (!data)
+			return -ENOMEM;
+		ops->get_ethtool_stats(dev, &stats, data);
+	} else {
+		data = NULL;
+	}
 	ret = -EFAULT;
 	if (copy_to_user(useraddr, &stats, sizeof(stats)))
 		return -EFAULT;
 	stats.n_stats = n_stats;
-	data = vzalloc(array_size(n_stats, sizeof(u64)));
-	if (n_stats && !data)
-		return -ENOMEM;
-	if (dev->phydev && !ops->get_ethtool_phy_stats) {
+	if (n_stats) {
-		ret = phy_ethtool_get_stats(dev->phydev, &stats, data);
+		data = vzalloc(array_size(n_stats, sizeof(u64)));
-		if (ret < 0)
+		if (!data)
-			return ret;
+			return -ENOMEM;
+		if (dev->phydev && !ops->get_ethtool_phy_stats) {
+			ret = phy_ethtool_get_stats(dev->phydev, &stats, data);
+			if (ret < 0)
+				goto out;
+		} else {
+			ops->get_ethtool_phy_stats(dev, &stats, data);
+		}
 	} else {
-		ops->get_ethtool_phy_stats(dev, &stats, data);
+		data = NULL;
 	}
 	ret = -EFAULT;

net/core/failover.c+3−3

@@ -80,14 +80,14 @@ static int failover_slave_register(struct net_device *slave_dev) · 79 unmodified lines
80	goto err_upper_link;	80	goto err_upper_link;
81	}	81	}
82		82
83	slave_dev->priv_flags \|= IFF_FAILOVER_SLAVE;	83	slave_dev->priv_flags \|= (IFF_FAILOVER_SLAVE \| IFF_LIVE_RENAME_OK);

20 more lines aren’t shown here.

net/core/filter.c+5−13

This diff is large: its 39 lines aren’t shown here.

net/core/flow_dissector.c+3−1

This diff is large: its 18 lines aren’t shown here.

net/core/net-sysfs.c+5−9

This diff is large: its 26 lines aren’t shown here.

net/core/net_namespace.c+1−0

This diff is large: its 8 lines aren’t shown here.

net/core/ptp_classifier.c+4−3

This diff is large: its 14 lines aren’t shown here.

net/core/rtnetlink.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/core/skbuff.c+10−2

This diff is large: its 33 lines aren’t shown here.

net/core/sock.c+2−2

This diff is large: its 18 lines aren’t shown here.

net/dccp/feat.c+6−1

This diff is large: its 14 lines aren’t shown here.

net/dsa/tag_qca.c+10−0

This diff is large: its 19 lines aren’t shown here.

net/ipv4/fou.c+3−1

This diff is large: its 24 lines aren’t shown here.

net/ipv4/ip_gre.c+10−5

This diff is large: its 44 lines aren’t shown here.

net/ipv4/ip_input.c+3−4

This diff is large: its 31 lines aren’t shown here.

net/ipv4/ip_options.c+2−2

This diff is large: its 18 lines aren’t shown here.

net/ipv4/route.c+15−1

This diff is large: its 25 lines aren’t shown here.

net/ipv4/tcp_dctcp.c+35−46

This diff is large: its 156 lines aren’t shown here.

net/ipv4/tcp_input.c+5−5

This diff is large: its 26 lines aren’t shown here.

net/ipv4/tcp_ipv4.c+2−1

This diff is large: its 10 lines aren’t shown here.

net/ipv6/ila/ila_xlat.c+1−0

This diff is large: its 8 lines aren’t shown here.

net/ipv6/ip6_gre.c+13−7

This diff is large: its 58 lines aren’t shown here.

net/ipv6/ip6_output.c+3−1

This diff is large: its 25 lines aren’t shown here.

net/ipv6/ip6_tunnel.c+2−2

This diff is large: its 18 lines aren’t shown here.

net/ipv6/route.c+4−0

This diff is large: its 11 lines aren’t shown here.

net/ipv6/sit.c+4−0

This diff is large: its 11 lines aren’t shown here.

net/ipv6/udp.c+2−0

This diff is large: its 9 lines aren’t shown here.

net/kcm/kcmsock.c+8−8

This diff is large: its 45 lines aren’t shown here.

net/llc/af_llc.c+1−2

This diff is large: its 16 lines aren’t shown here.

net/mac80211/driver-ops.h+3−0

This diff is large: its 10 lines aren’t shown here.

net/mac80211/key.c+4−5

This diff is large: its 25 lines aren’t shown here.

net/mac80211/mesh_pathtbl.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/mac80211/rx.c+9−1

This diff is large: its 17 lines aren’t shown here.

net/mac80211/trace_msg.h+6−1

This diff is large: its 19 lines aren’t shown here.

net/mac80211/tx.c+23−30

This diff is large: its 150 lines aren’t shown here.

net/netlink/af_netlink.c+2−1

This diff is large: its 17 lines aren’t shown here.

net/netrom/af_netrom.c+54−22

This diff is large: its 124 lines aren’t shown here.

net/netrom/nr_loopback.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/netrom/nr_route.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/netrom/sysctl_net_netrom.c+4−1

This diff is large: its 14 lines aren’t shown here.

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

This diff is large: its 22 lines aren’t shown here.

net/openvswitch/flow_netlink.c+2−2

This diff is large: its 17 lines aren’t shown here.

net/rds/af_rds.c+3−0

This diff is large: its 10 lines aren’t shown here.

net/rds/bind.c+2−0

This diff is large: its 9 lines aren’t shown here.

net/rds/tcp.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/rxrpc/af_rxrpc.c+11−6

This diff is large: its 45 lines aren’t shown here.

net/rxrpc/ar-internal.h+1−0

This diff is large: its 8 lines aren’t shown here.

net/rxrpc/conn_event.c+7−4

This diff is large: its 46 lines aren’t shown here.

net/rxrpc/input.c+12−6

This diff is large: its 56 lines aren’t shown here.

net/rxrpc/peer_event.c+5−0

This diff is large: its 12 lines aren’t shown here.

net/rxrpc/sendmsg.c+12−9

This diff is large: its 43 lines aren’t shown here.

net/sched/act_sample.c+8−2

This diff is large: its 32 lines aren’t shown here.

net/sched/cls_matchall.c+5−0

This diff is large: its 12 lines aren’t shown here.

net/sched/sch_cake.c+12−1

This diff is large: its 29 lines aren’t shown here.

net/sched/sch_cbq.c+4−6

This diff is large: its 40 lines aren’t shown here.

net/sched/sch_drr.c+4−12

This diff is large: its 44 lines aren’t shown here.

net/sched/sch_hfsc.c+5−14

This diff is large: its 55 lines aren’t shown here.

net/sched/sch_htb.c+6−16

This diff is large: its 44 lines aren’t shown here.

net/sched/sch_mq.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/sched/sch_mqprio.c+1−2

This diff is large: its 10 lines aren’t shown here.

net/sched/sch_multiq.c+4−6

This diff is large: its 32 lines aren’t shown here.

net/sched/sch_prio.c+3−7

This diff is large: its 24 lines aren’t shown here.

net/sched/sch_qfq.c+2−12

This diff is large: its 35 lines aren’t shown here.

net/sched/sch_red.c+1−2

This diff is large: its 10 lines aren’t shown here.

net/sched/sch_sfb.c+1−2

This diff is large: its 10 lines aren’t shown here.

net/sched/sch_taprio.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/sched/sch_tbf.c+1−2

This diff is large: its 10 lines aren’t shown here.

net/sctp/protocol.c+1−0

This diff is large: its 8 lines aren’t shown here.

net/sctp/socket.c+2−1

This diff is large: its 10 lines aren’t shown here.

net/smc/af_smc.c+39−19

This diff is large: its 169 lines aren’t shown here.

net/smc/smc_close.c+21−4

This diff is large: its 49 lines aren’t shown here.

net/smc/smc_close.h+1−0

This diff is large: its 7 lines aren’t shown here.

net/smc/smc_ism.c+5−0

This diff is large: its 12 lines aren’t shown here.

net/smc/smc_pnet.c+2−1

This diff is large: its 10 lines aren’t shown here.

net/strparser/strparser.c+5−7

This diff is large: its 19 lines aren’t shown here.

net/sunrpc/clnt.c+13−39

This diff is large: its 201 lines aren’t shown here.

net/sunrpc/xprtrdma/verbs.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/tipc/link.c+2−0

This diff is large: its 9 lines aren’t shown here.

net/tipc/name_table.c+2−1

This diff is large: its 10 lines aren’t shown here.

net/tipc/netlink_compat.c+20−4

This diff is large: its 45 lines aren’t shown here.

net/tipc/sysctl.c+6−2

This diff is large: its 28 lines aren’t shown here.

net/tls/tls_device.c+11−1

This diff is large: its 27 lines aren’t shown here.

net/tls/tls_main.c+24−0

This diff is large: its 38 lines aren’t shown here.

net/tls/tls_sw.c+3−14

This diff is large: its 31 lines aren’t shown here.

net/wireless/nl80211.c+12−6

This diff is large: its 60 lines aren’t shown here.

net/wireless/reg.c+39−0

This diff is large: its 67 lines aren’t shown here.

net/wireless/scan.c+1−2

This diff is large: its 12 lines aren’t shown here.

net/wireless/util.c+4−2

This diff is large: its 14 lines aren’t shown here.

scripts/atomic/gen-atomics.sh+1−1

This diff is large: its 9 lines aren’t shown here.

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

This diff is large: its 364 lines aren’t shown here.

security/apparmor/lsm.c+48−1

This diff is large: its 65 lines aren’t shown here.

security/device_cgroup.c+1−1

This diff is large: its 9 lines aren’t shown here.

security/keys/trusted.c+25−7

This diff is large: its 89 lines aren’t shown here.

sound/core/info.c+10−2

This diff is large: its 27 lines aren’t shown here.

sound/core/init.c+9−9

This diff is large: its 39 lines aren’t shown here.

sound/core/seq/seq_clientmgr.c+3−3

This diff is large: its 27 lines aren’t shown here.

sound/hda/ext/hdac_ext_bus.c+0−1

This diff is large: its 8 lines aren’t shown here.

sound/hda/hdac_bus.c+1−0

This diff is large: its 8 lines aren’t shown here.

sound/hda/hdac_component.c+5−1

This diff is large: its 26 lines aren’t shown here.

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

This diff is large: its 8 lines aren’t shown here.

sound/pci/hda/hda_intel.c+4−0

This diff is large: its 18 lines aren’t shown here.

sound/pci/hda/patch_realtek.c+57−21

This diff is large: its 191 lines aren’t shown here.

sound/soc/codecs/Kconfig+1−0

This diff is large: its 8 lines aren’t shown here.

sound/soc/codecs/ab8500-codec.c+1−0

This diff is large: its 8 lines aren’t shown here.

sound/soc/codecs/cs35l35.c+11−0

This diff is large: its 25 lines aren’t shown here.

sound/soc/codecs/cs4270.c+1−0

This diff is large: its 8 lines aren’t shown here.

sound/soc/codecs/hdac_hda.c+39−14

This diff is large: its 91 lines aren’t shown here.

sound/soc/codecs/hdac_hda.h+1−0

This diff is large: its 8 lines aren’t shown here.

sound/soc/codecs/hdmi-codec.c+59−62

This diff is large: its 152 lines aren’t shown here.

sound/soc/codecs/nau8810.c+2−2

This diff is large: its 12 lines aren’t shown here.

sound/soc/codecs/nau8824.c+38−8

This diff is large: its 81 lines aren’t shown here.

sound/soc/codecs/rt5682.c+25−31

This diff is large: its 159 lines aren’t shown here.

sound/soc/codecs/tlv320aic32x4-i2c.c+2−2

This diff is large: its 16 lines aren’t shown here.

sound/soc/codecs/tlv320aic32x4-spi.c+2−2

This diff is large: its 16 lines aren’t shown here.

sound/soc/codecs/tlv320aic32x4.c+2−0

This diff is large: its 9 lines aren’t shown here.

sound/soc/codecs/tlv320aic3x.c+3−1

This diff is large: its 25 lines aren’t shown here.

sound/soc/codecs/wm_adsp.c+33−7

This diff is large: its 121 lines aren’t shown here.

sound/soc/codecs/wm_adsp.h+1−0

This diff is large: its 8 lines aren’t shown here.

sound/soc/fsl/fsl_asrc.c+14−0

This diff is large: its 28 lines aren’t shown here.

sound/soc/fsl/fsl_esai.c+37−10

This diff is large: its 96 lines aren’t shown here.

sound/soc/generic/audio-graph-card.c+8−3

This diff is large: its 39 lines aren’t shown here.

sound/soc/generic/simple-card.c+9−3

This diff is large: its 46 lines aren’t shown here.

sound/soc/intel/atom/sst-mfld-platform-pcm.c+8−0

This diff is large: its 18 lines aren’t shown here.

sound/soc/intel/boards/cht_bsw_max98090_ti.c+41−6

This diff is large: its 106 lines aren’t shown here.

sound/soc/intel/boards/kbl_rt5663_rt5514_max98927.c+1−1

This diff is large: its 9 lines aren’t shown here.

sound/soc/intel/skylake/skl-messages.c+1−0

This diff is large: its 8 lines aren’t shown here.

sound/soc/intel/skylake/skl-pcm.c+22−6

This diff is large: its 69 lines aren’t shown here.

sound/soc/mediatek/common/mtk-btcvsd.c+68−1

This diff is large: its 104 lines aren’t shown here.

sound/soc/mediatek/mt8183/mt8183-afe-clk.c+4−0

This diff is large: its 11 lines aren’t shown here.

sound/soc/rockchip/rockchip_pdm.c+3−1

This diff is large: its 19 lines aren’t shown here.

sound/soc/samsung/i2s.c+6−4

This diff is large: its 33 lines aren’t shown here.

sound/soc/samsung/odroid.c+2−2

This diff is large: its 14 lines aren’t shown here.

sound/soc/sh/rcar/core.c+2−0

This diff is large: its 9 lines aren’t shown here.

sound/soc/sh/rcar/rsnd.h+5−0

This diff is large: its 19 lines aren’t shown here.

sound/soc/sh/rcar/src.c+7−14

This diff is large: its 90 lines aren’t shown here.

sound/soc/soc-core.c+4−2

This diff is large: its 34 lines aren’t shown here.

sound/soc/soc-dapm.c+11−0

This diff is large: its 25 lines aren’t shown here.

sound/soc/soc-pcm.c+55−11

This diff is large: its 232 lines aren’t shown here.

sound/soc/soc-topology.c+4−3

This diff is large: its 15 lines aren’t shown here.

sound/soc/stm/stm32_adfsdm.c+34−4

This diff is large: its 117 lines aren’t shown here.

sound/soc/stm/stm32_i2s.c+1−2

This diff is large: its 17 lines aren’t shown here.

sound/soc/stm/stm32_sai.c+5−3

This diff is large: its 32 lines aren’t shown here.

sound/soc/stm/stm32_sai_sub.c+86−28

This diff is large: its 257 lines aren’t shown here.

sound/xen/xen_snd_front_alsa.c+1−1

This diff is large: its 9 lines aren’t shown here.

tools/include/uapi/sound/asound.h+1−0

This diff is large: its 8 lines aren’t shown here.

tools/io_uring/io_uring-bench.c+4−28

This diff is large: its 87 lines aren’t shown here.

tools/lib/bpf/Makefile+4−3

This diff is large: its 21 lines aren’t shown here.

tools/lib/bpf/btf.c+3−0

This diff is large: its 10 lines aren’t shown here.

tools/lib/traceevent/event-parse.c+1−1

This diff is large: its 9 lines aren’t shown here.

tools/objtool/check.c+1−0

This diff is large: its 8 lines aren’t shown here.

tools/perf/builtin-stat.c+1−0

This diff is large: its 8 lines aren’t shown here.

tools/perf/builtin-top.c+1−0

This diff is large: its 8 lines aren’t shown here.

tools/perf/scripts/python/export-to-sqlite.py+1−1

This diff is large: its 9 lines aren’t shown here.

tools/perf/util/env.c+6−2

This diff is large: its 27 lines aren’t shown here.

tools/perf/util/evlist.c+9−5

This diff is large: its 32 lines aren’t shown here.

tools/perf/util/evsel.c+6−6

This diff is large: its 54 lines aren’t shown here.

tools/perf/util/header.c+13−9

This diff is large: its 60 lines aren’t shown here.

tools/perf/util/map.c+17−3

This diff is large: its 35 lines aren’t shown here.

tools/perf/util/map.h+3−1

This diff is large: its 14 lines aren’t shown here.

tools/power/x86/turbostat/turbostat.c+219−58

This diff is large: its 680 lines aren’t shown here.

tools/testing/nvdimm/test/nfit.c+13−4

This diff is large: its 59 lines aren’t shown here.

tools/testing/selftests/bpf/prog_tests/flow_dissector.c+68−0

This diff is large: its 81 lines aren’t shown here.

tools/testing/selftests/bpf/progs/bpf_flow.c+7−12

This diff is large: its 62 lines aren’t shown here.

tools/testing/selftests/bpf/test_btf.c+47−0

This diff is large: its 54 lines aren’t shown here.

tools/testing/selftests/bpf/verifier/calls.c+38−0

This diff is large: its 45 lines aren’t shown here.

tools/testing/selftests/drivers/net/mlxsw/rtnetlink.sh+20−0

This diff is large: its 34 lines aren’t shown here.

tools/testing/selftests/kvm/Makefile+8−1

This diff is large: its 27 lines aren’t shown here.

tools/testing/selftests/kvm/include/x86_64/processor.h+27−0

This diff is large: its 34 lines aren’t shown here.

tools/testing/selftests/kvm/lib/kvm_util.c+5−0

This diff is large: its 12 lines aren’t shown here.

tools/testing/selftests/kvm/lib/x86_64/processor.c+14−6

This diff is large: its 39 lines aren’t shown here.

tools/testing/selftests/kvm/x86_64/evmcs_test.c+3−2

This diff is large: its 19 lines aren’t shown here.

tools/testing/selftests/kvm/x86_64/smm_test.c+157−0

This diff is large: its 158 lines aren’t shown here.

tools/testing/selftests/kvm/x86_64/state_test.c+1−14

This diff is large: its 32 lines aren’t shown here.

tools/testing/selftests/net/fib_tests.sh+40−54

This diff is large: its 142 lines aren’t shown here.

tools/testing/selftests/proc/proc-pid-vm.c+2−2

This diff is large: its 11 lines aren’t shown here.

tools/testing/selftests/proc/proc-self-map-files-002.c+10−10

This diff is large: its 34 lines aren’t shown here.

tools/testing/selftests/tc-testing/tc-tests/actions/sample.json+24−0

This diff is large: its 31 lines aren’t shown here.

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

This diff is large: its 27 lines aren’t shown here.

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

This diff is large: its 20 lines aren’t shown here.

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

This diff is large: its 70 lines aren’t shown here.

virt/kvm/irqchip.c+3−2

This diff is large: its 22 lines aren’t shown here.

virt/kvm/kvm_main.c+4−2

This diff is large: its 25 lines aren’t shown here.