lael-labs/linux

Documentation/admin-guide/sysctl/net.rst+1−28

@@ -39,7 +39,6 @@ Table : Subdirectories in /proc/sys/net · 38 unmodified lines
39	802 E802 protocol ax25 AX25	39	802 E802 protocol ax25 AX25
40	ethernet Ethernet protocol rose X.25 PLP layer	40	ethernet Ethernet protocol rose X.25 PLP layer
41	ipv4 IP version 4 x25 X.25 protocol	41	ipv4 IP version 4 x25 X.25 protocol
42	ipx IPX token-ring IBM token ring
43	bridge Bridging decnet DEC net	42	bridge Bridging decnet DEC net
44	ipv6 IP version 6 tipc TIPC	43	ipv6 IP version 6 tipc TIPC
45	========= =================== = ========== ==================	44	========= =================== = ========== ==================
@@ -401,33 +400,7 @@ interface. · 355 unmodified lines
401	(network) that the route leads to, the router (may be directly connected), the	400	(network) that the route leads to, the router (may be directly connected), the
402	route flags, and the device the route is using.	401	route flags, and the device the route is using.
403		402
404		403	5. TIPC
405	5. IPX
406	------
407
408	The IPX protocol has no tunable values in proc/sys/net.
409
410	The IPX protocol does, however, provide proc/net/ipx. This lists each IPX
411	socket giving the local and remote addresses in Novell format (that is
412	network:node:port). In accordance with the strange Novell tradition,
413	everything but the port is in hex. Not_Connected is displayed for sockets that
414	are not tied to a specific remote address. The Tx and Rx queue sizes indicate
415	the number of bytes pending for transmission and reception. The state
416	indicates the state the socket is in and the uid is the owning uid of the
417	socket.
418
419	The /proc/net/ipx_interface file lists all IPX interfaces. For each interface
420	it gives the network number, the node number, and indicates if the network is
421	the primary network. It also indicates which device it is bound to (or
422	Internal for internal networks) and the Frame Type if appropriate. Linux
423	supports 802.3, 802.2, 802.2 SNAP and DIX (Blue Book) ethernet framing for
424	IPX.
425
426	The /proc/net/ipx_route table holds a list of IPX routes. For each route it
427	gives the destination network, the router node (or Directly) and the network
428	address of the router (or Connected) for internal networks.
429
430	6. TIPC
431	-------	404	-------
432		405
433	tipc_rmem	406	tipc_rmem

Documentation/devicetree/bindings/Makefile+3−1

@@ -19,7 +19,9 @@ quiet_cmd_mk_schema = SCHEMA $@ · 18 unmodified lines
19		19
20	DT_DOCS = $(shell \	20	DT_DOCS = $(shell \
21	cd $(srctree)/$(src) && \	21	cd $(srctree)/$(src) && \
22	find * $ -name '*.yaml' ! -name $(DT_TMP_SCHEMA) $ \	22	find * \( -name '*.yaml' ! \
		23	-name $(DT_TMP_SCHEMA) ! \
		24	-name '*.example.dt.yaml' \) \
23	)	25	)
24		26
25	DT_SCHEMA_FILES ?= $(addprefix $(src)/,$(DT_DOCS))	27	DT_SCHEMA_FILES ?= $(addprefix $(src)/,$(DT_DOCS))

Documentation/devicetree/bindings/net/fsl-fec.txt+17−13

 - phy-mode : See ethernet.txt file in the same directory
 Optional properties:
-- phy-reset-gpios : Should specify the gpio for phy reset
-- phy-reset-duration : Reset duration in milliseconds.  Should present
-  only if property "phy-reset-gpios" is available.  Missing the property
-  will have the duration be 1 millisecond.  Numbers greater than 1000 are
-  invalid and 1 millisecond will be used instead.
-- phy-reset-active-high : If present then the reset sequence using the GPIO
-  specified in the "phy-reset-gpios" property is reversed (H=reset state,
-  L=operation state).
-- phy-reset-post-delay : Post reset delay in milliseconds. If present then
-  a delay of phy-reset-post-delay milliseconds will be observed after the
-  phy-reset-gpios has been toggled. Can be omitted thus no delay is
-  observed. Delay is in range of 1ms to 1000ms. Other delays are invalid.
 - phy-supply : regulator that powers the Ethernet PHY.
 - phy-handle : phandle to the PHY device connected to this device.
 - fixed-link : Assume a fixed link. See fixed-link.txt in the same directory.
   For imx6sx, "int0" handles all 3 queues and ENET_MII. "pps" is for the pulse
   per second interrupt associated with 1588 precision time protocol(PTP).
 Optional subnodes:
 - mdio : specifies the mdio bus in the FEC, used as a container for phy nodes
   according to phy.txt in the same directory
+Deprecated optional properties:
+	To avoid these, create a phy node according to phy.txt in the same
+	directory, and point the fec's "phy-handle" property to it. Then use
+	the phy's reset binding, again described by phy.txt.
+- phy-reset-gpios : Should specify the gpio for phy reset
+- phy-reset-duration : Reset duration in milliseconds.  Should present
+  only if property "phy-reset-gpios" is available.  Missing the property
+  will have the duration be 1 millisecond.  Numbers greater than 1000 are
+  invalid and 1 millisecond will be used instead.
+- phy-reset-active-high : If present then the reset sequence using the GPIO
+  specified in the "phy-reset-gpios" property is reversed (H=reset state,
+  L=operation state).
+- phy-reset-post-delay : Post reset delay in milliseconds. If present then
+  a delay of phy-reset-post-delay milliseconds will be observed after the
+  phy-reset-gpios has been toggled. Can be omitted thus no delay is
+  observed. Delay is in range of 1ms to 1000ms. Other delays are invalid.
 Example:
 ethernet@83fec000 {

Documentation/devicetree/bindings/pinctrl/st,stm32-pinctrl.yaml+2−1

@@ -37,7 +37,8 @@ properties: · 36 unmodified lines
37	hwlocks: true	37	hwlocks: true
38		38
39	st,syscfg:	39	st,syscfg:
40	$ref: "/schemas/types.yaml#/definitions/phandle-array"	40	allOf:
		41	- $ref: "/schemas/types.yaml#/definitions/phandle-array"
41	description: Should be phandle/offset/mask	42	description: Should be phandle/offset/mask
42	items:	43	items:
43	- description: Phandle to the syscon node which includes IRQ mux selection.	44	- description: Phandle to the syscon node which includes IRQ mux selection.

Documentation/devicetree/bindings/riscv/cpus.txt+0−162

@@ -1,162 +0,0 @@
1	===================
2	RISC-V CPU Bindings
3	===================
4
5	The device tree allows to describe the layout of CPUs in a system through
6	the "cpus" node, which in turn contains a number of subnodes (ie "cpu")
7	defining properties for every cpu.
8
9	Bindings for CPU nodes follow the Devicetree Specification, available from:
10
11	https://www.devicetree.org/specifications/
12
13	with updates for 32-bit and 64-bit RISC-V systems provided in this document.
14
15	===========
16	Terminology
17	===========
18
19	This document uses some terminology common to the RISC-V community that is not
20	widely used, the definitions of which are listed here:
21
22	* hart: A hardware execution context, which contains all the state mandated by
23	the RISC-V ISA: a PC and some registers. This terminology is designed to
24	disambiguate software's view of execution contexts from any particular
25	microarchitectural implementation strategy. For example, my Intel laptop is
26	described as having one socket with two cores, each of which has two hyper
27	threads. Therefore this system has four harts.
28
29	=====================================
30	cpus and cpu node bindings definition
31	=====================================
32
33	The RISC-V architecture, in accordance with the Devicetree Specification,
34	requires the cpus and cpu nodes to be present and contain the properties
35	described below.
36
37	- cpus node
38
39	Description: Container of cpu nodes
40
41	The node name must be "cpus".
42
43	A cpus node must define the following properties:
44
45	- #address-cells
46	Usage: required
47	Value type: <u32>
48	Definition: must be set to 1
49	- #size-cells
50	Usage: required
51	Value type: <u32>
52	Definition: must be set to 0
53
54	- cpu node
55
56	Description: Describes a hart context
57
58	PROPERTIES
59
60	- device_type
61	Usage: required
62	Value type: <string>
63	Definition: must be "cpu"
64	- reg
65	Usage: required
66	Value type: <u32>
67	Definition: The hart ID of this CPU node
68	- compatible:
69	Usage: required
70	Value type: <stringlist>
71	Definition: must contain "riscv", may contain one of
72	"sifive,rocket0"
73	- mmu-type:
74	Usage: optional
75	Value type: <string>
76	Definition: Specifies the CPU's MMU type. Possible values are
77	"riscv,sv32"
78	"riscv,sv39"
79	"riscv,sv48"
80	- riscv,isa:
81	Usage: required
82	Value type: <string>
83	Definition: Contains the RISC-V ISA string of this hart. These
84	ISA strings are defined by the RISC-V ISA manual.
85
86	Example: SiFive Freedom U540G Development Kit
87	---------------------------------------------
88
89	This system contains two harts: a hart marked as disabled that's used for
90	low-level system tasks and should be ignored by Linux, and a second hart that
91	Linux is allowed to run on.
92
93	cpus {
94	#address-cells = <1>;
95	#size-cells = <0>;
96	timebase-frequency = <1000000>;
97	cpu@0 {
98	clock-frequency = <1600000000>;
99	compatible = "sifive,rocket0", "riscv";
100	device_type = "cpu";
101	i-cache-block-size = <64>;
102	i-cache-sets = <128>;
103	i-cache-size = <16384>;
104	next-level-cache = <&L15 &L0>;
105	reg = <0>;
106	riscv,isa = "rv64imac";
107	status = "disabled";
108	L10: interrupt-controller {
109	#interrupt-cells = <1>;
110	compatible = "riscv,cpu-intc";
111	interrupt-controller;
112	};
113	};
114	cpu@1 {
115	clock-frequency = <1600000000>;
116	compatible = "sifive,rocket0", "riscv";
117	d-cache-block-size = <64>;
118	d-cache-sets = <64>;
119	d-cache-size = <32768>;
120	d-tlb-sets = <1>;
121	d-tlb-size = <32>;
122	device_type = "cpu";
123	i-cache-block-size = <64>;
124	i-cache-sets = <64>;
125	i-cache-size = <32768>;
126	i-tlb-sets = <1>;
127	i-tlb-size = <32>;
128	mmu-type = "riscv,sv39";
129	next-level-cache = <&L15 &L0>;
130	reg = <1>;
131	riscv,isa = "rv64imafdc";
132	status = "okay";
133	tlb-split;
134	L13: interrupt-controller {
135	#interrupt-cells = <1>;
136	compatible = "riscv,cpu-intc";
137	interrupt-controller;
138	};
139	};
140	};
141
142	Example: Spike ISA Simulator with 1 Hart
143	----------------------------------------
144
145	This device tree matches the Spike ISA golden model as run with `spike -p1`.
146
147	cpus {
148	cpu@0 {
149	device_type = "cpu";
150	reg = <0x00000000>;
151	status = "okay";
152	compatible = "riscv";
153	riscv,isa = "rv64imafdc";
154	mmu-type = "riscv,sv48";
155	clock-frequency = <0x3b9aca00>;
156	interrupt-controller {
157	#interrupt-cells = <0x00000001>;
158	interrupt-controller;
159	compatible = "riscv,cpu-intc";
160	}
161	}
162	}

Documentation/devicetree/bindings/riscv/cpus.yaml+16−0

@@ -10,6 +10,18 @@ maintainers: · 9 unmodified lines
10	- Paul Walmsley <paul.walmsley@sifive.com>	10	- Paul Walmsley <paul.walmsley@sifive.com>
11	- Palmer Dabbelt <palmer@sifive.com>	11	- Palmer Dabbelt <palmer@sifive.com>
12		12
		13	description: \|
		14	This document uses some terminology common to the RISC-V community
		15	that is not widely used, the definitions of which are listed here:
		16
		17	hart: A hardware execution context, which contains all the state
		18	mandated by the RISC-V ISA: a PC and some registers. This
		19	terminology is designed to disambiguate software's view of execution
		20	contexts from any particular microarchitectural implementation
		21	strategy. For example, an Intel laptop containing one socket with
		22	two cores, each of which has two hyperthreads, could be described as
		23	having four harts.
		24
13	properties:	25	properties:
14	compatible:	26	compatible:
15	items:	27	items:
@@ -50,6 +62,10 @@ properties: · 34 unmodified lines
50	User-Level ISA document, available from	62	User-Level ISA document, available from
51	https://riscv.org/specifications/	63	https://riscv.org/specifications/
52		64
		65	While the isa strings in ISA specification are case
		66	insensitive, letters in the riscv,isa string must be all
		67	lowercase to simplify parsing.
		68
53	timebase-frequency:	69	timebase-frequency:
54	type: integer	70	type: integer
55	minimum: 1	71	minimum: 1

Documentation/devicetree/bindings/riscv/sifive.yaml+1−1

@@ -19,7 +19,7 @@ properties: · 18 unmodified lines
19	compatible:	19	compatible:
20	items:	20	items:
21	- enum:	21	- enum:
22	- sifive,freedom-unleashed-a00	22	- sifive,hifive-unleashed-a00
23	- const: sifive,fu540-c000	23	- const: sifive,fu540-c000
24	- const: sifive,fu540	24	- const: sifive,fu540
25	...	25	...

Documentation/filesystems/cifs/TODO+16−10

    - T10 copy offload ie "ODX" (copy chunk, and "Duplicate Extents" ioctl
      currently the only two server side copy mechanisms supported)
-b) improved sparse file support
+b) improved sparse file support (fiemap and SEEK_HOLE are implemented
+but additional features would be supportable by the protocol).
 c) Directory entry caching relies on a 1 second timer, rather than
 using Directory Leases, currently only the root file handle is cached longer
 d) quota support (needs minor kernel change since quota calls
 to make it to network filesystems or deviceless filesystems)
-e) Additional use cases where we use "compoounding" (e.g. open/query/close
+e) Additional use cases can be optimized to use "compounding"
-and open/setinfo/close) to reduce the number of roundtrips, and also
+(e.g. open/query/close and open/setinfo/close) to reduce the number
-open to reduce redundant opens (using deferred close and reference counts more).
+of roundtrips to the server and improve performance. Various cases
+(stat, statfs, create, unlink, mkdir) already have been improved by
+using compounding but more can be done.  In addition we could significantly
+reduce redundant opens by using deferred close (with handle caching leases)
+and better using reference counters on file handles.
 f) Finish inotify support so kde and gnome file list windows
 will autorefresh (partially complete by Asser). Needs minor kernel
 exists. Also better integration with winbind for resolving SID owners
 k) Add tools to take advantage of more smb3 specific ioctls and features
-(passthrough ioctl/fsctl for sending various SMB3 fsctls to the server
+(passthrough ioctl/fsctl is now implemented in cifs.ko to allow sending
-is in progress, and a passthrough query_info call is already implemented
+various SMB3 fsctls and query info and set info calls directly from user space)
-in cifs.ko to allow smb3 info levels queries to be sent from userspace)
+Add tools to make setting various non-POSIX metadata attributes easier
+from tools (e.g. extending what was done in smb-info tool).
 l) encrypted file support
 m) improved stats gathering tools (perhaps integration with nfsometer?)
 to extend and make easier to use what is currently in /proc/fs/cifs/Stats
-n) allow setting more NTFS/SMB3 file attributes remotely (currently limited to compressed
+n) Add support for claims based ACLs ("DAC")
-file attribute via chflags) and improve user space tools for managing and
-viewing them.
 o) mount helper GUI (to simplify the various configuration options on mount)
 w) Add support for additional strong encryption types, and additional spnego
 authentication mechanisms (see MS-SMB2)
+x) Finish support for SMB3.1.1 compression
 KNOWN BUGS
 ====================================
 See http://bugzilla.samba.org - search on product "CifsVFS" for

Documentation/networking/tls-offload.rst+0−18

@@ -506,21 +506,3 @@ Drivers should ignore the changes to TLS the device feature flags. · 505 unmodified lines
506	These flags will be acted upon accordingly by the core ``ktls`` code.	506	These flags will be acted upon accordingly by the core ``ktls`` code.
507	TLS device feature flags only control adding of new TLS connection	507	TLS device feature flags only control adding of new TLS connection
508	offloads, old connections will remain active after flags are cleared.	508	offloads, old connections will remain active after flags are cleared.
509
510	Known bugs
511	==========
512
513	skb_orphan() leaks clear text
514	-----------------------------
515
516	Currently drivers depend on the :c:member:`sk` member of
517	:c:type:`struct sk_buff <sk_buff>` to identify segments requiring
518	encryption. Any operation which removes or does not preserve the socket
519	association such as :c:func:`skb_orphan` or :c:func:`skb_clone`
520	will cause the driver to miss the packets and lead to clear text leaks.
521
522	Redirects leak clear text
523	-------------------------
524
525	In the RX direction, if segment has already been decrypted by the device
526	and it gets redirected or mirrored - clear text will be transmitted out.

Documentation/networking/tuntap.txt+2−2

@@ -204,8 +204,8 @@ Ethernet device, which instead of receiving packets from a physical · 203 unmodified lines
204	media, receives them from user space program and instead of sending	204	media, receives them from user space program and instead of sending
205	packets via physical media sends them to the user space program.	205	packets via physical media sends them to the user space program.
206		206
207	Let's say that you configured IPX on the tap0, then whenever	207	Let's say that you configured IPv6 on the tap0, then whenever
208	the kernel sends an IPX packet to tap0, it is passed to the application	208	the kernel sends an IPv6 packet to tap0, it is passed to the application
209	(VTun for example). The application encrypts, compresses and sends it to	209	(VTun for example). The application encrypts, compresses and sends it to
210	the other side over TCP or UDP. The application on the other side decompresses	210	the other side over TCP or UDP. The application on the other side decompresses
211	and decrypts the data received and writes the packet to the TAP device,	211	and decrypts the data received and writes the packet to the TAP device,

MAINTAINERS+22−7

 M:	Heiner Kallweit <hkallweit1@gmail.com>
 L:	netdev@vger.kernel.org
 S:	Maintained
-F:	drivers/net/ethernet/realtek/r8169.c
+F:	drivers/net/ethernet/realtek/r8169*
 8250/16?50 (AND CLONE UARTS) SERIAL DRIVER
 M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
 M:	Heiner Kallweit <hkallweit1@gmail.com>
 L:	netdev@vger.kernel.org
 S:	Maintained
-F:	Documentation/ABI/testing/sysfs-bus-mdio
+F:	Documentation/ABI/testing/sysfs-class-net-phydev
 F:	Documentation/devicetree/bindings/net/ethernet-phy.yaml
 F:	Documentation/devicetree/bindings/net/mdio*
 F:	Documentation/networking/phy.rst
 M:	Moritz Fischer <mdf@kernel.org>
 L:	linux-fpga@vger.kernel.org
 S:	Maintained
-T:	git git://git.kernel.org/pub/scm/linux/kernel/git/atull/linux-fpga.git
+T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mdf/linux-fpga.git
 Q:	http://patchwork.kernel.org/project/linux-fpga/list/
 F:	Documentation/fpga/
 F:	Documentation/driver-api/fpga/
 M:	Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
 L:	dri-devel@lists.freedesktop.org
 L:	linux-fbdev@vger.kernel.org
-T:	git git://github.com/bzolnier/linux.git
+T:	git git://anongit.freedesktop.org/drm/drm-misc
 Q:	http://patchwork.kernel.org/project/linux-fbdev/list/
 S:	Maintained
 F:	Documentation/fb/
 F:	drivers/perf/fsl_imx8_ddr_perf.c
 F:	Documentation/devicetree/bindings/perf/fsl-imx-ddr.txt
+FREESCALE IMX I2C DRIVER
+M:	Oleksij Rempel <o.rempel@pengutronix.de>
+R:	Pengutronix Kernel Team <kernel@pengutronix.de>
+L:	linux-i2c@vger.kernel.org
+S:	Maintained
+F:	drivers/i2c/busses/i2c-imx.c
+F:	Documentation/devicetree/bindings/i2c/i2c-imx.txt
 FREESCALE IMX LPI2C DRIVER
 M:	Dong Aisheng <aisheng.dong@nxp.com>
 L:	linux-i2c@vger.kernel.org
 F:	drivers/scsi/storvsc_drv.c
 F:	drivers/uio/uio_hv_generic.c
 F:	drivers/video/fbdev/hyperv_fb.c
-F:	drivers/iommu/hyperv_iommu.c
+F:	drivers/iommu/hyperv-iommu.c
 F:	net/vmw_vsock/hyperv_transport.c
 F:	include/clocksource/hyperv_timer.h
 F:	include/linux/hyperv.h
 F:	drivers/video/fbdev/i810/
 INTEL ASoC DRIVERS
+M:	Cezary Rojewski <cezary.rojewski@intel.com>
 M:	Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
 M:	Liam Girdwood <liam.r.girdwood@linux.intel.com>
 M:	Jie Yang <yang.jie@linux.intel.com>
 S:	Supported
 F:	drivers/scsi/isci/
+INTEL CPU family model numbers
+M:	Tony Luck <tony.luck@intel.com>
+M:	x86@kernel.org
+L:	linux-kernel@vger.kernel.org
+S:	Supported
+F:	arch/x86/include/asm/intel-family.h
 INTEL DRM DRIVERS (excluding Poulsbo, Moorestown and derivative chipsets)
 M:	Jani Nikula <jani.nikula@linux.intel.com>
 M:	Joonas Lahtinen <joonas.lahtinen@linux.intel.com>
 L:	linux-fsdevel@vger.kernel.org
 T:	git git://git.kernel.org/pub/scm/fs/xfs/xfs-linux.git
 S:	Supported
-F:	fs/iomap.c
 F:	fs/iomap/
 F:	include/linux/iomap.h
 F:	drivers/net/ethernet/ti/netcp*
 TI PCM3060 ASoC CODEC DRIVER
-M:	Kirill Marinushkin <kmarinushkin@birdec.tech>
+M:	Kirill Marinushkin <kmarinushkin@birdec.com>
 L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
 S:	Maintained
 F:	Documentation/devicetree/bindings/sound/pcm3060.txt

Makefile+18−6

 VERSION = 5
 PATCHLEVEL = 3
 SUBLEVEL = 0
-EXTRAVERSION = -rc3
+EXTRAVERSION = -rc5
 NAME = Bobtail Squid
 # *DOCUMENTATION*
 STRIP		= $(CROSS_COMPILE)strip
 OBJCOPY		= $(CROSS_COMPILE)objcopy
 OBJDUMP		= $(CROSS_COMPILE)objdump
+OBJSIZE		= $(CROSS_COMPILE)size
 PAHOLE		= pahole
 LEX		= flex
 YACC		= bison
 CLANG_FLAGS :=
 export ARCH SRCARCH CONFIG_SHELL HOSTCC KBUILD_HOSTCFLAGS CROSS_COMPILE AS LD CC
-export CPP AR NM STRIP OBJCOPY OBJDUMP PAHOLE KBUILD_HOSTLDFLAGS KBUILD_HOSTLDLIBS
+export CPP AR NM STRIP OBJCOPY OBJDUMP OBJSIZE PAHOLE LEX YACC AWK INSTALLKERNEL
-export MAKE LEX YACC AWK INSTALLKERNEL PERL PYTHON PYTHON2 PYTHON3 UTS_MACHINE
+export PERL PYTHON PYTHON2 PYTHON3 CHECK CHECKFLAGS MAKE UTS_MACHINE HOSTCXX
-export HOSTCXX KBUILD_HOSTCXXFLAGS LDFLAGS_MODULE CHECK CHECKFLAGS
+export KBUILD_HOSTCXXFLAGS KBUILD_HOSTLDFLAGS KBUILD_HOSTLDLIBS LDFLAGS_MODULE
 export KBUILD_CPPFLAGS NOSTDINC_FLAGS LINUXINCLUDE OBJCOPYFLAGS KBUILD_LDFLAGS
 export KBUILD_CFLAGS CFLAGS_KERNEL CFLAGS_MODULE
 KBUILD_CFLAGS += -Wdeclaration-after-statement
 # Warn about unmarked fall-throughs in switch statement.
-KBUILD_CFLAGS += $(call cc-option,-Wimplicit-fallthrough=3,)
+KBUILD_CFLAGS += $(call cc-option,-Wimplicit-fallthrough,)
 # Variable Length Arrays (VLAs) should not be used anywhere in the kernel
 KBUILD_CFLAGS += -Wvla
 PHONY += prepare0
+export MODORDER := $(if $(KBUILD_EXTMOD),$(KBUILD_EXTMOD)/)modules.order
 ifeq ($(KBUILD_EXTMOD),)
 core-y		+= kernel/ certs/ mm/ fs/ ipc/ security/ crypto/ block/
 	$(Q)$(MAKE) $(build)=$(build-dir) $(build-target)
 %.symtypes: prepare FORCE
 	$(Q)$(MAKE) $(build)=$(build-dir) $(build-target)
+ifeq ($(KBUILD_EXTMOD),)
+# For the single build of an in-tree module, use a temporary file to avoid
+# the situation of modules_install installing an invalid modules.order.
+%.ko: MODORDER := .modules.tmp
+endif
+%.ko: prepare FORCE
+	$(Q)$(MAKE) $(build)=$(build-dir) $(build-target:.ko=.mod)
+	$(Q)echo $(build-target) > $(MODORDER)
+	$(Q)$(MAKE) -f $(srctree)/scripts/Makefile.modpost
 # Modules
 PHONY += /
 /: ./
 %/: prepare FORCE
-	$(Q)$(MAKE) KBUILD_MODULES=1 $(build)=$(build-dir)
+	$(Q)$(MAKE) KBUILD_MODULES=1 $(build)=$(build-dir) need-modorder=1
 # FIXME Should go into a make.lib or something
 # ===========================================================================

arch/arm/kernel/hw_breakpoint.c+5−0

 		if ((hw->ctrl.type != ARM_BREAKPOINT_EXECUTE)
 			&& max_watchpoint_len >= 8)
 			break;
+		/* Else, fall through */
 	default:
 		return -EINVAL;
 	}
 		/* Allow halfword watchpoints and breakpoints. */
 		if (hw->ctrl.len == ARM_BREAKPOINT_LEN_2)
 			break;
+		/* Else, fall through */
 	case 3:
 		/* Allow single byte watchpoint. */
 		if (hw->ctrl.len == ARM_BREAKPOINT_LEN_1)
 			break;
+		/* Else, fall through */
 	default:
 		ret = -EINVAL;
 		goto out;
 		break;
 	case ARM_ENTRY_ASYNC_WATCHPOINT:
 		WARN(1, "Asynchronous watchpoint exception taken. Debugging results may be unreliable\n");
+		/* Fall through */
 	case ARM_ENTRY_SYNC_WATCHPOINT:
 		watchpoint_handler(addr, fsr, regs);
 		break;
 		ARM_DBG_READ(c1, c1, 4, oslsr);
 		if (oslsr & ARM_OSLSR_OSLM0)
 			return true;
+		/* Else, fall through */
 	default:
 		return false;
 	}

arch/arm/kernel/signal.c+1−0

@@ -596,6 +596,7 @@ static int do_signal(struct pt_regs *regs, int syscall) · 595 unmodified lines
596	switch (retval) {	596	switch (retval) {
597	case -ERESTART_RESTARTBLOCK:	597	case -ERESTART_RESTARTBLOCK:
598	restart -= 2;	598	restart -= 2;
		599	/* Fall through */
599	case -ERESTARTNOHAND:	600	case -ERESTARTNOHAND:
600	case -ERESTARTSYS:	601	case -ERESTARTSYS:
601	case -ERESTARTNOINTR:	602	case -ERESTARTNOINTR:

arch/arm/kvm/coproc.c+15−8

@@ -651,13 +651,22 @@ int kvm_handle_cp14_64(struct kvm_vcpu vcpu, struct kvm_run run) · 650 unmodified lines
651	}	651	}
652		652
653	static void reset_coproc_regs(struct kvm_vcpu *vcpu,	653	static void reset_coproc_regs(struct kvm_vcpu *vcpu,
654	const struct coproc_reg *table, size_t num)	654	const struct coproc_reg *table, size_t num,
		655	unsigned long *bmap)
655	{	656	{
656	unsigned long i;	657	unsigned long i;
657		658
658	for (i = 0; i < num; i++)	659	for (i = 0; i < num; i++)
659	if (table[i].reset)	660	if (table[i].reset) {
		661	int reg = table[i].reg;
		662
660	table[i].reset(vcpu, &table[i]);	663	table[i].reset(vcpu, &table[i]);
		664	if (reg > 0 && reg < NR_CP15_REGS) {
		665	set_bit(reg, bmap);
		666	if (table[i].is_64bit)
		667	set_bit(reg + 1, bmap);
		668	}
		669	}
661	}	670	}
662		671
663	static struct coproc_params decode_32bit_hsr(struct kvm_vcpu *vcpu)	672	static struct coproc_params decode_32bit_hsr(struct kvm_vcpu *vcpu)
@@ -1432,17 +1441,15 @@ void kvm_reset_coprocs(struct kvm_vcpu *vcpu) · 768 unmodified lines
1432	{	1441	{
1433	size_t num;	1442	size_t num;
1434	const struct coproc_reg *table;	1443	const struct coproc_reg *table;
1435		1444	DECLARE_BITMAP(bmap, NR_CP15_REGS) = { 0, };
1436	/* Catch someone adding a register without putting in reset entry. */
1437	memset(vcpu->arch.ctxt.cp15, 0x42, sizeof(vcpu->arch.ctxt.cp15));
1438		1445
1439	/* Generic chip reset first (so target could override). */	1446	/* Generic chip reset first (so target could override). */
1440	reset_coproc_regs(vcpu, cp15_regs, ARRAY_SIZE(cp15_regs));	1447	reset_coproc_regs(vcpu, cp15_regs, ARRAY_SIZE(cp15_regs), bmap);
1441		1448
1442	table = get_target_table(vcpu->arch.target, &num);	1449	table = get_target_table(vcpu->arch.target, &num);
1443	reset_coproc_regs(vcpu, table, num);	1450	reset_coproc_regs(vcpu, table, num, bmap);
1444		1451
1445	for (num = 1; num < NR_CP15_REGS; num++)	1452	for (num = 1; num < NR_CP15_REGS; num++)
1446	WARN(vcpu_cp15(vcpu, num) == 0x42424242,	1453	WARN(!test_bit(num, bmap),
1447	"Didn't reset vcpu_cp15(vcpu, %zi)", num);	1454	"Didn't reset vcpu_cp15(vcpu, %zi)", num);
1448	}	1455	}

arch/arm/mach-ep93xx/crunch.c+1−0

@@ -49,6 +49,7 @@ static int crunch_do(struct notifier_block self, unsigned long cmd, void t) · 48 unmodified lines
49	* FALLTHROUGH: Ensure we don't try to overwrite our newly	49	* FALLTHROUGH: Ensure we don't try to overwrite our newly
50	* initialised state information on the first fault.	50	* initialised state information on the first fault.
51	*/	51	*/
		52	/* Fall through */
52		53
53	case THREAD_NOTIFY_EXIT:	54	case THREAD_NOTIFY_EXIT:
54	crunch_task_release(thread);	55	crunch_task_release(thread);

arch/arm/mach-tegra/reset.c+1−1

@@ -70,7 +70,7 @@ static void __init tegra_cpu_reset_handler_enable(void) · 69 unmodified lines
70	switch (err) {	70	switch (err) {
71	case -ENOSYS:	71	case -ENOSYS:
72	tegra_cpu_reset_handler_set(reset_address);	72	tegra_cpu_reset_handler_set(reset_address);
73	/* pass-through */	73	/* fall through */
74	case 0:	74	case 0:
75	is_enabled = true;	75	is_enabled = true;
76	break;	76	break;

arch/arm/mm/alignment.c+3−1

 			return subset[(L<<1) | ((tinstr & (1<<8)) >> 8)] |
 			    (tinstr & 255);		/* register_list */
 		}
-		/* Else fall through for illegal instruction case */
+		/* Else, fall through - for illegal instruction case */
 	default:
 		return BAD_INSTR;
 	case 0xe8e0:
 	case 0xe9e0:
 		poffset->un = (tinst2 & 0xff) << 2;
+		/* Fall through */
 	case 0xe940:
 	case 0xe9c0:
 		return do_alignment_ldrdstrd;

arch/arm/mm/dma-mapping.c+1−3

 pgprot_t arch_dma_mmap_pgprot(struct device *dev, pgprot_t prot,
 		unsigned long attrs)
 {
-	if (!dev_is_dma_coherent(dev))
+	return __get_dma_pgprot(attrs, prot);
-		return __get_dma_pgprot(attrs, prot);
-	return prot;
 }
 void *arch_dma_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle,

arch/arm/plat-omap/dma.c+5−9

 		/*
 		 * not supported by current hardware on OMAP1
 		 * w |= (0x03 << 7);
-		 * fall through
 		 */
+		/* fall through */
 	case OMAP_DMA_DATA_BURST_16:
 		if (dma_omap2plus()) {
 			burst = 0x3;
 			break;
 		}
-		/*
+		/* OMAP1 don't support burst 16 */
-		 * OMAP1 don't support burst 16
+		/* fall through */
-		 * fall through
-		 */
 	default:
 		BUG();
 	}
 			burst = 0x3;
 			break;
 		}
-		/*
+		/* OMAP1 don't support burst 16 */
-		 * OMAP1 don't support burst 16
+		/* fall through */
-		 * fall through
-		 */
 	default:
 		printk(KERN_ERR "Invalid DMA burst mode\n");
 		BUG();

arch/arm64/include/asm/kvm_arm.h+4−3

 #define kvm_arm_exception_class \
 	ECN(UNKNOWN), ECN(WFx), ECN(CP15_32), ECN(CP15_64), ECN(CP14_MR), \
-	ECN(CP14_LS), ECN(FP_ASIMD), ECN(CP10_ID), ECN(CP14_64), ECN(SVC64), \
+	ECN(CP14_LS), ECN(FP_ASIMD), ECN(CP10_ID), ECN(PAC), ECN(CP14_64), \
-	ECN(HVC64), ECN(SMC64), ECN(SYS64), ECN(IMP_DEF), ECN(IABT_LOW), \
+	ECN(SVC64), ECN(HVC64), ECN(SMC64), ECN(SYS64), ECN(SVE), \
-	ECN(IABT_CUR), ECN(PC_ALIGN), ECN(DABT_LOW), ECN(DABT_CUR), \
+	ECN(IMP_DEF), ECN(IABT_LOW), ECN(IABT_CUR), \
+	ECN(PC_ALIGN), ECN(DABT_LOW), ECN(DABT_CUR), \
 	ECN(SP_ALIGN), ECN(FP_EXC32), ECN(FP_EXC64), ECN(SERROR), \
 	ECN(BREAKPT_LOW), ECN(BREAKPT_CUR), ECN(SOFTSTP_LOW), \
 	ECN(SOFTSTP_CUR), ECN(WATCHPT_LOW), ECN(WATCHPT_CUR), \

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

 static inline pte_t pte_mkdevmap(pte_t pte)
 {
-	return set_pte_bit(pte, __pgprot(PTE_DEVMAP));
+	return set_pte_bit(pte, __pgprot(PTE_DEVMAP | PTE_SPECIAL));
 }
 static inline void set_pte(pte_t *ptep, pte_t pte)
 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
 #define pmd_devmap(pmd)		pte_devmap(pmd_pte(pmd))
 #endif
-#define pmd_mkdevmap(pmd)	pte_pmd(pte_mkdevmap(pmd_pte(pmd)))
+static inline pmd_t pmd_mkdevmap(pmd_t pmd)
+{
+	return pte_pmd(set_pte_bit(pmd_pte(pmd), __pgprot(PTE_DEVMAP)));
+}
 #define __pmd_to_phys(pmd)	__pte_to_phys(pmd_pte(pmd))
 #define __phys_to_pmd_val(phys)	__phys_to_pte_val(phys)

arch/arm64/kernel/cpufeature.c+11−3

 };
 static const struct arm64_ftr_bits ftr_id_aa64mmfr0[] = {
-	S_ARM64_FTR_BITS(FTR_HIDDEN, FTR_STRICT, FTR_LOWER_SAFE, ID_AA64MMFR0_TGRAN4_SHIFT, 4, ID_AA64MMFR0_TGRAN4_NI),
+	/*
-	S_ARM64_FTR_BITS(FTR_HIDDEN, FTR_STRICT, FTR_LOWER_SAFE, ID_AA64MMFR0_TGRAN64_SHIFT, 4, ID_AA64MMFR0_TGRAN64_NI),
+	 * We already refuse to boot CPUs that don't support our configured
-	ARM64_FTR_BITS(FTR_HIDDEN, FTR_STRICT, FTR_LOWER_SAFE, ID_AA64MMFR0_TGRAN16_SHIFT, 4, ID_AA64MMFR0_TGRAN16_NI),
+	 * page size, so we can only detect mismatches for a page size other
+	 * than the one we're currently using. Unfortunately, SoCs like this
+	 * exist in the wild so, even though we don't like it, we'll have to go
+	 * along with it and treat them as non-strict.
+	 */
+	S_ARM64_FTR_BITS(FTR_HIDDEN, FTR_NONSTRICT, FTR_LOWER_SAFE, ID_AA64MMFR0_TGRAN4_SHIFT, 4, ID_AA64MMFR0_TGRAN4_NI),
+	S_ARM64_FTR_BITS(FTR_HIDDEN, FTR_NONSTRICT, FTR_LOWER_SAFE, ID_AA64MMFR0_TGRAN64_SHIFT, 4, ID_AA64MMFR0_TGRAN64_NI),
+	ARM64_FTR_BITS(FTR_HIDDEN, FTR_NONSTRICT, FTR_LOWER_SAFE, ID_AA64MMFR0_TGRAN16_SHIFT, 4, ID_AA64MMFR0_TGRAN16_NI),
 	ARM64_FTR_BITS(FTR_HIDDEN, FTR_STRICT, FTR_LOWER_SAFE, ID_AA64MMFR0_BIGENDEL0_SHIFT, 4, 0),
 	/* Linux shouldn't care about secure memory */
 	ARM64_FTR_BITS(FTR_HIDDEN, FTR_NONSTRICT, FTR_LOWER_SAFE, ID_AA64MMFR0_SNSMEM_SHIFT, 4, 0),

arch/arm64/kernel/ftrace.c+13−9

 	if (offset < -SZ_128M || offset >= SZ_128M) {
 #ifdef CONFIG_ARM64_MODULE_PLTS
-		struct plt_entry trampoline;
+		struct plt_entry trampoline, *dst;
 		struct module *mod;
 		/*
 		 * to check if the actual opcodes are in fact identical,
 		 * regardless of the offset in memory so use memcmp() instead.
 		 */
-		trampoline = get_plt_entry(addr, mod->arch.ftrace_trampoline);
+		dst = mod->arch.ftrace_trampoline;
-		if (memcmp(mod->arch.ftrace_trampoline, &trampoline,
+		trampoline = get_plt_entry(addr, dst);
-			   sizeof(trampoline))) {
+		if (memcmp(dst, &trampoline, sizeof(trampoline))) {
-			if (plt_entry_is_initialized(mod->arch.ftrace_trampoline)) {
+			if (plt_entry_is_initialized(dst)) {
 				pr_err("ftrace: far branches to multiple entry points unsupported inside a single module\n");
 				return -EINVAL;
 			}
 			/* point the trampoline to our ftrace entry point */
 			module_disable_ro(mod);
-			*mod->arch.ftrace_trampoline = trampoline;
+			*dst = trampoline;
 			module_enable_ro(mod, true);
-			/* update trampoline before patching in the branch */
+			/*
-			smp_wmb();
+			 * Ensure updated trampoline is visible to instruction
+			 * fetch before we patch in the branch.
+			 */
+			__flush_icache_range((unsigned long)&dst[0],
+					     (unsigned long)&dst[1]);
 		}
-		addr = (unsigned long)(void *)mod->arch.ftrace_trampoline;
+		addr = (unsigned long)dst;
 #else /* CONFIG_ARM64_MODULE_PLTS */
 		return -EINVAL;
 #endif /* CONFIG_ARM64_MODULE_PLTS */

arch/arm64/kernel/traps.c+1−0

@@ -733,6 +733,7 @@ static const char *esr_class_str[] = { · 732 unmodified lines
733	[ESR_ELx_EC_CP14_LS] = "CP14 LDC/STC",	733	[ESR_ELx_EC_CP14_LS] = "CP14 LDC/STC",
734	[ESR_ELx_EC_FP_ASIMD] = "ASIMD",	734	[ESR_ELx_EC_FP_ASIMD] = "ASIMD",
735	[ESR_ELx_EC_CP10_ID] = "CP10 MRC/VMRS",	735	[ESR_ELx_EC_CP10_ID] = "CP10 MRC/VMRS",
		736	[ESR_ELx_EC_PAC] = "PAC",
736	[ESR_ELx_EC_CP14_64] = "CP14 MCRR/MRRC",	737	[ESR_ELx_EC_CP14_64] = "CP14 MCRR/MRRC",
737	[ESR_ELx_EC_ILL] = "PSTATE.IL",	738	[ESR_ELx_EC_ILL] = "PSTATE.IL",
738	[ESR_ELx_EC_SVC32] = "SVC (AArch32)",	739	[ESR_ELx_EC_SVC32] = "SVC (AArch32)",

arch/arm64/kvm/hyp/debug-sr.c+30−0

 #define save_debug(ptr,reg,nr)						\
 	switch (nr) {							\
 	case 15:	ptr[15] = read_debug(reg, 15);			\
+			/* Fall through */				\
 	case 14:	ptr[14] = read_debug(reg, 14);			\
+			/* Fall through */				\
 	case 13:	ptr[13] = read_debug(reg, 13);			\
+			/* Fall through */				\
 	case 12:	ptr[12] = read_debug(reg, 12);			\
+			/* Fall through */				\
 	case 11:	ptr[11] = read_debug(reg, 11);			\
+			/* Fall through */				\
 	case 10:	ptr[10] = read_debug(reg, 10);			\
+			/* Fall through */				\
 	case 9:		ptr[9] = read_debug(reg, 9);			\
+			/* Fall through */				\
 	case 8:		ptr[8] = read_debug(reg, 8);			\
+			/* Fall through */				\
 	case 7:		ptr[7] = read_debug(reg, 7);			\
+			/* Fall through */				\
 	case 6:		ptr[6] = read_debug(reg, 6);			\
+			/* Fall through */				\
 	case 5:		ptr[5] = read_debug(reg, 5);			\
+			/* Fall through */				\
 	case 4:		ptr[4] = read_debug(reg, 4);			\
+			/* Fall through */				\
 	case 3:		ptr[3] = read_debug(reg, 3);			\
+			/* Fall through */				\
 	case 2:		ptr[2] = read_debug(reg, 2);			\
+			/* Fall through */				\
 	case 1:		ptr[1] = read_debug(reg, 1);			\
+			/* Fall through */				\
 	default:	ptr[0] = read_debug(reg, 0);			\
 	}
 #define restore_debug(ptr,reg,nr)					\
 	switch (nr) {							\
 	case 15:	write_debug(ptr[15], reg, 15);			\
+			/* Fall through */				\
 	case 14:	write_debug(ptr[14], reg, 14);			\
+			/* Fall through */				\
 	case 13:	write_debug(ptr[13], reg, 13);			\
+			/* Fall through */				\
 	case 12:	write_debug(ptr[12], reg, 12);			\
+			/* Fall through */				\
 	case 11:	write_debug(ptr[11], reg, 11);			\
+			/* Fall through */				\
 	case 10:	write_debug(ptr[10], reg, 10);			\
+			/* Fall through */				\
 	case 9:		write_debug(ptr[9], reg, 9);			\
+			/* Fall through */				\
 	case 8:		write_debug(ptr[8], reg, 8);			\
+			/* Fall through */				\
 	case 7:		write_debug(ptr[7], reg, 7);			\
+			/* Fall through */				\
 	case 6:		write_debug(ptr[6], reg, 6);			\
+			/* Fall through */				\
 	case 5:		write_debug(ptr[5], reg, 5);			\
+			/* Fall through */				\
 	case 4:		write_debug(ptr[4], reg, 4);			\
+			/* Fall through */				\
 	case 3:		write_debug(ptr[3], reg, 3);			\
+			/* Fall through */				\
 	case 2:		write_debug(ptr[2], reg, 2);			\
+			/* Fall through */				\
 	case 1:		write_debug(ptr[1], reg, 1);			\
+			/* Fall through */				\
 	default:	write_debug(ptr[0], reg, 0);			\
 	}

arch/arm64/kvm/regmap.c+5−0

 	switch (spsr_idx) {
 	case KVM_SPSR_SVC:
 		write_sysreg_el1(v, SYS_SPSR);
+		break;
 	case KVM_SPSR_ABT:
 		write_sysreg(v, spsr_abt);
+		break;
 	case KVM_SPSR_UND:
 		write_sysreg(v, spsr_und);
+		break;
 	case KVM_SPSR_IRQ:
 		write_sysreg(v, spsr_irq);
+		break;
 	case KVM_SPSR_FIQ:
 		write_sysreg(v, spsr_fiq);
+		break;
 	}
 }

arch/arm64/kvm/sys_regs.c+18−14

@@ -632,7 +632,7 @@ static void reset_pmcr(struct kvm_vcpu vcpu, const struct sys_reg_desc r) · 631 unmodified lines
632	*/	632	*/
633	val = ((pmcr & ~ARMV8_PMU_PMCR_MASK)	633	val = ((pmcr & ~ARMV8_PMU_PMCR_MASK)
634	\| (ARMV8_PMU_PMCR_MASK & 0xdecafbad)) & (~ARMV8_PMU_PMCR_E);	634	\| (ARMV8_PMU_PMCR_MASK & 0xdecafbad)) & (~ARMV8_PMU_PMCR_E);
635	__vcpu_sys_reg(vcpu, PMCR_EL0) = val;	635	__vcpu_sys_reg(vcpu, r->reg) = val;
636	}	636	}
637		637
638	static bool check_pmu_access_disabled(struct kvm_vcpu *vcpu, u64 flags)	638	static bool check_pmu_access_disabled(struct kvm_vcpu *vcpu, u64 flags)
@@ -981,13 +981,13 @@ static bool access_pmuserenr(struct kvm_vcpu vcpu, struct sys_reg_params p, · 342 unmodified lines
981	/* Silly macro to expand the DBG{BCR,BVR,WVR,WCR}n_EL1 registers in one go */	981	/* Silly macro to expand the DBG{BCR,BVR,WVR,WCR}n_EL1 registers in one go */
982	#define DBG_BCR_BVR_WCR_WVR_EL1(n) \	982	#define DBG_BCR_BVR_WCR_WVR_EL1(n) \
983	{ SYS_DESC(SYS_DBGBVRn_EL1(n)), \	983	{ SYS_DESC(SYS_DBGBVRn_EL1(n)), \
984	trap_bvr, reset_bvr, n, 0, get_bvr, set_bvr }, \	984	trap_bvr, reset_bvr, 0, 0, get_bvr, set_bvr }, \
985	{ SYS_DESC(SYS_DBGBCRn_EL1(n)), \	985	{ SYS_DESC(SYS_DBGBCRn_EL1(n)), \
986	trap_bcr, reset_bcr, n, 0, get_bcr, set_bcr }, \	986	trap_bcr, reset_bcr, 0, 0, get_bcr, set_bcr }, \
987	{ SYS_DESC(SYS_DBGWVRn_EL1(n)), \	987	{ SYS_DESC(SYS_DBGWVRn_EL1(n)), \
988	trap_wvr, reset_wvr, n, 0, get_wvr, set_wvr }, \	988	trap_wvr, reset_wvr, 0, 0, get_wvr, set_wvr }, \
989	{ SYS_DESC(SYS_DBGWCRn_EL1(n)), \	989	{ SYS_DESC(SYS_DBGWCRn_EL1(n)), \
990	trap_wcr, reset_wcr, n, 0, get_wcr, set_wcr }	990	trap_wcr, reset_wcr, 0, 0, get_wcr, set_wcr }
991		991
992	/* Macro to expand the PMEVCNTRn_EL0 register */	992	/* Macro to expand the PMEVCNTRn_EL0 register */
993	#define PMU_PMEVCNTR_EL0(n) \	993	#define PMU_PMEVCNTR_EL0(n) \
@@ -1540,7 +1540,7 @@ static const struct sys_reg_desc sys_reg_descs[] = { · 546 unmodified lines
1540	{ SYS_DESC(SYS_CSSELR_EL1), access_csselr, reset_unknown, CSSELR_EL1 },	1540	{ SYS_DESC(SYS_CSSELR_EL1), access_csselr, reset_unknown, CSSELR_EL1 },
1541	{ SYS_DESC(SYS_CTR_EL0), access_ctr },	1541	{ SYS_DESC(SYS_CTR_EL0), access_ctr },
1542		1542
1543	{ SYS_DESC(SYS_PMCR_EL0), access_pmcr, reset_pmcr, },	1543	{ SYS_DESC(SYS_PMCR_EL0), access_pmcr, reset_pmcr, PMCR_EL0 },
1544	{ SYS_DESC(SYS_PMCNTENSET_EL0), access_pmcnten, reset_unknown, PMCNTENSET_EL0 },	1544	{ SYS_DESC(SYS_PMCNTENSET_EL0), access_pmcnten, reset_unknown, PMCNTENSET_EL0 },
1545	{ SYS_DESC(SYS_PMCNTENCLR_EL0), access_pmcnten, NULL, PMCNTENSET_EL0 },	1545	{ SYS_DESC(SYS_PMCNTENCLR_EL0), access_pmcnten, NULL, PMCNTENSET_EL0 },
1546	{ SYS_DESC(SYS_PMOVSCLR_EL0), access_pmovs, NULL, PMOVSSET_EL0 },	1546	{ SYS_DESC(SYS_PMOVSCLR_EL0), access_pmovs, NULL, PMOVSSET_EL0 },
@@ -2254,13 +2254,19 @@ static int emulate_sys_reg(struct kvm_vcpu *vcpu, · 707 unmodified lines
2254	}	2254	}
2255		2255
2256	static void reset_sys_reg_descs(struct kvm_vcpu *vcpu,	2256	static void reset_sys_reg_descs(struct kvm_vcpu *vcpu,
2257	const struct sys_reg_desc *table, size_t num)	2257	const struct sys_reg_desc *table, size_t num,
		2258	unsigned long *bmap)
2258	{	2259	{
2259	unsigned long i;	2260	unsigned long i;
2260		2261
2261	for (i = 0; i < num; i++)	2262	for (i = 0; i < num; i++)
2262	if (table[i].reset)	2263	if (table[i].reset) {
		2264	int reg = table[i].reg;
		2265
2263	table[i].reset(vcpu, &table[i]);	2266	table[i].reset(vcpu, &table[i]);
		2267	if (reg > 0 && reg < NR_SYS_REGS)
		2268	set_bit(reg, bmap);
		2269	}
2264	}	2270	}
2265		2271
2266	/**	2272	/**
@@ -2774,18 +2780,16 @@ void kvm_reset_sys_regs(struct kvm_vcpu *vcpu) · 507 unmodified lines
2774	{	2780	{
2775	size_t num;	2781	size_t num;
2776	const struct sys_reg_desc *table;	2782	const struct sys_reg_desc *table;
2777		2783	DECLARE_BITMAP(bmap, NR_SYS_REGS) = { 0, };
2778	/* Catch someone adding a register without putting in reset entry. */
2779	memset(&vcpu->arch.ctxt.sys_regs, 0x42, sizeof(vcpu->arch.ctxt.sys_regs));
2780		2784
2781	/* Generic chip reset first (so target could override). */	2785	/* Generic chip reset first (so target could override). */
2782	reset_sys_reg_descs(vcpu, sys_reg_descs, ARRAY_SIZE(sys_reg_descs));	2786	reset_sys_reg_descs(vcpu, sys_reg_descs, ARRAY_SIZE(sys_reg_descs), bmap);
2783		2787
2784	table = get_target_table(vcpu->arch.target, true, &num);	2788	table = get_target_table(vcpu->arch.target, true, &num);
2785	reset_sys_reg_descs(vcpu, table, num);	2789	reset_sys_reg_descs(vcpu, table, num, bmap);
2786		2790
2787	for (num = 1; num < NR_SYS_REGS; num++) {	2791	for (num = 1; num < NR_SYS_REGS; num++) {
2788	if (WARN(__vcpu_sys_reg(vcpu, num) == 0x4242424242424242,	2792	if (WARN(!test_bit(num, bmap),
2789	"Didn't reset __vcpu_sys_reg(%zi)\n", num))	2793	"Didn't reset __vcpu_sys_reg(%zi)\n", num))
2790	break;	2794	break;
2791	}	2795	}

arch/arm64/mm/dma-mapping.c+1−3

 pgprot_t arch_dma_mmap_pgprot(struct device *dev, pgprot_t prot,
 		unsigned long attrs)
 {
-	if (!dev_is_dma_coherent(dev) || (attrs & DMA_ATTR_WRITE_COMBINE))
+	return pgprot_writecombine(prot);
-		return pgprot_writecombine(prot);
-	return prot;
 }
 void arch_sync_dma_for_device(struct device *dev, phys_addr_t paddr,

arch/mips/kvm/mips.c+0−10

@@ -150,16 +150,6 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) · 149 unmodified lines
150	return 0;	150	return 0;
151	}	151	}
152		152
153	bool kvm_arch_has_vcpu_debugfs(void)
154	{
155	return false;
156	}
157
158	int kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu)
159	{
160	return 0;
161	}
162
163	void kvm_mips_free_vcpus(struct kvm *kvm)	153	void kvm_mips_free_vcpus(struct kvm *kvm)
164	{	154	{
165	unsigned int i;	155	unsigned int i;

arch/parisc/math-emu/Makefile+1−1

@@ -18,4 +18,4 @@ obj-y := frnd.o driver.o decode_exc.o fpudispatch.o denormal.o \ · 17 unmodified lines
18	# other very old or stripped-down PA-RISC CPUs -- not currently supported	18	# other very old or stripped-down PA-RISC CPUs -- not currently supported
19		19
20	obj-$(CONFIG_MATH_EMULATION) += unimplemented-math-emulation.o	20	obj-$(CONFIG_MATH_EMULATION) += unimplemented-math-emulation.o
21	CFLAGS_REMOVE_fpudispatch.o = -Wimplicit-fallthrough=3	21	CFLAGS_REMOVE_fpudispatch.o = -Wimplicit-fallthrough

arch/powerpc/Kconfig+0−1

@@ -121,7 +121,6 @@ config PPC · 120 unmodified lines
121	select ARCH_32BIT_OFF_T if PPC32	121	select ARCH_32BIT_OFF_T if PPC32
122	select ARCH_HAS_DEBUG_VIRTUAL	122	select ARCH_HAS_DEBUG_VIRTUAL
123	select ARCH_HAS_DEVMEM_IS_ALLOWED	123	select ARCH_HAS_DEVMEM_IS_ALLOWED
124	select ARCH_HAS_DMA_MMAP_PGPROT
125	select ARCH_HAS_ELF_RANDOMIZE	124	select ARCH_HAS_ELF_RANDOMIZE
126	select ARCH_HAS_FORTIFY_SOURCE	125	select ARCH_HAS_FORTIFY_SOURCE
127	select ARCH_HAS_GCOV_PROFILE_ALL	126	select ARCH_HAS_GCOV_PROFILE_ALL

arch/powerpc/include/asm/cache.h+4−4

@@ -107,22 +107,22 @@ extern void _set_L3CR(unsigned long); · 106 unmodified lines
107		107
108	static inline void dcbz(void *addr)	108	static inline void dcbz(void *addr)
109	{	109	{
110	__asm__ __volatile__ ("dcbz %y0" : : "Z"((u8 )addr) : "memory");	110	__asm__ __volatile__ ("dcbz 0, %0" : : "r"(addr) : "memory");
111	}	111	}
112		112
113	static inline void dcbi(void *addr)	113	static inline void dcbi(void *addr)
114	{	114	{
115	__asm__ __volatile__ ("dcbi %y0" : : "Z"((u8 )addr) : "memory");	115	__asm__ __volatile__ ("dcbi 0, %0" : : "r"(addr) : "memory");
116	}	116	}
117		117
118	static inline void dcbf(void *addr)	118	static inline void dcbf(void *addr)
119	{	119	{
120	__asm__ __volatile__ ("dcbf %y0" : : "Z"((u8 )addr) : "memory");	120	__asm__ __volatile__ ("dcbf 0, %0" : : "r"(addr) : "memory");
121	}	121	}
122		122
123	static inline void dcbst(void *addr)	123	static inline void dcbst(void *addr)
124	{	124	{
125	__asm__ __volatile__ ("dcbst %y0" : : "Z"((u8 )addr) : "memory");	125	__asm__ __volatile__ ("dcbst 0, %0" : : "r"(addr) : "memory");
126	}	126	}
127	#endif /* !__ASSEMBLY__ */	127	#endif /* !__ASSEMBLY__ */
128	#endif /* __KERNEL__ */	128	#endif /* __KERNEL__ */

arch/powerpc/kernel/Makefile+1−2

 				   signal.o sysfs.o cacheinfo.o time.o \
 				   prom.o traps.o setup-common.o \
 				   udbg.o misc.o io.o misc_$(BITS).o \
-				   of_platform.o prom_parse.o \
+				   of_platform.o prom_parse.o
-				   dma-common.o
 obj-$(CONFIG_PPC64)		+= setup_64.o sys_ppc32.o \
 				   signal_64.o ptrace32.o \
 				   paca.o nvram_64.o firmware.o

arch/powerpc/kernel/dma-common.c+0−17

@@ -1,17 +0,0 @@
1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*
3	* Contains common dma routines for all powerpc platforms.
4	*
5	* Copyright (C) 2019 Shawn Anastasio.
6	*/
7
8	#include <linux/mm.h>
9	#include <linux/dma-noncoherent.h>
10
11	pgprot_t arch_dma_mmap_pgprot(struct device *dev, pgprot_t prot,
12	unsigned long attrs)
13	{
14	if (!dev_is_dma_coherent(dev))
15	return pgprot_noncached(prot);
16	return prot;
17	}

arch/powerpc/kvm/powerpc.c+5−10

 	return !!(v->arch.pending_exceptions) || kvm_request_pending(v);
 }
+bool kvm_arch_dy_runnable(struct kvm_vcpu *vcpu)
+{
+	return kvm_arch_vcpu_runnable(vcpu);
+}
 bool kvm_arch_vcpu_in_kernel(struct kvm_vcpu *vcpu)
 {
 	return false;
 	return -EINVAL;
 }
-bool kvm_arch_has_vcpu_debugfs(void)
-{
-	return false;
-}
-int kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu)
-{
-	return 0;
-}
 void kvm_arch_destroy_vm(struct kvm *kvm)
 {
 	unsigned int i;

arch/riscv/configs/defconfig+2−0

 CONFIG_SERIAL_OF_PLATFORM=y
 CONFIG_SERIAL_EARLYCON_RISCV_SBI=y
 CONFIG_HVC_RISCV_SBI=y
+CONFIG_HW_RANDOM=y
+CONFIG_HW_RANDOM_VIRTIO=y
 CONFIG_SPI=y
 CONFIG_SPI_SIFIVE=y
 # CONFIG_PTP_1588_CLOCK is not set

arch/riscv/configs/rv32_defconfig+3−0

 CONFIG_PCI_HOST_GENERIC=y
 CONFIG_PCIE_XILINX=y
 CONFIG_DEVTMPFS=y
+CONFIG_DEVTMPFS_MOUNT=y
 CONFIG_BLK_DEV_LOOP=y
 CONFIG_VIRTIO_BLK=y
 CONFIG_BLK_DEV_SD=y
 CONFIG_SERIAL_OF_PLATFORM=y
 CONFIG_SERIAL_EARLYCON_RISCV_SBI=y
 CONFIG_HVC_RISCV_SBI=y
+CONFIG_HW_RANDOM=y
+CONFIG_HW_RANDOM_VIRTIO=y
 # CONFIG_PTP_1588_CLOCK is not set
 CONFIG_DRM=y
 CONFIG_DRM_RADEON=y

arch/riscv/include/asm/switch_to.h+7−1

 static inline void __fstate_clean(struct pt_regs *regs)
 {
-	regs->sstatus |= (regs->sstatus & ~(SR_FS)) | SR_FS_CLEAN;
+	regs->sstatus = (regs->sstatus & ~SR_FS) | SR_FS_CLEAN;
+}
+static inline void fstate_off(struct task_struct *task,
+			      struct pt_regs *regs)
+{
+	regs->sstatus = (regs->sstatus & ~SR_FS) | SR_FS_OFF;
 }
 static inline void fstate_save(struct task_struct *task,

arch/riscv/include/asm/tlbflush.h+9−2

@@ -53,10 +53,17 @@ static inline void remote_sfence_vma(struct cpumask *cmask, unsigned long start, · 52 unmodified lines
53	}	53	}
54		54
55	#define flush_tlb_all() sbi_remote_sfence_vma(NULL, 0, -1)	55	#define flush_tlb_all() sbi_remote_sfence_vma(NULL, 0, -1)
56	#define flush_tlb_page(vma, addr) flush_tlb_range(vma, addr, 0)	56
57	#define flush_tlb_range(vma, start, end) \	57	#define flush_tlb_range(vma, start, end) \
58	remote_sfence_vma(mm_cpumask((vma)->vm_mm), start, (end) - (start))	58	remote_sfence_vma(mm_cpumask((vma)->vm_mm), start, (end) - (start))
59	#define flush_tlb_mm(mm) \	59
		60	static inline void flush_tlb_page(struct vm_area_struct *vma,
		61	unsigned long addr)
		62	{
		63	flush_tlb_range(vma, addr, addr + PAGE_SIZE);
		64	}
		65
		66	#define flush_tlb_mm(mm) \
60	remote_sfence_vma(mm_cpumask(mm), 0, -1)	67	remote_sfence_vma(mm_cpumask(mm), 0, -1)
61		68
62	#endif /* CONFIG_SMP */	69	#endif /* CONFIG_SMP */

arch/riscv/kernel/process.c+9−2

 	unsigned long sp)
 {
 	regs->sstatus = SR_SPIE;
-	if (has_fpu)
+	if (has_fpu) {
 		regs->sstatus |= SR_FS_INITIAL;
+		/*
+		 * Restore the initial value to the FP register
+		 * before starting the user program.
+		 */
+		fstate_restore(current, regs);
+	}
 	regs->sepc = pc;
 	regs->sp = sp;
 	set_fs(USER_DS);
 {
 #ifdef CONFIG_FPU
 	/*
-	 * Reset FPU context
+	 * Reset FPU state and context
 	 *	frm: round to nearest, ties to even (IEEE default)
 	 *	fflags: accrued exceptions cleared
 	 */
+	fstate_off(current, task_pt_regs(current));
 	memset(&current->thread.fstate, 0, sizeof(current->thread.fstate));
 #endif
 }

arch/riscv/lib/Makefile+0−2

@@ -5,5 +5,3 @@ lib-y += memset.o · 4 unmodified lines
5	lib-y += uaccess.o	5	lib-y += uaccess.o
6		6
7	lib-$(CONFIG_64BIT) += tishift.o	7	lib-$(CONFIG_64BIT) += tishift.o
8
9	lib-$(CONFIG_32BIT) += udivdi3.o

arch/riscv/lib/delay.c+5−1

 void udelay(unsigned long usecs)
 {
 	u64 ucycles = (u64)usecs * lpj_fine * UDELAY_MULT;
+	u64 n;
 	if (unlikely(usecs > MAX_UDELAY_US)) {
-		__delay((u64)usecs * riscv_timebase / 1000000ULL);
+		n = (u64)usecs * riscv_timebase;
+		do_div(n, 1000000);
+		__delay(n);
 		return;
 	}

arch/riscv/lib/udivdi3.S+0−32

@@ -1,32 +0,0 @@
1	/* SPDX-License-Identifier: GPL-2.0-only */
2	/*
3	* Copyright (C) 2016-2017 Free Software Foundation, Inc.
4	*/
5
6	#include <linux/linkage.h>
7
8	ENTRY(__udivdi3)
9	mv a2, a1
10	mv a1, a0
11	li a0, -1
12	beqz a2, .L5
13	li a3, 1
14	bgeu a2, a1, .L2
15	.L1:
16	blez a2, .L2
17	slli a2, a2, 1
18	slli a3, a3, 1
19	bgtu a1, a2, .L1
20	.L2:
21	li a0, 0
22	.L3:
23	bltu a1, a2, .L4
24	sub a1, a1, a2
25	or a0, a0, a3
26	.L4:
27	srli a3, a3, 1
28	srli a2, a2, 1
29	bnez a3, .L3
30	.L5:
31	ret
32	ENDPROC(__udivdi3)

arch/s390/boot/ipl_parm.c+0−2

 {
 	int rc;
-	uv_set_shared(__pa(&ipl_block));
 	rc = __diag308(DIAG308_STORE, &ipl_block);
-	uv_remove_shared(__pa(&ipl_block));
 	if (rc == DIAG308_RC_OK &&
 	    ipl_block.hdr.version <= IPL_MAX_SUPPORTED_VERSION)
 		ipl_block_valid = 1;

arch/s390/kernel/dumpstack.c+1−5

 	 * If it comes up a second time then there's something wrong going on:
 	 * just break out and report an unknown stack type.
 	 */
-	if (*visit_mask & (1UL << info->type)) {
+	if (*visit_mask & (1UL << info->type))
-		printk_deferred_once(KERN_WARNING
-			"WARNING: stack recursion on stack type %d\n",
-			info->type);
 		goto unknown;
-	}
 	*visit_mask |= 1UL << info->type;
 	return 0;
 unknown:

arch/s390/kernel/head64.S+0−7

@@ -60,12 +60,5 @@ ENTRY(startup_continue) · 59 unmodified lines
60		60
61	.align 16	61	.align 16
62	.LPG1:	62	.LPG1:
63	.Lpcmsk:.quad 0x0000000180000000
64	.L4malign:.quad 0xffffffffffc00000
65	.Lscan2g:.quad 0x80000000 + 0x20000 - 8 # 2GB + 128K - 8
66	.Lnop: .long 0x07000700
67	.Lparmaddr:
68	.quad PARMAREA
69	.align 64
70	.Ldw: .quad 0x0002000180000000,0x0000000000000000	63	.Ldw: .quad 0x0002000180000000,0x0000000000000000
71	.Laregs:.long 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0	64	.Laregs:.long 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0

arch/s390/kernel/ipl.c+0−9

 #include <asm/os_info.h>
 #include <asm/sections.h>
 #include <asm/boot_data.h>
-#include <asm/uv.h>
 #include "entry.h"
 #define IPL_PARM_BLOCK_VERSION 0
 {
 	switch (reipl_type) {
 	case IPL_TYPE_CCW:
-		uv_set_shared(__pa(reipl_block_ccw));
 		diag308(DIAG308_SET, reipl_block_ccw);
-		uv_remove_shared(__pa(reipl_block_ccw));
 		diag308(DIAG308_LOAD_CLEAR, NULL);
 		break;
 	case IPL_TYPE_FCP:
-		uv_set_shared(__pa(reipl_block_fcp));
 		diag308(DIAG308_SET, reipl_block_fcp);
-		uv_remove_shared(__pa(reipl_block_fcp));
 		diag308(DIAG308_LOAD_CLEAR, NULL);
 		break;
 	case IPL_TYPE_NSS:
-		uv_set_shared(__pa(reipl_block_nss));
 		diag308(DIAG308_SET, reipl_block_nss);
-		uv_remove_shared(__pa(reipl_block_nss));
 		diag308(DIAG308_LOAD_CLEAR, NULL);
 		break;
 	case IPL_TYPE_UNKNOWN:
 static void diag308_dump(void *dump_block)
 {
-	uv_set_shared(__pa(dump_block));
 	diag308(DIAG308_SET, dump_block);
-	uv_remove_shared(__pa(dump_block));
 	while (1) {
 		if (diag308(DIAG308_LOAD_NORMAL_DUMP, NULL) != 0x302)
 			break;

arch/s390/kernel/setup.c+1−2

@@ -1114,8 +1114,7 @@ void __init setup_arch(char **cmdline_p) · 1113 unmodified lines
1114		1114
1115	ROOT_DEV = Root_RAM0;	1115	ROOT_DEV = Root_RAM0;
1116		1116
1117	/* Is init_mm really needed? */	1117	init_mm.start_code = (unsigned long) _text;
1118	init_mm.start_code = PAGE_OFFSET;
1119	init_mm.end_code = (unsigned long) _etext;	1118	init_mm.end_code = (unsigned long) _etext;
1120	init_mm.end_data = (unsigned long) _edata;	1119	init_mm.end_data = (unsigned long) _edata;
1121	init_mm.brk = (unsigned long) _end;	1120	init_mm.brk = (unsigned long) _end;

arch/s390/kernel/vdso.c+0−5

 	if (!vdso_enabled)
 		return 0;
-	/*
-	 * Only map the vdso for dynamically linked elf binaries.
-	 */
-	if (!uses_interp)
-		return 0;
 	vdso_pages = vdso64_pages;
 #ifdef CONFIG_COMPAT_VDSO

arch/s390/kernel/vmlinux.lds.S+4−6

 SECTIONS
 {
 	. = 0x100000;
-	_stext = .;		/* Start of text section */
 	.text : {
-		/* Text and read-only data */
+		_stext = .;		/* Start of text section */
-		_text = .;
+		_text = .;		/* Text and read-only data */
 		HEAD_TEXT
 		TEXT_TEXT
 		SCHED_TEXT
 		*(.text.*_indirect_*)
 		*(.fixup)
 		*(.gnu.warning)
+		. = ALIGN(PAGE_SIZE);
+		_etext = .;		/* End of text section */
 	} :text = 0x0700
-	. = ALIGN(PAGE_SIZE);
-	_etext = .;		/* End of text section */
 	NOTES :text :note
 	.dummy : { *(.dummy) } :data

arch/s390/kvm/kvm-s390.c+0−10

@@ -2516,16 +2516,6 @@ out_err: · 2515 unmodified lines
2516	return rc;	2516	return rc;
2517	}	2517	}
2518		2518
2519	bool kvm_arch_has_vcpu_debugfs(void)
2520	{
2521	return false;
2522	}
2523
2524	int kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu)
2525	{
2526	return 0;
2527	}
2528
2529	void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)	2519	void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
2530	{	2520	{
2531	VCPU_EVENT(vcpu, 3, "%s", "free cpu");	2521	VCPU_EVENT(vcpu, 3, "%s", "free cpu");

arch/s390/mm/dump_pagetables.c+6−6

 	}
 #endif
-	for (i = 0; i < PTRS_PER_PMD && addr < max_addr; i++) {
+	pmd = pmd_offset(pud, addr);
+	for (i = 0; i < PTRS_PER_PMD && addr < max_addr; i++, pmd++) {
 		st->current_address = addr;
-		pmd = pmd_offset(pud, addr);
 		if (!pmd_none(*pmd)) {
 			if (pmd_large(*pmd)) {
 				prot = pmd_val(*pmd) &
 	}
 #endif
-	for (i = 0; i < PTRS_PER_PUD && addr < max_addr; i++) {
+	pud = pud_offset(p4d, addr);
+	for (i = 0; i < PTRS_PER_PUD && addr < max_addr; i++, pud++) {
 		st->current_address = addr;
-		pud = pud_offset(p4d, addr);
 		if (!pud_none(*pud))
 			if (pud_large(*pud)) {
 				prot = pud_val(*pud) &
 	}
 #endif
-	for (i = 0; i < PTRS_PER_P4D && addr < max_addr; i++) {
+	p4d = p4d_offset(pgd, addr);
+	for (i = 0; i < PTRS_PER_P4D && addr < max_addr; i++, p4d++) {
 		st->current_address = addr;
-		p4d = p4d_offset(pgd, addr);
 		if (!p4d_none(*p4d))
 			walk_pud_level(m, st, p4d, addr);
 		else

arch/s390/scripts/Makefile.chkbss+1−2

@@ -11,8 +11,7 @@ chkbss: $(addprefix $(obj)/, $(chkbss-files)) · 10 unmodified lines
11		11
12	quiet_cmd_chkbss = CHKBSS $<	12	quiet_cmd_chkbss = CHKBSS $<
13	cmd_chkbss = \	13	cmd_chkbss = \
14	if $(OBJDUMP) -h $< \| grep -q "\.bss" && \	14	if ! $(OBJSIZE) --common $< \| $(AWK) 'END { if ($$3) exit 1 }'; then \
15	! $(OBJDUMP) -j .bss -w -h $< \| awk 'END { if ($$3) exit 1 }'; then \
16	echo "error: $< .bss section is not empty" >&2; exit 1; \	15	echo "error: $< .bss section is not empty" >&2; exit 1; \
17	fi; \	16	fi; \
18	touch $@;	17	touch $@;

arch/sh/kernel/disassemble.c+2−3

 				printk("dbr");
 				break;
 			case FD_REG_N:
-				if (0)
-					goto d_reg_n;
 			case F_REG_N:
 				printk("fr%d", rn);
 				break;
 					printk("xd%d", rn & ~1);
 					break;
 				}
-			d_reg_n:
+				/* else, fall through */
 			case D_REG_N:
 				printk("dr%d", rn);
 				break;
 					printk("xd%d", rm & ~1);
 					break;
 				}
+				/* else, fall through */
 			case D_REG_M:
 				printk("dr%d", rm);
 				break;

arch/sh/kernel/hw_breakpoint.c+1−0

@@ -157,6 +157,7 @@ int arch_bp_generic_fields(int sh_len, int sh_type, · 156 unmodified lines
157	switch (sh_type) {	157	switch (sh_type) {
158	case SH_BREAKPOINT_READ:	158	case SH_BREAKPOINT_READ:
159	*gen_type = HW_BREAKPOINT_R;	159	*gen_type = HW_BREAKPOINT_R;
		160	break;
160	case SH_BREAKPOINT_WRITE:	161	case SH_BREAKPOINT_WRITE:
161	*gen_type = HW_BREAKPOINT_W;	162	*gen_type = HW_BREAKPOINT_W;
162	break;	163	break;

arch/x86/boot/string.c+8−0

@@ -37,6 +37,14 @@ int memcmp(const void s1, const void s2, size_t len) · 36 unmodified lines
37	return diff;	37	return diff;
38	}	38	}
39		39
		40	/*
		41	* Clang may lower `memcmp == 0` to `bcmp == 0`.
		42	*/
		43	int bcmp(const void s1, const void s2, size_t len)
		44	{
		45	return memcmp(s1, s2, len);
		46	}
		47
40	int strcmp(const char str1, const char str2)	48	int strcmp(const char str1, const char str2)
41	{	49	{
42	const unsigned char s1 = (const unsigned char )str1;	50	const unsigned char s1 = (const unsigned char )str1;

arch/x86/include/asm/bootparam_utils.h+48−15

@@ -18,6 +18,20 @@ · 17 unmodified lines
18	* Note: efi_info is commonly left uninitialized, but that field has a	18	* Note: efi_info is commonly left uninitialized, but that field has a
19	* private magic, so it is better to leave it unchanged.	19	* private magic, so it is better to leave it unchanged.
20	*/	20	*/
		21
		22	#define sizeof_mbr(type, member) ({ sizeof(((type *)0)->member); })
		23
		24	#define BOOT_PARAM_PRESERVE(struct_member) \
		25	{ \
		26	.start = offsetof(struct boot_params, struct_member), \
		27	.len = sizeof_mbr(struct boot_params, struct_member), \
		28	}
		29
		30	struct boot_params_to_save {
		31	unsigned int start;
		32	unsigned int len;
		33	};
		34
21	static void sanitize_boot_params(struct boot_params *boot_params)	35	static void sanitize_boot_params(struct boot_params *boot_params)
22	{	36	{
23	/*	37	/*
@@ -35,21 +49,40 @@ static void sanitize_boot_params(struct boot_params *boot_params) · 11 unmodified lines
35	* problems again.	49	* problems again.
36	*/	50	*/
37	if (boot_params->sentinel) {	51	if (boot_params->sentinel) {
38	/* fields in boot_params are left uninitialized, clear them */	52	static struct boot_params scratch;
39	boot_params->acpi_rsdp_addr = 0;	53	char bp_base = (char )boot_params;
40	memset(&boot_params->ext_ramdisk_image, 0,	54	char save_base = (char )&scratch;
41	(char *)&boot_params->efi_info -	55	int i;
42	(char *)&boot_params->ext_ramdisk_image);	56
43	memset(&boot_params->kbd_status, 0,	57	const struct boot_params_to_save to_save[] = {
44	(char *)&boot_params->hdr -	58	BOOT_PARAM_PRESERVE(screen_info),
45	(char *)&boot_params->kbd_status);	59	BOOT_PARAM_PRESERVE(apm_bios_info),
46	memset(&boot_params->_pad7[0], 0,	60	BOOT_PARAM_PRESERVE(tboot_addr),
47	(char *)&boot_params->edd_mbr_sig_buffer[0] -	61	BOOT_PARAM_PRESERVE(ist_info),
48	(char *)&boot_params->_pad7[0]);	62	BOOT_PARAM_PRESERVE(acpi_rsdp_addr),
49	memset(&boot_params->_pad8[0], 0,	63	BOOT_PARAM_PRESERVE(hd0_info),
50	(char *)&boot_params->eddbuf[0] -	64	BOOT_PARAM_PRESERVE(hd1_info),
51	(char *)&boot_params->_pad8[0]);	65	BOOT_PARAM_PRESERVE(sys_desc_table),
52	memset(&boot_params->_pad9[0], 0, sizeof(boot_params->_pad9));	66	BOOT_PARAM_PRESERVE(olpc_ofw_header),
		67	BOOT_PARAM_PRESERVE(efi_info),
		68	BOOT_PARAM_PRESERVE(alt_mem_k),
		69	BOOT_PARAM_PRESERVE(scratch),
		70	BOOT_PARAM_PRESERVE(e820_entries),
		71	BOOT_PARAM_PRESERVE(eddbuf_entries),
		72	BOOT_PARAM_PRESERVE(edd_mbr_sig_buf_entries),
		73	BOOT_PARAM_PRESERVE(edd_mbr_sig_buffer),
		74	BOOT_PARAM_PRESERVE(e820_table),
		75	BOOT_PARAM_PRESERVE(eddbuf),
		76	};
		77
		78	memset(&scratch, 0, sizeof(scratch));
		79
		80	for (i = 0; i < ARRAY_SIZE(to_save); i++) {
		81	memcpy(save_base + to_save[i].start,
		82	bp_base + to_save[i].start, to_save[i].len);
		83	}
		84
		85	memcpy(boot_params, save_base, sizeof(*boot_params));
53	}	86	}
54	}	87	}
55		88

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

 #include <asm/kvm_vcpu_regs.h>
 #include <asm/hyperv-tlfs.h>
+#define __KVM_HAVE_ARCH_VCPU_DEBUGFS
 #define KVM_MAX_VCPUS 288
 #define KVM_SOFT_MAX_VCPUS 240
 #define KVM_MAX_VCPU_ID 1023
 	int (*update_pi_irte)(struct kvm *kvm, unsigned int host_irq,
 			      uint32_t guest_irq, bool set);
 	void (*apicv_post_state_restore)(struct kvm_vcpu *vcpu);
+	bool (*dy_apicv_has_pending_interrupt)(struct kvm_vcpu *vcpu);
 	int (*set_hv_timer)(struct kvm_vcpu *vcpu, u64 guest_deadline_tsc,
 			    bool *expired);

arch/x86/kernel/apic/probe_32.c+2−1

 				def_to_bigsmp = 0;
 				break;
 			}
-			/* If P4 and above fall through */
+			/* P4 and above */
+			/* fall through */
 		case X86_VENDOR_HYGON:
 		case X86_VENDOR_AMD:
 			def_to_bigsmp = 1;

arch/x86/kernel/cpu/mtrr/cyrix.c+1−0

@@ -98,6 +98,7 @@ cyrix_get_free_region(unsigned long base, unsigned long size, int replace_reg) · 97 unmodified lines
98	case 7:	98	case 7:
99	if (size < 0x40)	99	if (size < 0x40)
100	break;	100	break;
		101	/* Else, fall through */
101	case 6:	102	case 6:
102	case 5:	103	case 5:
103	case 4:	104	case 4:

arch/x86/kernel/cpu/umwait.c+38−1

@@ -17,6 +17,12 @@ · 16 unmodified lines
17	*/	17	*/
18	static u32 umwait_control_cached = UMWAIT_CTRL_VAL(100000, UMWAIT_C02_ENABLE);	18	static u32 umwait_control_cached = UMWAIT_CTRL_VAL(100000, UMWAIT_C02_ENABLE);
19		19
		20	/*
		21	* Cache the original IA32_UMWAIT_CONTROL MSR value which is configured by
		22	* hardware or BIOS before kernel boot.
		23	*/
		24	static u32 orig_umwait_control_cached __ro_after_init;
		25
20	/*	26	/*
21	* Serialize access to umwait_control_cached and IA32_UMWAIT_CONTROL MSR in	27	* Serialize access to umwait_control_cached and IA32_UMWAIT_CONTROL MSR in
22	* the sysfs write functions.	28	* the sysfs write functions.
@@ -52,6 +58,23 @@ static int umwait_cpu_online(unsigned int cpu) · 29 unmodified lines
52	return 0;	58	return 0;
53	}	59	}
54		60
		61	/*
		62	* The CPU hotplug callback sets the control MSR to the original control
		63	* value.
		64	*/
		65	static int umwait_cpu_offline(unsigned int cpu)
		66	{
		67	/*
		68	* This code is protected by the CPU hotplug already and
		69	* orig_umwait_control_cached is never changed after it caches
		70	* the original control MSR value in umwait_init(). So there
		71	* is no race condition here.
		72	*/
		73	wrmsr(MSR_IA32_UMWAIT_CONTROL, orig_umwait_control_cached, 0);
		74
		75	return 0;
		76	}
		77
55	/*	78	/*
56	* On resume, restore IA32_UMWAIT_CONTROL MSR on the boot processor which	79	* On resume, restore IA32_UMWAIT_CONTROL MSR on the boot processor which
57	* is the only active CPU at this time. The MSR is set up on the APs via the	80	* is the only active CPU at this time. The MSR is set up on the APs via the
@@ -185,8 +208,22 @@ static int __init umwait_init(void) · 127 unmodified lines
185	if (!boot_cpu_has(X86_FEATURE_WAITPKG))	208	if (!boot_cpu_has(X86_FEATURE_WAITPKG))
186	return -ENODEV;	209	return -ENODEV;
187		210
		211	/*
		212	* Cache the original control MSR value before the control MSR is
		213	* changed. This is the only place where orig_umwait_control_cached
		214	* is modified.
		215	*/
		216	rdmsrl(MSR_IA32_UMWAIT_CONTROL, orig_umwait_control_cached);
		217
188	ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "umwait:online",	218	ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "umwait:online",
189	umwait_cpu_online, NULL);	219	umwait_cpu_online, umwait_cpu_offline);
		220	if (ret < 0) {
		221	/*
		222	* On failure, the control MSR on all CPUs has the
		223	* original control value.
		224	*/
		225	return ret;
		226	}
190		227
191	register_syscore_ops(&umwait_syscore_ops);	228	register_syscore_ops(&umwait_syscore_ops);
192		229

arch/x86/kernel/kvm.c+0−8

 static void kvm_guest_cpu_init(void)
 {
-	if (!kvm_para_available())
-		return;
 	if (kvm_para_has_feature(KVM_FEATURE_ASYNC_PF) && kvmapf) {
 		u64 pa = slow_virt_to_phys(this_cpu_ptr(&apf_reason));
 {
 	int i;
-	if (!kvm_para_available())
-		return;
 	paravirt_ops_setup();
 	register_reboot_notifier(&kvm_pv_reboot_nb);
 	for (i = 0; i < KVM_TASK_SLEEP_HASHSIZE; i++)
  */
 void __init kvm_spinlock_init(void)
 {
-	if (!kvm_para_available())
-		return;
 	/* Does host kernel support KVM_FEATURE_PV_UNHALT? */
 	if (!kvm_para_has_feature(KVM_FEATURE_PV_UNHALT))
 		return;

arch/x86/kernel/ptrace.c+1−0

@@ -201,6 +201,7 @@ static int set_segment_reg(struct task_struct *task, · 200 unmodified lines
201	case offsetof(struct user_regs_struct, ss):	201	case offsetof(struct user_regs_struct, ss):
202	if (unlikely(value == 0))	202	if (unlikely(value == 0))
203	return -EIO;	203	return -EIO;
		204	/* Else, fall through */
204		205
205	default:	206	default:
206	*pt_regs_access(task_pt_regs(task), offset) = value;	207	*pt_regs_access(task_pt_regs(task), offset) = value;

arch/x86/kvm/debugfs.c+13−33

@@ -8,11 +8,6 @@ · 7 unmodified lines
8	#include <linux/debugfs.h>	8	#include <linux/debugfs.h>
9	#include "lapic.h"	9	#include "lapic.h"
10		10
11	bool kvm_arch_has_vcpu_debugfs(void)
12	{
13	return true;
14	}
15
16	static int vcpu_get_timer_advance_ns(void data, u64 val)	11	static int vcpu_get_timer_advance_ns(void data, u64 val)
17	{	12	{
18	struct kvm_vcpu vcpu = (struct kvm_vcpu ) data;	13	struct kvm_vcpu vcpu = (struct kvm_vcpu ) data;
@@ -48,37 +43,22 @@ static int vcpu_get_tsc_scaling_frac_bits(void data, u64 val) · 29 unmodified lines
48		43
49	DEFINE_SIMPLE_ATTRIBUTE(vcpu_tsc_scaling_frac_fops, vcpu_get_tsc_scaling_frac_bits, NULL, "%llu\n");	44	DEFINE_SIMPLE_ATTRIBUTE(vcpu_tsc_scaling_frac_fops, vcpu_get_tsc_scaling_frac_bits, NULL, "%llu\n");
50		45
51	int kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu)	46	void kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu)
52	{	47	{
53	struct dentry *ret;	48	debugfs_create_file("tsc-offset", 0444, vcpu->debugfs_dentry, vcpu,
54		49	&vcpu_tsc_offset_fops);
55	ret = debugfs_create_file("tsc-offset", 0444,
56	vcpu->debugfs_dentry,
57	vcpu, &vcpu_tsc_offset_fops);
58	if (!ret)
59	return -ENOMEM;
60		50
61	if (lapic_in_kernel(vcpu)) {	51	if (lapic_in_kernel(vcpu))
62	ret = debugfs_create_file("lapic_timer_advance_ns", 0444,	52	debugfs_create_file("lapic_timer_advance_ns", 0444,
63	vcpu->debugfs_dentry,	53	vcpu->debugfs_dentry, vcpu,
64	vcpu, &vcpu_timer_advance_ns_fops);	54	&vcpu_timer_advance_ns_fops);
65	if (!ret)
66	return -ENOMEM;
67	}
68		55
69	if (kvm_has_tsc_control) {	56	if (kvm_has_tsc_control) {
70	ret = debugfs_create_file("tsc-scaling-ratio", 0444,	57	debugfs_create_file("tsc-scaling-ratio", 0444,
71	vcpu->debugfs_dentry,	58	vcpu->debugfs_dentry, vcpu,
72	vcpu, &vcpu_tsc_scaling_fops);	59	&vcpu_tsc_scaling_fops);
73	if (!ret)	60	debugfs_create_file("tsc-scaling-ratio-frac-bits", 0444,
74	return -ENOMEM;	61	vcpu->debugfs_dentry, vcpu,
75	ret = debugfs_create_file("tsc-scaling-ratio-frac-bits", 0444,	62	&vcpu_tsc_scaling_frac_fops);
76	vcpu->debugfs_dentry,
77	vcpu, &vcpu_tsc_scaling_frac_fops);
78	if (!ret)
79	return -ENOMEM;
80
81	}	63	}
82
83	return 0;
84	}	64	}

arch/x86/kvm/lapic.c+0−8

 static void apic_timer_expired(struct kvm_lapic *apic)
 {
 	struct kvm_vcpu *vcpu = apic->vcpu;
-	struct swait_queue_head *q = &vcpu->wq;
 	struct kvm_timer *ktimer = &apic->lapic_timer;
 	if (atomic_read(&apic->lapic_timer.pending))
 	atomic_inc(&apic->lapic_timer.pending);
 	kvm_set_pending_timer(vcpu);
-	/*
-	 * For x86, the atomic_inc() is serialized, thus
-	 * using swait_active() is safe.
-	 */
-	if (swait_active(q))
-		swake_up_one(q);
 }
 static void start_sw_tscdeadline(struct kvm_lapic *apic)

arch/x86/kvm/svm.c+6−0

 		kvm_vcpu_wake_up(vcpu);
 }
+static bool svm_dy_apicv_has_pending_interrupt(struct kvm_vcpu *vcpu)
+{
+	return false;
+}
 static void svm_ir_list_del(struct vcpu_svm *svm, struct amd_iommu_pi_data *pi)
 {
 	unsigned long flags;
 	.pmu_ops = &amd_pmu_ops,
 	.deliver_posted_interrupt = svm_deliver_avic_intr,
+	.dy_apicv_has_pending_interrupt = svm_dy_apicv_has_pending_interrupt,
 	.update_pi_irte = svm_update_pi_irte,
 	.setup_mce = svm_setup_mce,

arch/x86/kvm/vmx/vmx.c+6−0

 	return max_irr;
 }
+static bool vmx_dy_apicv_has_pending_interrupt(struct kvm_vcpu *vcpu)
+{
+	return pi_test_on(vcpu_to_pi_desc(vcpu));
+}
 static void vmx_load_eoi_exitmap(struct kvm_vcpu *vcpu, u64 *eoi_exit_bitmap)
 {
 	if (!kvm_vcpu_apicv_active(vcpu))
 	.guest_apic_has_interrupt = vmx_guest_apic_has_interrupt,
 	.sync_pir_to_irr = vmx_sync_pir_to_irr,
 	.deliver_posted_interrupt = vmx_deliver_posted_interrupt,
+	.dy_apicv_has_pending_interrupt = vmx_dy_apicv_has_pending_interrupt,
 	.set_tss_addr = vmx_set_tss_addr,
 	.set_identity_map_addr = vmx_set_identity_map_addr,

arch/x86/kvm/x86.c+16−0

@@ -9698,6 +9698,22 @@ int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu) · 9697 unmodified lines
9698	return kvm_vcpu_running(vcpu) \|\| kvm_vcpu_has_events(vcpu);	9698	return kvm_vcpu_running(vcpu) \|\| kvm_vcpu_has_events(vcpu);
9699	}	9699	}
9700		9700
		9701	bool kvm_arch_dy_runnable(struct kvm_vcpu *vcpu)
		9702	{
		9703	if (READ_ONCE(vcpu->arch.pv.pv_unhalted))
		9704	return true;
		9705
		9706	if (kvm_test_request(KVM_REQ_NMI, vcpu) \|\|
		9707	kvm_test_request(KVM_REQ_SMI, vcpu) \|\|
		9708	kvm_test_request(KVM_REQ_EVENT, vcpu))
		9709	return true;
		9710
		9711	if (vcpu->arch.apicv_active && kvm_x86_ops->dy_apicv_has_pending_interrupt(vcpu))
		9712	return true;
		9713
		9714	return false;
		9715	}
		9716
9701	bool kvm_arch_vcpu_in_kernel(struct kvm_vcpu *vcpu)	9717	bool kvm_arch_vcpu_in_kernel(struct kvm_vcpu *vcpu)
9702	{	9718	{
9703	return vcpu->arch.preempted_in_kernel;	9719	return vcpu->arch.preempted_in_kernel;

arch/x86/lib/cpu.c+1−0

@@ -1,6 +1,7 @@
1	// SPDX-License-Identifier: GPL-2.0-only	1	// SPDX-License-Identifier: GPL-2.0-only
2	#include <linux/types.h>	2	#include <linux/types.h>
3	#include <linux/export.h>	3	#include <linux/export.h>
		4	#include <asm/cpu.h>
4		5
5	unsigned int x86_family(unsigned int sig)	6	unsigned int x86_family(unsigned int sig)
6	{	7	{

arch/x86/math-emu/errors.c+3−2

 	for (i = 0; i < 8; i++) {
 		FPU_REG *r = &st(i);
 		u_char tagi = FPU_gettagi(i);
 		switch (tagi) {
 		case TAG_Empty:
 			continue;
-			break;
 		case TAG_Zero:
 		case TAG_Special:
+			/* Update tagi for the printk below */
 			tagi = FPU_Special(r);
+			/* fall through */
 		case TAG_Valid:
 			printk("st(%d)  %c .%04lx %04lx %04lx %04lx e%+-6d ", i,
 			       getsign(r) ? '-' : '+',
 			printk("Whoops! Error in errors.c: tag%d is %d ", i,
 			       tagi);
 			continue;
-			break;
 		}
 		printk("%s\n", tag_desc[(int)(unsigned)tagi]);
 	}

arch/x86/math-emu/fpu_trig.c+1−1

@@ -1352,7 +1352,7 @@ static void fyl2xp1(FPU_REG *st0_ptr, u_char st0_tag) · 1351 unmodified lines
1352	case TW_Denormal:	1352	case TW_Denormal:
1353	if (denormal_operand() < 0)	1353	if (denormal_operand() < 0)
1354	return;	1354	return;
1355		1355	/* fall through */
1356	case TAG_Zero:	1356	case TAG_Zero:
1357	case TAG_Valid:	1357	case TAG_Valid:
1358	setsign(st0_ptr, getsign(st0_ptr) ^ getsign(st1_ptr));	1358	setsign(st0_ptr, getsign(st0_ptr) ^ getsign(st1_ptr));

arch/x86/net/bpf_jit_comp.c+5−4

 	emit_prologue(&prog, bpf_prog->aux->stack_depth,
 		      bpf_prog_was_classic(bpf_prog));
+	addrs[0] = prog - temp;
-	for (i = 0; i < insn_cnt; i++, insn++) {
+	for (i = 1; i <= insn_cnt; i++, insn++) {
 		const s32 imm32 = insn->imm;
 		u32 dst_reg = insn->dst_reg;
 		u32 src_reg = insn->src_reg;
 		extra_pass = true;
 		goto skip_init_addrs;
 	}
-	addrs = kmalloc_array(prog->len, sizeof(*addrs), GFP_KERNEL);
+	addrs = kmalloc_array(prog->len + 1, sizeof(*addrs), GFP_KERNEL);
 	if (!addrs) {
 		prog = orig_prog;
 		goto out_addrs;
 	 * Before first pass, make a rough estimation of addrs[]
 	 * each BPF instruction is translated to less than 64 bytes
 	 */
-	for (proglen = 0, i = 0; i < prog->len; i++) {
+	for (proglen = 0, i = 0; i <= prog->len; i++) {
 		proglen += 64;
 		addrs[i] = proglen;
 	}
 	if (!image || !prog->is_func || extra_pass) {
 		if (image)
-			bpf_prog_fill_jited_linfo(prog, addrs);
+			bpf_prog_fill_jited_linfo(prog, addrs + 1);
 out_addrs:
 		kfree(addrs);
 		kfree(jit_data);

arch/x86/purgatory/Makefile+31−5

@@ -6,6 +6,9 @@ purgatory-y := purgatory.o stack.o setup-x86_$(BITS).o sha256.o entry64.o string · 5 unmodified lines
6	targets += $(purgatory-y)	6	targets += $(purgatory-y)
7	PURGATORY_OBJS = $(addprefix $(obj)/,$(purgatory-y))	7	PURGATORY_OBJS = $(addprefix $(obj)/,$(purgatory-y))
8		8
		9	$(obj)/string.o: $(srctree)/arch/x86/boot/compressed/string.c FORCE
		10	$(call if_changed_rule,cc_o_c)
		11
9	$(obj)/sha256.o: $(srctree)/lib/sha256.c FORCE	12	$(obj)/sha256.o: $(srctree)/lib/sha256.c FORCE
10	$(call if_changed_rule,cc_o_c)	13	$(call if_changed_rule,cc_o_c)
11		14
@@ -17,11 +20,34 @@ KCOV_INSTRUMENT := n · 5 unmodified lines
17		20
18	# Default KBUILD_CFLAGS can have -pg option set when FTRACE is enabled. That	21	# Default KBUILD_CFLAGS can have -pg option set when FTRACE is enabled. That
19	# in turn leaves some undefined symbols like __fentry__ in purgatory and not	22	# in turn leaves some undefined symbols like __fentry__ in purgatory and not
20	# sure how to relocate those. Like kexec-tools, use custom flags.	23	# sure how to relocate those.
21		24	ifdef CONFIG_FUNCTION_TRACER
22	KBUILD_CFLAGS := -fno-strict-aliasing -Wall -Wstrict-prototypes -fno-zero-initialized-in-bss -fno-builtin -ffreestanding -c -Os -mcmodel=large	25	CFLAGS_REMOVE_sha256.o += $(CC_FLAGS_FTRACE)
23	KBUILD_CFLAGS += -m$(BITS)	26	CFLAGS_REMOVE_purgatory.o += $(CC_FLAGS_FTRACE)
24	KBUILD_CFLAGS += $(call cc-option,-fno-PIE)	27	CFLAGS_REMOVE_string.o += $(CC_FLAGS_FTRACE)
		28	CFLAGS_REMOVE_kexec-purgatory.o += $(CC_FLAGS_FTRACE)
		29	endif
		30
		31	ifdef CONFIG_STACKPROTECTOR
		32	CFLAGS_REMOVE_sha256.o += -fstack-protector
		33	CFLAGS_REMOVE_purgatory.o += -fstack-protector
		34	CFLAGS_REMOVE_string.o += -fstack-protector
		35	CFLAGS_REMOVE_kexec-purgatory.o += -fstack-protector
		36	endif
		37
		38	ifdef CONFIG_STACKPROTECTOR_STRONG
		39	CFLAGS_REMOVE_sha256.o += -fstack-protector-strong
		40	CFLAGS_REMOVE_purgatory.o += -fstack-protector-strong
		41	CFLAGS_REMOVE_string.o += -fstack-protector-strong
		42	CFLAGS_REMOVE_kexec-purgatory.o += -fstack-protector-strong
		43	endif
		44
		45	ifdef CONFIG_RETPOLINE
		46	CFLAGS_REMOVE_sha256.o += $(RETPOLINE_CFLAGS)
		47	CFLAGS_REMOVE_purgatory.o += $(RETPOLINE_CFLAGS)
		48	CFLAGS_REMOVE_string.o += $(RETPOLINE_CFLAGS)
		49	CFLAGS_REMOVE_kexec-purgatory.o += $(RETPOLINE_CFLAGS)
		50	endif
25		51
26	$(obj)/purgatory.ro: $(PURGATORY_OBJS) FORCE	52	$(obj)/purgatory.ro: $(PURGATORY_OBJS) FORCE
27	$(call if_changed,ld)	53	$(call if_changed,ld)

arch/x86/purgatory/purgatory.c+6−0

@@ -68,3 +68,9 @@ void purgatory(void) · 67 unmodified lines
68	}	68	}
69	copy_backup_region();	69	copy_backup_region();
70	}	70	}
		71
		72	/*
		73	* Defined in order to reuse memcpy() and memset() from
		74	* arch/x86/boot/compressed/string.c
		75	*/
		76	void warn(const char *msg) {}

arch/x86/purgatory/string.c+0−23

@@ -1,23 +0,0 @@
1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* Simple string functions.
4	*
5	* Copyright (C) 2014 Red Hat Inc.
6	*
7	* Author:
8	* Vivek Goyal <vgoyal@redhat.com>
9	*/
10
11	#include <linux/types.h>
12
13	#include "../boot/string.c"
14
15	void memcpy(void dst, const void *src, size_t len)
16	{
17	return __builtin_memcpy(dst, src, len);
18	}
19
20	void memset(void dst, int c, size_t len)
21	{
22	return __builtin_memset(dst, c, len);
23	}

arch/xtensa/kernel/setup.c+1−0

@@ -511,6 +511,7 @@ void cpu_reset(void) · 510 unmodified lines
511	"add %2, %2, %7\n\t"	511	"add %2, %2, %7\n\t"
512	"addi %0, %0, -1\n\t"	512	"addi %0, %0, -1\n\t"
513	"bnez %0, 1b\n\t"	513	"bnez %0, 1b\n\t"
		514	"isync\n\t"
514	/* Jump to identity mapping */	515	/* Jump to identity mapping */
515	"jx %3\n"	516	"jx %3\n"
516	"2:\n\t"	517	"2:\n\t"

block/bfq-iosched.c+47−21

 		 * confirmed no later than during the next
 		 * I/O-plugging interval for bfqq.
 		 */
-		if (!bfq_bfqq_has_short_ttime(bfqq) &&
+		if (bfqd->last_completed_rq_bfqq &&
+		    !bfq_bfqq_has_short_ttime(bfqq) &&
 		    ktime_get_ns() - bfqd->last_completion <
 		    200 * NSEC_PER_USEC) {
 			if (bfqd->last_completed_rq_bfqq != bfqq &&
-				   bfqd->last_completed_rq_bfqq !=
+			    bfqd->last_completed_rq_bfqq !=
-				   bfqq->waker_bfqq) {
+			    bfqq->waker_bfqq) {
 				/*
 				 * First synchronization detected with
 				 * a candidate waker queue, or with a
 	    blk_rq_pos(container_of(rb_prev(&req->rb_node),
 				    struct request, rb_node))) {
 		struct bfq_queue *bfqq = bfq_init_rq(req);
-		struct bfq_data *bfqd = bfqq->bfqd;
+		struct bfq_data *bfqd;
 		struct request *prev, *next_rq;
+		if (!bfqq)
+			return;
+		bfqd = bfqq->bfqd;
 		/* Reposition request in its sort_list */
 		elv_rb_del(&bfqq->sort_list, req);
 		elv_rb_add(&bfqq->sort_list, req);
 	struct bfq_queue *bfqq = bfq_init_rq(rq),
 		*next_bfqq = bfq_init_rq(next);
+	if (!bfqq)
+		return;
 	/*
 	 * If next and rq belong to the same bfq_queue and next is older
 	 * than rq, then reposition rq in the fifo (by substituting next
  */
 void bfq_put_queue(struct bfq_queue *bfqq)
 {
+	struct bfq_queue *item;
+	struct hlist_node *n;
 #ifdef CONFIG_BFQ_GROUP_IOSCHED
 	struct bfq_group *bfqg = bfqq_group(bfqq);
 #endif
 			bfqq->bfqd->burst_size--;
 	}
+	/*
+	 * bfqq does not exist any longer, so it cannot be woken by
+	 * any other queue, and cannot wake any other queue. Then bfqq
+	 * must be removed from the woken list of its possible waker
+	 * queue, and all queues in the woken list of bfqq must stop
+	 * having a waker queue. Strictly speaking, these updates
+	 * should be performed when bfqq remains with no I/O source
+	 * attached to it, which happens before bfqq gets freed. In
+	 * particular, this happens when the last process associated
+	 * with bfqq exits or gets associated with a different
+	 * queue. However, both events lead to bfqq being freed soon,
+	 * and dangling references would come out only after bfqq gets
+	 * freed. So these updates are done here, as a simple and safe
+	 * way to handle all cases.
+	 */
+	/* remove bfqq from woken list */
+	if (!hlist_unhashed(&bfqq->woken_list_node))
+		hlist_del_init(&bfqq->woken_list_node);
+	/* reset waker for all queues in woken list */
+	hlist_for_each_entry_safe(item, n, &bfqq->woken_list,
+				  woken_list_node) {
+		item->waker_bfqq = NULL;
+		bfq_clear_bfqq_has_waker(item);
+		hlist_del_init(&item->woken_list_node);
+	}
+	if (bfqq->bfqd && bfqq->bfqd->last_completed_rq_bfqq == bfqq)
+		bfqq->bfqd->last_completed_rq_bfqq = NULL;
 	kmem_cache_free(bfq_pool, bfqq);
 #ifdef CONFIG_BFQ_GROUP_IOSCHED
 	bfqg_and_blkg_put(bfqg);
 static void bfq_exit_bfqq(struct bfq_data *bfqd, struct bfq_queue *bfqq)
 {
-	struct bfq_queue *item;
-	struct hlist_node *n;
 	if (bfqq == bfqd->in_service_queue) {
 		__bfq_bfqq_expire(bfqd, bfqq, BFQQE_BUDGET_TIMEOUT);
 		bfq_schedule_dispatch(bfqd);
 	bfq_put_cooperator(bfqq);
-	/* remove bfqq from woken list */
-	if (!hlist_unhashed(&bfqq->woken_list_node))
-		hlist_del_init(&bfqq->woken_list_node);
-	/* reset waker for all queues in woken list */
-	hlist_for_each_entry_safe(item, n, &bfqq->woken_list,
-				  woken_list_node) {
-		item->waker_bfqq = NULL;
-		bfq_clear_bfqq_has_waker(item);
-		hlist_del_init(&item->woken_list_node);
-	}
 	bfq_put_queue(bfqq); /* release process reference */
 }
 	spin_lock_irq(&bfqd->lock);
 	bfqq = bfq_init_rq(rq);
-	if (at_head || blk_rq_is_passthrough(rq)) {
+	if (!bfqq || at_head || blk_rq_is_passthrough(rq)) {
 		if (at_head)
 			list_add(&rq->queuelist, &bfqd->dispatch);
 		else
 			list_add_tail(&rq->queuelist, &bfqd->dispatch);
-	} else { /* bfqq is assumed to be non null here */
+	} else {
 		idle_timer_disabled = __bfq_insert_request(bfqd, rq);
 		/*
 		 * Update bfqq, because, if a queue merge has occurred

block/blk-mq.c+2−8

@@ -1958,13 +1958,9 @@ static blk_qc_t blk_mq_make_request(struct request_queue q, struct bio bio) · 1957 unmodified lines
1958	rq = blk_mq_get_request(q, bio, &data);	1958	rq = blk_mq_get_request(q, bio, &data);
1959	if (unlikely(!rq)) {	1959	if (unlikely(!rq)) {
1960	rq_qos_cleanup(q, bio);	1960	rq_qos_cleanup(q, bio);
1961		1961	if (bio->bi_opf & REQ_NOWAIT)
1962	cookie = BLK_QC_T_NONE;
1963	if (bio->bi_opf & REQ_NOWAIT_INLINE)
1964	cookie = BLK_QC_T_EAGAIN;
1965	else if (bio->bi_opf & REQ_NOWAIT)
1966	bio_wouldblock_error(bio);	1962	bio_wouldblock_error(bio);
1967	return cookie;	1963	return BLK_QC_T_NONE;
1968	}	1964	}
1969		1965
1970	trace_block_getrq(q, bio, bio->bi_opf);	1966	trace_block_getrq(q, bio, bio->bi_opf);
@@ -2666,8 +2662,6 @@ void blk_mq_release(struct request_queue *q) · 695 unmodified lines
2666	struct blk_mq_hw_ctx hctx, next;	2662	struct blk_mq_hw_ctx hctx, next;
2667	int i;	2663	int i;
2668		2664
2669	cancel_delayed_work_sync(&q->requeue_work);
2670
2671	queue_for_each_hw_ctx(q, hctx, i)	2665	queue_for_each_hw_ctx(q, hctx, i)
2672	WARN_ON_ONCE(hctx && list_empty(&hctx->hctx_list));	2666	WARN_ON_ONCE(hctx && list_empty(&hctx->hctx_list));
2673		2667

block/blk-sysfs.c+3−0

@@ -892,6 +892,9 @@ static void __blk_release_queue(struct work_struct *work) · 891 unmodified lines
892		892
893	blk_free_queue_stats(q->stats);	893	blk_free_queue_stats(q->stats);
894		894
		895	if (queue_is_mq(q))
		896	cancel_delayed_work_sync(&q->requeue_work);
		897
895	blk_exit_queue(q);	898	blk_exit_queue(q);
896		899
897	blk_queue_free_zone_bitmaps(q);	900	blk_queue_free_zone_bitmaps(q);

drivers/ata/libata-scsi.c+21−0

 	return 1;
 }
+static bool ata_check_nblocks(struct scsi_cmnd *scmd, u32 n_blocks)
+{
+	struct request *rq = scmd->request;
+	u32 req_blocks;
+	if (!blk_rq_is_passthrough(rq))
+		return true;
+	req_blocks = blk_rq_bytes(rq) / scmd->device->sector_size;
+	if (n_blocks > req_blocks)
+		return false;
+	return true;
+}
 /**
  *	ata_scsi_rw_xlat - Translate SCSI r/w command into an ATA one
  *	@qc: Storage for translated ATA taskfile
 		scsi_10_lba_len(cdb, &block, &n_block);
 		if (cdb[1] & (1 << 3))
 			tf_flags |= ATA_TFLAG_FUA;
+		if (!ata_check_nblocks(scmd, n_block))
+			goto invalid_fld;
 		break;
 	case READ_6:
 	case WRITE_6:
 		 */
 		if (!n_block)
 			n_block = 256;
+		if (!ata_check_nblocks(scmd, n_block))
+			goto invalid_fld;
 		break;
 	case READ_16:
 	case WRITE_16:
 		scsi_16_lba_len(cdb, &block, &n_block);
 		if (cdb[1] & (1 << 3))
 			tf_flags |= ATA_TFLAG_FUA;
+		if (!ata_check_nblocks(scmd, n_block))
+			goto invalid_fld;
 		break;
 	default:
 		DPRINTK("no-byte command\n");

drivers/ata/libata-sff.c+6−0

 	unsigned int offset;
 	unsigned char *buf;
+	if (!qc->cursg) {
+		qc->curbytes = qc->nbytes;
+		return;
+	}
 	if (qc->curbytes == qc->nbytes - qc->sect_size)
 		ap->hsm_task_state = HSM_ST_LAST;
 	if (qc->cursg_ofs == qc->cursg->length) {
 		qc->cursg = sg_next(qc->cursg);
+		if (!qc->cursg)
+			ap->hsm_task_state = HSM_ST_LAST;
 		qc->cursg_ofs = 0;
 	}
 }

drivers/ata/pata_rb532_cf.c+0−1

@@ -158,7 +158,6 @@ static int rb532_pata_driver_probe(struct platform_device *pdev) · 157 unmodified lines
158	static int rb532_pata_driver_remove(struct platform_device *pdev)	158	static int rb532_pata_driver_remove(struct platform_device *pdev)
159	{	159	{
160	struct ata_host *ah = platform_get_drvdata(pdev);	160	struct ata_host *ah = platform_get_drvdata(pdev);
161	struct rb532_cf_info *info = ah->private_data;
162		161
163	ata_host_detach(ah);	162	ata_host_detach(ah);
164		163

drivers/auxdisplay/Kconfig+5−0

 choice
 	prompt "Backlight initial state"
 	default CHARLCD_BL_FLASH
+	---help---
+	  Select the initial backlight state on boot or module load.
+	  Previously, there was no option for this: the backlight flashed
+	  briefly on init. Now you can also turn it off/on.
 	config CHARLCD_BL_OFF
 		bool "Off"

drivers/auxdisplay/charlcd.c+1−1

@@ -20,7 +20,7 @@ · 19 unmodified lines
20		20
21	#include <generated/utsrelease.h>	21	#include <generated/utsrelease.h>
22		22
23	#include <misc/charlcd.h>	23	#include "charlcd.h"
24		24
25	#define LCD_MINOR 156	25	#define LCD_MINOR 156
26		26

drivers/auxdisplay/charlcd.hrenamed from include/misc/charlcd.h+5−0

  * Copyright (C) 2016-2017 Glider bvba
  */
+#ifndef _CHARLCD_H
+#define _CHARLCD_H
 struct charlcd {
 	const struct charlcd_ops *ops;
 	const unsigned char *char_conv;	/* Optional */
 int charlcd_unregister(struct charlcd *lcd);
 void charlcd_poke(struct charlcd *lcd);
+#endif /* CHARLCD_H */

drivers/auxdisplay/hd44780.c+1−2

@@ -14,8 +14,7 @@ · 13 unmodified lines
14	#include <linux/property.h>	14	#include <linux/property.h>
15	#include <linux/slab.h>	15	#include <linux/slab.h>
16		16
17	#include <misc/charlcd.h>	17	#include "charlcd.h"
18
19		18
20	enum hd44780_pin {	19	enum hd44780_pin {
21	/* Order does matter due to writing to GPIO array subsets! */	20	/* Order does matter due to writing to GPIO array subsets! */

drivers/auxdisplay/panel.c+3−1

 #include <linux/io.h>
 #include <linux/uaccess.h>
-#include <misc/charlcd.h>
+#include "charlcd.h"
 #define KEYPAD_MINOR		185
 	return;
 err_lcd_unreg:
+	if (scan_timer.function)
+		del_timer_sync(&scan_timer);
 	if (lcd.enabled)
 		charlcd_unregister(lcd.charlcd);
 err_unreg_device:

drivers/base/core.c+52−1

@@ -1823,12 +1823,63 @@ static inline struct kobject get_glue_dir(struct device dev) · 1822 unmodified lines
1823	*/	1823	*/
1824	static void cleanup_glue_dir(struct device dev, struct kobject glue_dir)	1824	static void cleanup_glue_dir(struct device dev, struct kobject glue_dir)
1825	{	1825	{
		1826	unsigned int ref;
		1827
1826	/* see if we live in a "glue" directory */	1828	/* see if we live in a "glue" directory */
1827	if (!live_in_glue_dir(glue_dir, dev))	1829	if (!live_in_glue_dir(glue_dir, dev))
1828	return;	1830	return;
1829		1831
1830	mutex_lock(&gdp_mutex);	1832	mutex_lock(&gdp_mutex);
1831	if (!kobject_has_children(glue_dir))	1833	/**
		1834	* There is a race condition between removing glue directory
		1835	* and adding a new device under the glue directory.
		1836	*
		1837	* CPU1: CPU2:
		1838	*
		1839	* device_add()
		1840	* get_device_parent()
		1841	* class_dir_create_and_add()
		1842	* kobject_add_internal()
		1843	* create_dir() // create glue_dir
		1844	*
		1845	* device_add()
		1846	* get_device_parent()
		1847	* kobject_get() // get glue_dir
		1848	*
		1849	* device_del()
		1850	* cleanup_glue_dir()
		1851	* kobject_del(glue_dir)
		1852	*
		1853	* kobject_add()
		1854	* kobject_add_internal()
		1855	* create_dir() // in glue_dir
		1856	* sysfs_create_dir_ns()
		1857	* kernfs_create_dir_ns(sd)
		1858	*
		1859	* sysfs_remove_dir() // glue_dir->sd=NULL
		1860	* sysfs_put() // free glue_dir->sd
		1861	*
		1862	* // sd is freed
		1863	* kernfs_new_node(sd)
		1864	* kernfs_get(glue_dir)
		1865	* kernfs_add_one()
		1866	* kernfs_put()
		1867	*
		1868	* Before CPU1 remove last child device under glue dir, if CPU2 add
		1869	* a new device under glue dir, the glue_dir kobject reference count
		1870	* will be increase to 2 in kobject_get(k). And CPU2 has been called
		1871	* kernfs_create_dir_ns(). Meanwhile, CPU1 call sysfs_remove_dir()
		1872	* and sysfs_put(). This result in glue_dir->sd is freed.
		1873	*
		1874	* Then the CPU2 will see a stale "empty" but still potentially used
		1875	* glue dir around in kernfs_new_node().
		1876	*
		1877	* In order to avoid this happening, we also should make sure that
		1878	* kernfs_node for glue_dir is released in CPU1 only when refcount
		1879	* for glue_dir kobj is 1.
		1880	*/
		1881	ref = kref_read(&glue_dir->kref);
		1882	if (!kobject_has_children(glue_dir) && !--ref)
1832	kobject_del(glue_dir);	1883	kobject_del(glue_dir);
1833	kobject_put(glue_dir);	1884	kobject_put(glue_dir);
1834	mutex_unlock(&gdp_mutex);	1885	mutex_unlock(&gdp_mutex);

drivers/base/platform.c+7−2

 	 * the device will only expose one IRQ, and this fallback
 	 * allows a common code path across either kind of resource.
 	 */
-	if (num == 0 && has_acpi_companion(&dev->dev))
+	if (num == 0 && has_acpi_companion(&dev->dev)) {
-		return acpi_dev_gpio_irq_get(ACPI_COMPANION(&dev->dev), num);
+		int ret = acpi_dev_gpio_irq_get(ACPI_COMPANION(&dev->dev), num);
+		/* Our callers expect -ENXIO for missing IRQs. */
+		if (ret >= 0 || ret == -EPROBE_DEFER)
+			return ret;
+	}
 	return -ENXIO;
 #endif

drivers/base/regmap/Kconfig+1−1

@@ -44,7 +44,7 @@ config REGMAP_IRQ · 43 unmodified lines
44		44
45	config REGMAP_SOUNDWIRE	45	config REGMAP_SOUNDWIRE
46	tristate	46	tristate
47	depends on SOUNDWIRE_BUS	47	depends on SOUNDWIRE
48		48
49	config REGMAP_SCCB	49	config REGMAP_SCCB
50	tristate	50	tristate

drivers/block/aoe/aoedev.c+10−3

 	}
 	flush_scheduled_work();
-	/* pass one: without sleeping, do aoedev_downdev */
+	/* pass one: do aoedev_downdev, which might sleep */
+restart1:
 	spin_lock_irqsave(&devlist_lock, flags);
 	for (d = devlist; d; d = d->next) {
 		spin_lock(&d->lock);
+		if (d->flags & DEVFL_TKILL)
+			goto cont;
 		if (exiting) {
 			/* unconditionally take each device down */
 		} else if (specified) {
 		|| d->ref)
 			goto cont;
+		spin_unlock(&d->lock);
+		spin_unlock_irqrestore(&devlist_lock, flags);
 		aoedev_downdev(d);
 		d->flags |= DEVFL_TKILL;
+		goto restart1;
 cont:
 		spin_unlock(&d->lock);
 	}
 	/* pass two: call freedev, which might sleep,
 	 * for aoedevs marked with DEVFL_TKILL
 	 */
-restart:
+restart2:
 	spin_lock_irqsave(&devlist_lock, flags);
 	for (d = devlist; d; d = d->next) {
 		spin_lock(&d->lock);
 			spin_unlock(&d->lock);
 			spin_unlock_irqrestore(&devlist_lock, flags);
 			freedev(d);
-			goto restart;
+			goto restart2;
 		}
 		spin_unlock(&d->lock);
 	}

drivers/block/loop.c+1−1

@@ -885,7 +885,7 @@ static void loop_unprepare_queue(struct loop_device *lo) · 884 unmodified lines
885		885
886	static int loop_kthread_worker_fn(void *worker_ptr)	886	static int loop_kthread_worker_fn(void *worker_ptr)
887	{	887	{
888	current->flags \|= PF_LESS_THROTTLE;	888	current->flags \|= PF_LESS_THROTTLE \| PF_MEMALLOC_NOIO;
889	return kthread_worker_fn(worker_ptr);	889	return kthread_worker_fn(worker_ptr);
890	}	890	}
891		891

drivers/block/xen-blkback/xenbus.c+3−3

 		}
 	}
+	err = -ENOMEM;
 	for (i = 0; i < nr_grefs * XEN_BLKIF_REQS_PER_PAGE; i++) {
 		req = kzalloc(sizeof(*req), GFP_KERNEL);
 		if (!req)
 	err = xen_blkif_map(ring, ring_ref, nr_grefs, evtchn);
 	if (err) {
 		xenbus_dev_fatal(dev, err, "mapping ring-ref port %u", evtchn);
-		return err;
+		goto fail;
 	}
 	return 0;
 		}
 		kfree(req);
 	}
-	return -ENOMEM;
+	return err;
 }
 static int connect_ring(struct backend_info *be)

drivers/bluetooth/btqca.c+27−2

 	return 0;
 }
+int qca_send_pre_shutdown_cmd(struct hci_dev *hdev)
+{
+	struct sk_buff *skb;
+	int err;
+	bt_dev_dbg(hdev, "QCA pre shutdown cmd");
+	skb = __hci_cmd_sync(hdev, QCA_PRE_SHUTDOWN_CMD, 0,
+				NULL, HCI_INIT_TIMEOUT);
+	if (IS_ERR(skb)) {
+		err = PTR_ERR(skb);
+		bt_dev_err(hdev, "QCA preshutdown_cmd failed (%d)", err);
+		return err;
+	}
+	kfree_skb(skb);
+	return 0;
+}
+EXPORT_SYMBOL_GPL(qca_send_pre_shutdown_cmd);
 static void qca_tlv_check_data(struct rome_config *config,
 				const struct firmware *fw)
 {
 	BT_DBG("Length\t\t : %d bytes", length);
 	config->dnld_mode = ROME_SKIP_EVT_NONE;
+	config->dnld_type = ROME_SKIP_EVT_NONE;
 	switch (config->type) {
 	case TLV_TYPE_PATCH:
 	evt = skb_put(skb, sizeof(*evt));
 	evt->ncmd = 1;
-	evt->opcode = QCA_HCI_CC_OPCODE;
+	evt->opcode = cpu_to_le16(QCA_HCI_CC_OPCODE);
 	skb_put_u8(skb, QCA_HCI_CC_SUCCESS);
 	 */
 	if (config->dnld_type == ROME_SKIP_EVT_VSE_CC ||
 	    config->dnld_type == ROME_SKIP_EVT_VSE)
-		return qca_inject_cmd_complete_event(hdev);
+		ret = qca_inject_cmd_complete_event(hdev);
 out:
 	release_firmware(fw);
 		return err;
 	}
+	/* Give the controller some time to get ready to receive the NVM */
+	msleep(10);
 	/* Download NVM configuration */
 	config.type = TLV_TYPE_NVM;
 	if (firmware_name)

drivers/bluetooth/btqca.h+7−0

 #define EDL_PATCH_TLV_REQ_CMD		(0x1E)
 #define EDL_NVM_ACCESS_SET_REQ_CMD	(0x01)
 #define MAX_SIZE_PER_TLV_SEGMENT	(243)
+#define QCA_PRE_SHUTDOWN_CMD		(0xFC08)
 #define EDL_CMD_REQ_RES_EVT		(0x00)
 #define EDL_PATCH_VER_RES_EVT		(0x19)
 		   const char *firmware_name);
 int qca_read_soc_version(struct hci_dev *hdev, u32 *soc_version);
 int qca_set_bdaddr(struct hci_dev *hdev, const bdaddr_t *bdaddr);
+int qca_send_pre_shutdown_cmd(struct hci_dev *hdev);
 static inline bool qca_is_wcn399x(enum qca_btsoc_type soc_type)
 {
 	return soc_type == QCA_WCN3990 || soc_type == QCA_WCN3998;
 {
 	return false;
 }
+static inline int qca_send_pre_shutdown_cmd(struct hci_dev *hdev)
+{
+	return -EOPNOTSUPP;
+}
 #endif

drivers/bluetooth/btusb.c+3−1

 	fw_size = fw->size;
 	/* The size of patch header is 30 bytes, should be skip */
-	if (fw_size < 30)
+	if (fw_size < 30) {
+		err = -EINVAL;
 		goto err_release_fw;
+	}
 	fw_size -= 30;
 	fw_ptr += 30;

drivers/bluetooth/hci_qca.c+6−3

 	unsigned long flags;
 	struct qca_data *qca = hu->priv;
-	BT_DBG("hu %p want to sleep", hu);
+	BT_DBG("hu %p want to sleep in %d state", hu, qca->rx_ibs_state);
 	spin_lock_irqsave(&qca->hci_ibs_lock, flags);
 		break;
 	case HCI_IBS_RX_ASLEEP:
-		/* Fall through */
+		break;
 	default:
 		/* Any other state is illegal */
 		if (hdr->evt == HCI_EV_VENDOR)
 			complete(&qca->drop_ev_comp);
-		kfree(skb);
+		kfree_skb(skb);
 		return 0;
 	}
 {
 	struct hci_uart *hu = hci_get_drvdata(hdev);
+	/* Perform pre shutdown command */
+	qca_send_pre_shutdown_cmd(hdev);
 	qca_power_shutdown(hu);
 	return 0;
 }

drivers/clocksource/timer-riscv.c+2−4

 	return get_cycles64();
 }
-static DEFINE_PER_CPU(struct clocksource, riscv_clocksource) = {
+static struct clocksource riscv_clocksource = {
 	.name		= "riscv_clocksource",
 	.rating		= 300,
 	.mask		= CLOCKSOURCE_MASK(64),
 static int __init riscv_timer_init_dt(struct device_node *n)
 {
 	int cpuid, hartid, error;
-	struct clocksource *cs;
 	hartid = riscv_of_processor_hartid(n);
 	if (hartid < 0) {
 	pr_info("%s: Registering clocksource cpuid [%d] hartid [%d]\n",
 	       __func__, cpuid, hartid);
-	cs = per_cpu_ptr(&riscv_clocksource, cpuid);
+	error = clocksource_register_hz(&riscv_clocksource, riscv_timebase);
-	error = clocksource_register_hz(cs, riscv_timebase);
 	if (error) {
 		pr_err("RISCV timer register failed [%d] for cpu = [%d]\n",
 		       error, cpuid);

drivers/cpufreq/cpufreq.c+1−1

@@ -2528,7 +2528,7 @@ static int cpufreq_boost_set_sw(int state) · 2527 unmodified lines
2528	}	2528	}
2529		2529
2530	ret = dev_pm_qos_update_request(policy->max_freq_req, policy->max);	2530	ret = dev_pm_qos_update_request(policy->max_freq_req, policy->max);
2531	if (ret)	2531	if (ret < 0)
2532	break;	2532	break;
2533	}	2533	}
2534		2534

drivers/crypto/ccp/ccp-crypto-aes-galois.c+14−0

@@ -58,6 +58,19 @@ static int ccp_aes_gcm_setkey(struct crypto_aead tfm, const u8 key, · 57 unmodified lines
58	static int ccp_aes_gcm_setauthsize(struct crypto_aead *tfm,	58	static int ccp_aes_gcm_setauthsize(struct crypto_aead *tfm,
59	unsigned int authsize)	59	unsigned int authsize)
60	{	60	{
		61	switch (authsize) {
		62	case 16:
		63	case 15:
		64	case 14:
		65	case 13:
		66	case 12:
		67	case 8:
		68	case 4:
		69	break;
		70	default:
		71	return -EINVAL;
		72	}
		73
61	return 0;	74	return 0;
62	}	75	}
63		76
@@ -104,6 +117,7 @@ static int ccp_aes_gcm_crypt(struct aead_request *req, bool encrypt) · 40 unmodified lines
104	memset(&rctx->cmd, 0, sizeof(rctx->cmd));	117	memset(&rctx->cmd, 0, sizeof(rctx->cmd));
105	INIT_LIST_HEAD(&rctx->cmd.entry);	118	INIT_LIST_HEAD(&rctx->cmd.entry);
106	rctx->cmd.engine = CCP_ENGINE_AES;	119	rctx->cmd.engine = CCP_ENGINE_AES;
		120	rctx->cmd.u.aes.authsize = crypto_aead_authsize(tfm);
107	rctx->cmd.u.aes.type = ctx->u.aes.type;	121	rctx->cmd.u.aes.type = ctx->u.aes.type;
108	rctx->cmd.u.aes.mode = ctx->u.aes.mode;	122	rctx->cmd.u.aes.mode = ctx->u.aes.mode;
109	rctx->cmd.u.aes.action = encrypt;	123	rctx->cmd.u.aes.action = encrypt;

drivers/crypto/ccp/ccp-ops.c+24−9

 	unsigned long long *final;
 	unsigned int dm_offset;
+	unsigned int authsize;
 	unsigned int jobid;
 	unsigned int ilen;
 	bool in_place = true; /* Default value */
 	if (!aes->key) /* Gotta have a key SGL */
 		return -EINVAL;
+	/* Zero defaults to 16 bytes, the maximum size */
+	authsize = aes->authsize ? aes->authsize : AES_BLOCK_SIZE;
+	switch (authsize) {
+	case 16:
+	case 15:
+	case 14:
+	case 13:
+	case 12:
+	case 8:
+	case 4:
+		break;
+	default:
+		return -EINVAL;
+	}
 	/* First, decompose the source buffer into AAD & PT,
 	 * and the destination buffer into AAD, CT & tag, or
 	 * the input into CT & tag.
 		p_tag = scatterwalk_ffwd(sg_tag, p_outp, ilen);
 	} else {
 		/* Input length for decryption includes tag */
-		ilen = aes->src_len - AES_BLOCK_SIZE;
+		ilen = aes->src_len - authsize;
 		p_tag = scatterwalk_ffwd(sg_tag, p_inp, ilen);
 	}
 		while (src.sg_wa.bytes_left) {
 			ccp_prepare_data(&src, &dst, &op, AES_BLOCK_SIZE, true);
 			if (!src.sg_wa.bytes_left) {
-				unsigned int nbytes = aes->src_len
+				unsigned int nbytes = ilen % AES_BLOCK_SIZE;
-						      % AES_BLOCK_SIZE;
 				if (nbytes) {
 					op.eom = 1;
 	if (aes->action == CCP_AES_ACTION_ENCRYPT) {
 		/* Put the ciphered tag after the ciphertext. */
-		ccp_get_dm_area(&final_wa, 0, p_tag, 0, AES_BLOCK_SIZE);
+		ccp_get_dm_area(&final_wa, 0, p_tag, 0, authsize);
 	} else {
 		/* Does this ciphered tag match the input? */
-		ret = ccp_init_dm_workarea(&tag, cmd_q, AES_BLOCK_SIZE,
+		ret = ccp_init_dm_workarea(&tag, cmd_q, authsize,
 					   DMA_BIDIRECTIONAL);
 		if (ret)
 			goto e_tag;
-		ret = ccp_set_dm_area(&tag, 0, p_tag, 0, AES_BLOCK_SIZE);
+		ret = ccp_set_dm_area(&tag, 0, p_tag, 0, authsize);
 		if (ret)
 			goto e_tag;
 		ret = crypto_memneq(tag.address, final_wa.address,
-				    AES_BLOCK_SIZE) ? -EBADMSG : 0;
+				    authsize) ? -EBADMSG : 0;
 		ccp_dm_free(&tag);
 	}
 	ccp_dm_free(&final_wa);
 e_dst:
-	if (aes->src_len && !in_place)
+	if (ilen > 0 && !in_place)
 		ccp_free_data(&dst, cmd_q);
 e_src:
-	if (aes->src_len)
+	if (ilen > 0)
 		ccp_free_data(&src, cmd_q);
 e_aad:

drivers/crypto/ux500/cryp/cryp.c+6−0

 	case CRYP_KEY_SIZE_256:
 		ctx->key_4_l = readl_relaxed(&src_reg->key_4_l);
 		ctx->key_4_r = readl_relaxed(&src_reg->key_4_r);
+		/* Fall through */
 	case CRYP_KEY_SIZE_192:
 		ctx->key_3_l = readl_relaxed(&src_reg->key_3_l);
 		ctx->key_3_r = readl_relaxed(&src_reg->key_3_r);
+		/* Fall through */
 	case CRYP_KEY_SIZE_128:
 		ctx->key_2_l = readl_relaxed(&src_reg->key_2_l);
 		ctx->key_2_r = readl_relaxed(&src_reg->key_2_r);
+		/* Fall through */
 	default:
 		ctx->key_1_l = readl_relaxed(&src_reg->key_1_l);
 	case CRYP_KEY_SIZE_256:
 		writel_relaxed(ctx->key_4_l, &reg->key_4_l);
 		writel_relaxed(ctx->key_4_r, &reg->key_4_r);
+		/* Fall through */
 	case CRYP_KEY_SIZE_192:
 		writel_relaxed(ctx->key_3_l, &reg->key_3_l);
 		writel_relaxed(ctx->key_3_r, &reg->key_3_r);
+		/* Fall through */
 	case CRYP_KEY_SIZE_128:
 		writel_relaxed(ctx->key_2_l, &reg->key_2_l);
 		writel_relaxed(ctx->key_2_r, &reg->key_2_r);
+		/* Fall through */
 	default:
 		writel_relaxed(ctx->key_1_l, &reg->key_1_l);

drivers/dma/dw-edma/dw-edma-core.h+1−1

@@ -50,7 +50,7 @@ struct dw_edma_burst { · 49 unmodified lines
50		50
51	struct dw_edma_region {	51	struct dw_edma_region {
52	phys_addr_t paddr;	52	phys_addr_t paddr;
53	dma_addr_t vaddr;	53	void __iomem *vaddr;
54	size_t sz;	54	size_t sz;
55	};	55	};
56		56

drivers/dma/dw-edma/dw-edma-pcie.c+9−9

drivers/dma/dw-edma/dw-edma-v0-core.c+15−19

 static inline struct dw_edma_v0_regs __iomem *__dw_regs(struct dw_edma *dw)
 {
-	return (struct dw_edma_v0_regs __iomem *)dw->rg_region.vaddr;
+	return dw->rg_region.vaddr;
 }
 #define SET(dw, name, value)				\
 static void dw_edma_v0_core_write_chunk(struct dw_edma_chunk *chunk)
 {
 	struct dw_edma_burst *child;
-	struct dw_edma_v0_lli *lli;
+	struct dw_edma_v0_lli __iomem *lli;
-	struct dw_edma_v0_llp *llp;
+	struct dw_edma_v0_llp __iomem *llp;
 	u32 control = 0, i = 0;
-	u64 sar, dar, addr;
 	int j;
-	lli = (struct dw_edma_v0_lli *)chunk->ll_region.vaddr;
+	lli = chunk->ll_region.vaddr;
 	if (chunk->cb)
 		control = DW_EDMA_V0_CB;
 		/* Transfer size */
 		SET_LL(&lli[i].transfer_size, child->sz);
 		/* SAR - low, high */
-		sar = cpu_to_le64(child->sar);
+		SET_LL(&lli[i].sar_low, lower_32_bits(child->sar));
-		SET_LL(&lli[i].sar_low, lower_32_bits(sar));
+		SET_LL(&lli[i].sar_high, upper_32_bits(child->sar));
-		SET_LL(&lli[i].sar_high, upper_32_bits(sar));
 		/* DAR - low, high */
-		dar = cpu_to_le64(child->dar);
+		SET_LL(&lli[i].dar_low, lower_32_bits(child->dar));
-		SET_LL(&lli[i].dar_low, lower_32_bits(dar));
+		SET_LL(&lli[i].dar_high, upper_32_bits(child->dar));
-		SET_LL(&lli[i].dar_high, upper_32_bits(dar));
 		i++;
 	}
-	llp = (struct dw_edma_v0_llp *)&lli[i];
+	llp = (void __iomem *)&lli[i];
 	control = DW_EDMA_V0_LLP | DW_EDMA_V0_TCB;
 	if (!chunk->cb)
 		control |= DW_EDMA_V0_CB;
 	/* Channel control */
 	SET_LL(&llp->control, control);
 	/* Linked list  - low, high */
-	addr = cpu_to_le64(chunk->ll_region.paddr);
+	SET_LL(&llp->llp_low, lower_32_bits(chunk->ll_region.paddr));
-	SET_LL(&llp->llp_low, lower_32_bits(addr));
+	SET_LL(&llp->llp_high, upper_32_bits(chunk->ll_region.paddr));
-	SET_LL(&llp->llp_high, upper_32_bits(addr));
 }
 void dw_edma_v0_core_start(struct dw_edma_chunk *chunk, bool first)
 	struct dw_edma_chan *chan = chunk->chan;
 	struct dw_edma *dw = chan->chip->dw;
 	u32 tmp;
-	u64 llp;
 	dw_edma_v0_core_write_chunk(chunk);
 		SET_CH(dw, chan->dir, chan->id, ch_control1,
 		       (DW_EDMA_V0_CCS | DW_EDMA_V0_LLE));
 		/* Linked list - low, high */
-		llp = cpu_to_le64(chunk->ll_region.paddr);
+		SET_CH(dw, chan->dir, chan->id, llp_low,
-		SET_CH(dw, chan->dir, chan->id, llp_low, lower_32_bits(llp));
+		       lower_32_bits(chunk->ll_region.paddr));
-		SET_CH(dw, chan->dir, chan->id, llp_high, upper_32_bits(llp));
+		SET_CH(dw, chan->dir, chan->id, llp_high,
+		       upper_32_bits(chunk->ll_region.paddr));
 	}
 	/* Doorbell */
 	SET_RW(dw, chan->dir, doorbell,

drivers/dma/dw-edma/dw-edma-v0-debugfs.c+15−14

 #include "dw-edma-core.h"
 #define REGS_ADDR(name) \
-	((dma_addr_t *)&regs->name)
+	((void __force *)&regs->name)
 #define REGISTER(name) \
 	{ #name, REGS_ADDR(name) }
 static struct dentry				*base_dir;
 static struct dw_edma				*dw;
-static struct dw_edma_v0_regs			*regs;
+static struct dw_edma_v0_regs			__iomem *regs;
 static struct {
-	void					*start;
+	void					__iomem *start;
-	void					*end;
+	void					__iomem *end;
 } lim[2][EDMA_V0_MAX_NR_CH];
 struct debugfs_entries {
-	char					name[24];
+	const char				*name;
 	dma_addr_t				*reg;
 };
 static int dw_edma_debugfs_u32_get(void *data, u64 *val)
 {
+	void __iomem *reg = (void __force __iomem *)data;
 	if (dw->mode == EDMA_MODE_LEGACY &&
-	    data >= (void *)&regs->type.legacy.ch) {
+	    reg >= (void __iomem *)&regs->type.legacy.ch) {
-		void *ptr = (void *)&regs->type.legacy.ch;
+		void __iomem *ptr = &regs->type.legacy.ch;
 		u32 viewport_sel = 0;
 		unsigned long flags;
 		u16 ch;
 		for (ch = 0; ch < dw->wr_ch_cnt; ch++)
-			if (lim[0][ch].start >= data && data < lim[0][ch].end) {
+			if (lim[0][ch].start >= reg && reg < lim[0][ch].end) {
-				ptr += (data - lim[0][ch].start);
+				ptr += (reg - lim[0][ch].start);
 				goto legacy_sel_wr;
 			}
 		for (ch = 0; ch < dw->rd_ch_cnt; ch++)
-			if (lim[1][ch].start >= data && data < lim[1][ch].end) {
+			if (lim[1][ch].start >= reg && reg < lim[1][ch].end) {
-				ptr += (data - lim[1][ch].start);
+				ptr += (reg - lim[1][ch].start);
 				goto legacy_sel_rd;
 			}
 		raw_spin_unlock_irqrestore(&dw->lock, flags);
 	} else {
-		*val = readl(data);
+		*val = readl(reg);
 	}
 	return 0;
 	}
 }
-static void dw_edma_debugfs_regs_ch(struct dw_edma_v0_ch_regs *regs,
+static void dw_edma_debugfs_regs_ch(struct dw_edma_v0_ch_regs __iomem *regs,
 				    struct dentry *dir)
 {
 	int nr_entries;
 	if (!dw)
 		return;
-	regs = (struct dw_edma_v0_regs *)dw->rg_region.vaddr;
+	regs = dw->rg_region.vaddr;
 	if (!regs)
 		return;

drivers/dma/ste_dma40.c+2−2

@@ -142,7 +142,7 @@ enum d40_events { · 141 unmodified lines
142	* when the DMA hw is powered off.	142	* when the DMA hw is powered off.
143	* TODO: Add save/restore of D40_DREG_GCC on dma40 v3 or later, if that works.	143	* TODO: Add save/restore of D40_DREG_GCC on dma40 v3 or later, if that works.
144	*/	144	*/
145	static u32 d40_backup_regs[] = {	145	static __maybe_unused u32 d40_backup_regs[] = {
146	D40_DREG_LCPA,	146	D40_DREG_LCPA,
147	D40_DREG_LCLA,	147	D40_DREG_LCLA,
148	D40_DREG_PRMSE,	148	D40_DREG_PRMSE,
@@ -211,7 +211,7 @@ static u32 d40_backup_regs_v4b[] = { · 62 unmodified lines
211		211
212	#define BACKUP_REGS_SZ_V4B ARRAY_SIZE(d40_backup_regs_v4b)	212	#define BACKUP_REGS_SZ_V4B ARRAY_SIZE(d40_backup_regs_v4b)
213		213
214	static u32 d40_backup_regs_chan[] = {	214	static __maybe_unused u32 d40_backup_regs_chan[] = {
215	D40_CHAN_REG_SSCFG,	215	D40_CHAN_REG_SSCFG,
216	D40_CHAN_REG_SSELT,	216	D40_CHAN_REG_SSELT,
217	D40_CHAN_REG_SSPTR,	217	D40_CHAN_REG_SSPTR,

drivers/dma/stm32-mdma.c+1−1

@@ -1366,7 +1366,7 @@ static irqreturn_t stm32_mdma_irq_handler(int irq, void *devid) · 1365 unmodified lines
1366		1366
1367	chan = &dmadev->chan[id];	1367	chan = &dmadev->chan[id];
1368	if (!chan) {	1368	if (!chan) {
1369	dev_err(chan2dev(chan), "MDMA channel not initialized\n");	1369	dev_dbg(mdma2dev(dmadev), "MDMA channel not initialized\n");
1370	goto exit;	1370	goto exit;
1371	}	1371	}
1372		1372

drivers/dma/tegra210-adma.c+2−2

@@ -712,7 +712,7 @@ static struct dma_chan tegra_dma_of_xlate(struct of_phandle_args dma_spec, · 711 unmodified lines
712	return chan;	712	return chan;
713	}	713	}
714		714
715	static int tegra_adma_runtime_suspend(struct device *dev)	715	static int __maybe_unused tegra_adma_runtime_suspend(struct device *dev)
716	{	716	{
717	struct tegra_adma *tdma = dev_get_drvdata(dev);	717	struct tegra_adma *tdma = dev_get_drvdata(dev);
718	struct tegra_adma_chan_regs *ch_reg;	718	struct tegra_adma_chan_regs *ch_reg;
@@ -744,7 +744,7 @@ clk_disable: · 25 unmodified lines
744	return 0;	744	return 0;
745	}	745	}
746		746
747	static int tegra_adma_runtime_resume(struct device *dev)	747	static int __maybe_unused tegra_adma_runtime_resume(struct device *dev)
748	{	748	{
749	struct tegra_adma *tdma = dev_get_drvdata(dev);	749	struct tegra_adma *tdma = dev_get_drvdata(dev);
750	struct tegra_adma_chan_regs *ch_reg;	750	struct tegra_adma_chan_regs *ch_reg;

drivers/dma/ti/omap-dma.c+2−2

@@ -1234,7 +1234,7 @@ static struct dma_async_tx_descriptor *omap_dma_prep_dma_interleaved( · 1233 unmodified lines
1234	if (src_icg) {	1234	if (src_icg) {
1235	d->ccr \|= CCR_SRC_AMODE_DBLIDX;	1235	d->ccr \|= CCR_SRC_AMODE_DBLIDX;
1236	d->ei = 1;	1236	d->ei = 1;
1237	d->fi = src_icg;	1237	d->fi = src_icg + 1;
1238	} else if (xt->src_inc) {	1238	} else if (xt->src_inc) {
1239	d->ccr \|= CCR_SRC_AMODE_POSTINC;	1239	d->ccr \|= CCR_SRC_AMODE_POSTINC;
1240	d->fi = 0;	1240	d->fi = 0;
@@ -1249,7 +1249,7 @@ static struct dma_async_tx_descriptor *omap_dma_prep_dma_interleaved( · 8 unmodified lines
1249	if (dst_icg) {	1249	if (dst_icg) {
1250	d->ccr \|= CCR_DST_AMODE_DBLIDX;	1250	d->ccr \|= CCR_DST_AMODE_DBLIDX;
1251	sg->ei = 1;	1251	sg->ei = 1;
1252	sg->fi = dst_icg;	1252	sg->fi = dst_icg + 1;
1253	} else if (xt->dst_inc) {	1253	} else if (xt->dst_inc) {
1254	d->ccr \|= CCR_DST_AMODE_POSTINC;	1254	d->ccr \|= CCR_DST_AMODE_POSTINC;
1255	sg->fi = 0;	1255	sg->fi = 0;

drivers/firmware/efi/libstub/efi-stub-helper.c+27−11

@@ -927,17 +927,33 @@ fail: · 926 unmodified lines
927	return status;	927	return status;
928	}	928	}
929		929
		930	#define GET_EFI_CONFIG_TABLE(bits) \
		931	static void get_efi_config_table##bits(efi_system_table_t _sys_table, \
		932	efi_guid_t guid) \
		933	{ \
		934	efi_system_table_##bits##_t *sys_table; \
		935	efi_config_table_##bits##_t *tables; \
		936	int i; \
		937	\
		938	sys_table = (typeof(sys_table))_sys_table; \
		939	tables = (typeof(tables))(unsigned long)sys_table->tables; \
		940	\
		941	for (i = 0; i < sys_table->nr_tables; i++) { \
		942	if (efi_guidcmp(tables[i].guid, guid) != 0) \
		943	continue; \
		944	\
		945	return (void *)(unsigned long)tables[i].table; \
		946	} \
		947	\
		948	return NULL; \
		949	}
		950	GET_EFI_CONFIG_TABLE(32)
		951	GET_EFI_CONFIG_TABLE(64)
		952
930	void get_efi_config_table(efi_system_table_t sys_table, efi_guid_t guid)	953	void get_efi_config_table(efi_system_table_t sys_table, efi_guid_t guid)
931	{	954	{
932	efi_config_table_t tables = (efi_config_table_t )sys_table->tables;	955	if (efi_is_64bit())
933	int i;	956	return get_efi_config_table64(sys_table, guid);
934		957	else
935	for (i = 0; i < sys_table->nr_tables; i++) {	958	return get_efi_config_table32(sys_table, guid);
936	if (efi_guidcmp(tables[i].guid, guid) != 0)
937	continue;
938
939	return (void *)tables[i].table;
940	}
941
942	return NULL;
943	}	959	}

drivers/gpu/drm/amd/amdgpu/amdgpu_gds.h+0−1

@@ -32,7 +32,6 @@ struct amdgpu_gds { · 31 unmodified lines
32	uint32_t gws_size;	32	uint32_t gws_size;
33	uint32_t oa_size;	33	uint32_t oa_size;
34	uint32_t gds_compute_max_wave_id;	34	uint32_t gds_compute_max_wave_id;
35	uint32_t vgt_gs_max_wave_id;
36	};	35	};
37		36
38	struct amdgpu_gds_reg_offset {	37	struct amdgpu_gds_reg_offset {

drivers/gpu/drm/amd/amdgpu/amdgpu_vcn.h+1−0

@@ -30,6 +30,7 @@ · 29 unmodified lines
30	#define AMDGPU_VCN_FIRMWARE_OFFSET 256	30	#define AMDGPU_VCN_FIRMWARE_OFFSET 256
31	#define AMDGPU_VCN_MAX_ENC_RINGS 3	31	#define AMDGPU_VCN_MAX_ENC_RINGS 3
32		32
		33	#define VCN_DEC_KMD_CMD 0x80000000
33	#define VCN_DEC_CMD_FENCE 0x00000000	34	#define VCN_DEC_CMD_FENCE 0x00000000
34	#define VCN_DEC_CMD_TRAP 0x00000001	35	#define VCN_DEC_CMD_TRAP 0x00000001
35	#define VCN_DEC_CMD_WRITE_REG 0x00000004	36	#define VCN_DEC_CMD_WRITE_REG 0x00000004

drivers/gpu/drm/amd/amdgpu/gfx_v10_0.c+1−11

 	unsigned vmid = AMDGPU_JOB_GET_VMID(job);
 	u32 header, control = 0;
-	/* Prevent a hw deadlock due to a wave ID mismatch between ME and GDS.
-	 * This resets the wave ID counters. (needed by transform feedback)
-	 * TODO: This might only be needed on a VMID switch when we change
-	 *       the GDS OA mapping, not sure.
-	 */
-	amdgpu_ring_write(ring, PACKET3(PACKET3_SET_CONFIG_REG, 1));
-	amdgpu_ring_write(ring, mmVGT_GS_MAX_WAVE_ID);
-	amdgpu_ring_write(ring, ring->adev->gds.vgt_gs_max_wave_id);
 	if (ib->flags & AMDGPU_IB_FLAG_CE)
 		header = PACKET3(PACKET3_INDIRECT_BUFFER_CNST, 2);
 	else
 		5 + /* HDP_INVL */
 		8 + 8 + /* FENCE x2 */
 		2, /* SWITCH_BUFFER */
-	.emit_ib_size =	7, /* gfx_v10_0_ring_emit_ib_gfx */
+	.emit_ib_size =	4, /* gfx_v10_0_ring_emit_ib_gfx */
 	.emit_ib = gfx_v10_0_ring_emit_ib_gfx,
 	.emit_fence = gfx_v10_0_ring_emit_fence,
 	.emit_pipeline_sync = gfx_v10_0_ring_emit_pipeline_sync,
 	default:
 		adev->gds.gds_size = 0x10000;
 		adev->gds.gds_compute_max_wave_id = 0x4ff;
-		adev->gds.vgt_gs_max_wave_id = 0x3ff;
 		break;
 	}

drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c+40−0

@@ -1321,6 +1321,39 @@ static int gfx_v8_0_rlc_init(struct amdgpu_device *adev) · 1320 unmodified lines
1321	return 0;	1321	return 0;
1322	}	1322	}
1323		1323
		1324	static int gfx_v8_0_csb_vram_pin(struct amdgpu_device *adev)
		1325	{
		1326	int r;
		1327
		1328	r = amdgpu_bo_reserve(adev->gfx.rlc.clear_state_obj, false);
		1329	if (unlikely(r != 0))
		1330	return r;
		1331
		1332	r = amdgpu_bo_pin(adev->gfx.rlc.clear_state_obj,
		1333	AMDGPU_GEM_DOMAIN_VRAM);
		1334	if (!r)
		1335	adev->gfx.rlc.clear_state_gpu_addr =
		1336	amdgpu_bo_gpu_offset(adev->gfx.rlc.clear_state_obj);
		1337
		1338	amdgpu_bo_unreserve(adev->gfx.rlc.clear_state_obj);
		1339
		1340	return r;
		1341	}
		1342
		1343	static void gfx_v8_0_csb_vram_unpin(struct amdgpu_device *adev)
		1344	{
		1345	int r;
		1346
		1347	if (!adev->gfx.rlc.clear_state_obj)
		1348	return;
		1349
		1350	r = amdgpu_bo_reserve(adev->gfx.rlc.clear_state_obj, true);
		1351	if (likely(r == 0)) {
		1352	amdgpu_bo_unpin(adev->gfx.rlc.clear_state_obj);
		1353	amdgpu_bo_unreserve(adev->gfx.rlc.clear_state_obj);
		1354	}
		1355	}
		1356
1324	static void gfx_v8_0_mec_fini(struct amdgpu_device *adev)	1357	static void gfx_v8_0_mec_fini(struct amdgpu_device *adev)
1325	{	1358	{
1326	amdgpu_bo_free_kernel(&adev->gfx.mec.hpd_eop_obj, NULL, NULL);	1359	amdgpu_bo_free_kernel(&adev->gfx.mec.hpd_eop_obj, NULL, NULL);
@@ -4785,6 +4818,10 @@ static int gfx_v8_0_hw_init(void *handle) · 3458 unmodified lines
4785	gfx_v8_0_init_golden_registers(adev);	4818	gfx_v8_0_init_golden_registers(adev);
4786	gfx_v8_0_constants_init(adev);	4819	gfx_v8_0_constants_init(adev);
4787		4820
		4821	r = gfx_v8_0_csb_vram_pin(adev);
		4822	if (r)
		4823	return r;
		4824
4788	r = adev->gfx.rlc.funcs->resume(adev);	4825	r = adev->gfx.rlc.funcs->resume(adev);
4789	if (r)	4826	if (r)
4790	return r;	4827	return r;
@@ -4901,6 +4938,9 @@ static int gfx_v8_0_hw_fini(void *handle) · 110 unmodified lines
4901	else	4938	else
4902	pr_err("rlc is busy, skip halt rlc\n");	4939	pr_err("rlc is busy, skip halt rlc\n");
4903	amdgpu_gfx_rlc_exit_safe_mode(adev);	4940	amdgpu_gfx_rlc_exit_safe_mode(adev);
		4941
		4942	gfx_v8_0_csb_vram_unpin(adev);
		4943
4904	return 0;	4944	return 0;
4905	}	4945	}
4906		4946

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

@@ -4869,7 +4869,7 @@ static void gfx_v9_0_ring_soft_recovery(struct amdgpu_ring *ring, unsigned vmid) · 4868 unmodified lines
4869	value = REG_SET_FIELD(value, SQ_CMD, MODE, 0x01);	4869	value = REG_SET_FIELD(value, SQ_CMD, MODE, 0x01);
4870	value = REG_SET_FIELD(value, SQ_CMD, CHECK_VMID, 1);	4870	value = REG_SET_FIELD(value, SQ_CMD, CHECK_VMID, 1);
4871	value = REG_SET_FIELD(value, SQ_CMD, VM_ID, vmid);	4871	value = REG_SET_FIELD(value, SQ_CMD, VM_ID, vmid);
4872	WREG32(mmSQ_CMD, value);	4872	WREG32_SOC15(GC, 0, mmSQ_CMD, value);
4873	}	4873	}
4874		4874
4875	static void gfx_v9_0_set_gfx_eop_interrupt_state(struct amdgpu_device *adev,	4875	static void gfx_v9_0_set_gfx_eop_interrupt_state(struct amdgpu_device *adev,

drivers/gpu/drm/amd/amdgpu/vcn_v2_0.c+37−7

 	amdgpu_ring_write(ring, PACKET0(mmUVD_GPCOM_VCPU_DATA0_INTERNAL_OFFSET, 0));
 	amdgpu_ring_write(ring, 0);
 	amdgpu_ring_write(ring, PACKET0(mmUVD_GPCOM_VCPU_CMD_INTERNAL_OFFSET, 0));
-	amdgpu_ring_write(ring, VCN_DEC_CMD_PACKET_START << 1);
+	amdgpu_ring_write(ring, VCN_DEC_KMD_CMD | (VCN_DEC_CMD_PACKET_START << 1));
 }
 /**
 static void vcn_v2_0_dec_ring_insert_end(struct amdgpu_ring *ring)
 {
 	amdgpu_ring_write(ring, PACKET0(mmUVD_GPCOM_VCPU_CMD_INTERNAL_OFFSET, 0));
-	amdgpu_ring_write(ring, VCN_DEC_CMD_PACKET_END << 1);
+	amdgpu_ring_write(ring, VCN_DEC_KMD_CMD | (VCN_DEC_CMD_PACKET_END << 1));
 }
 /**
 	amdgpu_ring_write(ring, upper_32_bits(addr) & 0xff);
 	amdgpu_ring_write(ring, PACKET0(mmUVD_GPCOM_VCPU_CMD_INTERNAL_OFFSET, 0));
-	amdgpu_ring_write(ring, VCN_DEC_CMD_FENCE << 1);
+	amdgpu_ring_write(ring, VCN_DEC_KMD_CMD | (VCN_DEC_CMD_FENCE << 1));
 	amdgpu_ring_write(ring, PACKET0(mmUVD_GPCOM_VCPU_DATA0_INTERNAL_OFFSET, 0));
 	amdgpu_ring_write(ring, 0);
 	amdgpu_ring_write(ring, PACKET0(mmUVD_GPCOM_VCPU_CMD_INTERNAL_OFFSET, 0));
-	amdgpu_ring_write(ring, VCN_DEC_CMD_TRAP << 1);
+	amdgpu_ring_write(ring, VCN_DEC_KMD_CMD | (VCN_DEC_CMD_TRAP << 1));
 }
 /**
 	amdgpu_ring_write(ring, PACKET0(mmUVD_GPCOM_VCPU_CMD_INTERNAL_OFFSET, 0));
-	amdgpu_ring_write(ring, VCN_DEC_CMD_REG_READ_COND_WAIT << 1);
+	amdgpu_ring_write(ring, VCN_DEC_KMD_CMD | (VCN_DEC_CMD_REG_READ_COND_WAIT << 1));
 }
 static void vcn_v2_0_dec_ring_emit_vm_flush(struct amdgpu_ring *ring,
 	amdgpu_ring_write(ring, PACKET0(mmUVD_GPCOM_VCPU_CMD_INTERNAL_OFFSET, 0));
-	amdgpu_ring_write(ring, VCN_DEC_CMD_WRITE_REG << 1);
+	amdgpu_ring_write(ring, VCN_DEC_KMD_CMD | (VCN_DEC_CMD_WRITE_REG << 1));
 }
 /**
 	return 0;
 }
+static int vcn_v2_0_dec_ring_test_ring(struct amdgpu_ring *ring)
+{
+	struct amdgpu_device *adev = ring->adev;
+	uint32_t tmp = 0;
+	unsigned i;
+	int r;
+	WREG32(adev->vcn.external.scratch9, 0xCAFEDEAD);
+	r = amdgpu_ring_alloc(ring, 4);
+	if (r)
+		return r;
+	amdgpu_ring_write(ring, PACKET0(mmUVD_GPCOM_VCPU_CMD_INTERNAL_OFFSET, 0));
+	amdgpu_ring_write(ring, VCN_DEC_KMD_CMD | (VCN_DEC_CMD_PACKET_START << 1));
+	amdgpu_ring_write(ring, PACKET0(adev->vcn.internal.scratch9, 0));
+	amdgpu_ring_write(ring, 0xDEADBEEF);
+	amdgpu_ring_commit(ring);
+	for (i = 0; i < adev->usec_timeout; i++) {
+		tmp = RREG32(adev->vcn.external.scratch9);
+		if (tmp == 0xDEADBEEF)
+			break;
+		DRM_UDELAY(1);
+	}
+	if (i >= adev->usec_timeout)
+		r = -ETIMEDOUT;
+	return r;
+}
 static int vcn_v2_0_set_powergating_state(void *handle,
 					  enum amd_powergating_state state)
 {
 	.emit_ib = vcn_v2_0_dec_ring_emit_ib,
 	.emit_fence = vcn_v2_0_dec_ring_emit_fence,
 	.emit_vm_flush = vcn_v2_0_dec_ring_emit_vm_flush,
-	.test_ring = amdgpu_vcn_dec_ring_test_ring,
+	.test_ring = vcn_v2_0_dec_ring_test_ring,
 	.test_ib = amdgpu_vcn_dec_ring_test_ib,
 	.insert_nop = vcn_v2_0_dec_ring_insert_nop,
 	.insert_start = vcn_v2_0_dec_ring_insert_start,

drivers/gpu/drm/amd/amdkfd/kfd_chardev.c+0−28

@@ -1567,32 +1567,6 @@ copy_from_user_failed: · 1566 unmodified lines
1567	return err;	1567	return err;
1568	}	1568	}
1569		1569
1570	static int kfd_ioctl_alloc_queue_gws(struct file *filep,
1571	struct kfd_process p, void data)
1572	{
1573	int retval;
1574	struct kfd_ioctl_alloc_queue_gws_args *args = data;
1575	struct kfd_dev *dev;
1576
1577	if (!hws_gws_support)
1578	return -ENODEV;
1579
1580	dev = kfd_device_by_id(args->gpu_id);
1581	if (!dev) {
1582	pr_debug("Could not find gpu id 0x%x\n", args->gpu_id);
1583	return -ENODEV;
1584	}
1585	if (dev->dqm->sched_policy == KFD_SCHED_POLICY_NO_HWS)
1586	return -ENODEV;
1587
1588	mutex_lock(&p->mutex);
1589	retval = pqm_set_gws(&p->pqm, args->queue_id, args->num_gws ? dev->gws : NULL);
1590	mutex_unlock(&p->mutex);
1591
1592	args->first_gws = 0;
1593	return retval;
1594	}
1595
1596	static int kfd_ioctl_get_dmabuf_info(struct file *filep,	1570	static int kfd_ioctl_get_dmabuf_info(struct file *filep,
1597	struct kfd_process p, void data)	1571	struct kfd_process p, void data)
1598	{	1572	{
@@ -1795,8 +1769,6 @@ static const struct amdkfd_ioctl_desc amdkfd_ioctls[] = { · 196 unmodified lines
1795	AMDKFD_IOCTL_DEF(AMDKFD_IOC_IMPORT_DMABUF,	1769	AMDKFD_IOCTL_DEF(AMDKFD_IOC_IMPORT_DMABUF,
1796	kfd_ioctl_import_dmabuf, 0),	1770	kfd_ioctl_import_dmabuf, 0),
1797		1771
1798	AMDKFD_IOCTL_DEF(AMDKFD_IOC_ALLOC_QUEUE_GWS,
1799	kfd_ioctl_alloc_queue_gws, 0),
1800	};	1772	};
1801		1773
1802	#define AMDKFD_CORE_IOCTL_COUNT ARRAY_SIZE(amdkfd_ioctls)	1774	#define AMDKFD_CORE_IOCTL_COUNT ARRAY_SIZE(amdkfd_ioctls)

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

  */
 #include <linux/slab.h>
+#include <linux/mm.h>
 #include "dm_services.h"
 struct dc_state *dc_create_state(struct dc *dc)
 {
-	struct dc_state *context = kzalloc(sizeof(struct dc_state),
+	struct dc_state *context = kvzalloc(sizeof(struct dc_state),
-					   GFP_KERNEL);
+					    GFP_KERNEL);
 	if (!context)
 		return NULL;
 struct dc_state *dc_copy_state(struct dc_state *src_ctx)
 {
 	int i, j;
-	struct dc_state *new_ctx = kmemdup(src_ctx,
+	struct dc_state *new_ctx = kvmalloc(sizeof(struct dc_state), GFP_KERNEL);
-			sizeof(struct dc_state), GFP_KERNEL);
 	if (!new_ctx)
 		return NULL;
+	memcpy(new_ctx, src_ctx, sizeof(struct dc_state));
 	for (i = 0; i < MAX_PIPES; i++) {
 			struct pipe_ctx *cur_pipe = &new_ctx->res_ctx.pipe_ctx[i];
 {
 	struct dc_state *context = container_of(kref, struct dc_state, refcount);
 	dc_resource_state_destruct(context);
-	kfree(context);
+	kvfree(context);
 }
 void dc_release_state(struct dc_state *context)

drivers/gpu/drm/amd/powerplay/amdgpu_smu.c+3−1

 int smu_common_read_sensor(struct smu_context *smu, enum amd_pp_sensors sensor,
 			   void *data, uint32_t *size)
 {
+	struct smu_power_context *smu_power = &smu->smu_power;
+	struct smu_power_gate *power_gate = &smu_power->power_gate;
 	int ret = 0;
 	switch (sensor) {
 		*size = 4;
 		break;
 	case AMDGPU_PP_SENSOR_VCN_POWER_STATE:
-		*(uint32_t *)data = smu_feature_is_enabled(smu, SMU_FEATURE_VCN_PG_BIT) ? 1 : 0;
+		*(uint32_t *)data = power_gate->vcn_gated ? 0 : 1;
 		*size = 4;
 		break;
 	default:

drivers/gpu/drm/amd/powerplay/inc/amdgpu_smu.h+1−0

@@ -451,6 +451,7 @@ struct smu_dpm_context { · 450 unmodified lines
451	struct smu_power_gate {	451	struct smu_power_gate {
452	bool uvd_gated;	452	bool uvd_gated;
453	bool vce_gated;	453	bool vce_gated;
		454	bool vcn_gated;
454	};	455	};
455		456
456	struct smu_power_context {	457	struct smu_power_context {

drivers/gpu/drm/amd/powerplay/navi10_ppt.c+53−26

@@ -502,6 +502,8 @@ static int navi10_store_powerplay_table(struct smu_context *smu) · 501 unmodified lines
502		502
503	static int navi10_tables_init(struct smu_context smu, struct smu_table tables)	503	static int navi10_tables_init(struct smu_context smu, struct smu_table tables)
504	{	504	{
		505	struct smu_table_context *smu_table = &smu->smu_table;
		506
505	SMU_TABLE_INIT(tables, SMU_TABLE_PPTABLE, sizeof(PPTable_t),	507	SMU_TABLE_INIT(tables, SMU_TABLE_PPTABLE, sizeof(PPTable_t),
506	PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM);	508	PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM);
507	SMU_TABLE_INIT(tables, SMU_TABLE_WATERMARKS, sizeof(Watermarks_t),	509	SMU_TABLE_INIT(tables, SMU_TABLE_WATERMARKS, sizeof(Watermarks_t),
@@ -516,9 +518,35 @@ static int navi10_tables_init(struct smu_context smu, struct smu_table tables) · 8 unmodified lines
516	sizeof(DpmActivityMonitorCoeffInt_t), PAGE_SIZE,	518	sizeof(DpmActivityMonitorCoeffInt_t), PAGE_SIZE,
517	AMDGPU_GEM_DOMAIN_VRAM);	519	AMDGPU_GEM_DOMAIN_VRAM);
518		520
		521	smu_table->metrics_table = kzalloc(sizeof(SmuMetrics_t), GFP_KERNEL);
		522	if (!smu_table->metrics_table)
		523	return -ENOMEM;
		524	smu_table->metrics_time = 0;
		525
519	return 0;	526	return 0;
520	}	527	}
521		528
		529	static int navi10_get_metrics_table(struct smu_context *smu,
		530	SmuMetrics_t *metrics_table)
		531	{
		532	struct smu_table_context *smu_table= &smu->smu_table;
		533	int ret = 0;
		534
		535	if (!smu_table->metrics_time \|\| time_after(jiffies, smu_table->metrics_time + HZ / 1000)) {
		536	ret = smu_update_table(smu, SMU_TABLE_SMU_METRICS, 0,
		537	(void *)smu_table->metrics_table, false);
		538	if (ret) {
		539	pr_info("Failed to export SMU metrics table!\n");
		540	return ret;
		541	}
		542	smu_table->metrics_time = jiffies;
		543	}
		544
		545	memcpy(metrics_table, smu_table->metrics_table, sizeof(SmuMetrics_t));
		546
		547	return ret;
		548	}
		549
522	static int navi10_allocate_dpm_context(struct smu_context *smu)	550	static int navi10_allocate_dpm_context(struct smu_context *smu)
523	{	551	{
524	struct smu_dpm_context *smu_dpm = &smu->smu_dpm;	552	struct smu_dpm_context *smu_dpm = &smu->smu_dpm;
@@ -577,20 +605,27 @@ static int navi10_set_default_dpm_table(struct smu_context *smu) · 52 unmodified lines
577		605
578	static int navi10_dpm_set_uvd_enable(struct smu_context *smu, bool enable)	606	static int navi10_dpm_set_uvd_enable(struct smu_context *smu, bool enable)
579	{	607	{
		608	struct smu_power_context *smu_power = &smu->smu_power;
		609	struct smu_power_gate *power_gate = &smu_power->power_gate;
580	int ret = 0;	610	int ret = 0;
581		611
582	if (enable) {	612	if (enable) {
583	ret = smu_send_smc_msg_with_param(smu, SMU_MSG_PowerUpVcn, 1);	613	/* vcn dpm on is a prerequisite for vcn power gate messages */
584	if (ret)	614	if (smu_feature_is_enabled(smu, SMU_FEATURE_VCN_PG_BIT)) {
585	return ret;	615	ret = smu_send_smc_msg_with_param(smu, SMU_MSG_PowerUpVcn, 1);
		616	if (ret)
		617	return ret;
		618	}
		619	power_gate->vcn_gated = false;
586	} else {	620	} else {
587	ret = smu_send_smc_msg(smu, SMU_MSG_PowerDownVcn);	621	if (smu_feature_is_enabled(smu, SMU_FEATURE_VCN_PG_BIT)) {
588	if (ret)	622	ret = smu_send_smc_msg(smu, SMU_MSG_PowerDownVcn);
589	return ret;	623	if (ret)
		624	return ret;
		625	}
		626	power_gate->vcn_gated = true;
590	}	627	}
591		628
592	ret = smu_feature_set_enabled(smu, SMU_FEATURE_VCN_PG_BIT, enable);
593
594	return ret;	629	return ret;
595	}	630	}
596		631
@@ -598,15 +633,10 @@ static int navi10_get_current_clk_freq_by_table(struct smu_context *smu, · 1 unmodified line
598	enum smu_clk_type clk_type,	633	enum smu_clk_type clk_type,
599	uint32_t *value)	634	uint32_t *value)
600	{	635	{
601	static SmuMetrics_t metrics;
602	int ret = 0, clk_id = 0;	636	int ret = 0, clk_id = 0;
		637	SmuMetrics_t metrics;
603		638
604	if (!value)	639	ret = navi10_get_metrics_table(smu, &metrics);
605	return -EINVAL;
606
607	memset(&metrics, 0, sizeof(metrics));
608
609	ret = smu_update_table(smu, SMU_TABLE_SMU_METRICS, 0, (void *)&metrics, false);
610	if (ret)	640	if (ret)
611	return ret;	641	return ret;
612		642
@@ -894,8 +924,9 @@ static int navi10_get_gpu_power(struct smu_context smu, uint32_t value) · 281 unmodified lines
894	if (!value)	924	if (!value)
895	return -EINVAL;	925	return -EINVAL;
896		926
897	ret = smu_update_table(smu, SMU_TABLE_SMU_METRICS, 0, (void *)&metrics,	927	ret = navi10_get_metrics_table(smu, &metrics);
898	false);	928	if (ret)
		929	return ret;
899	if (ret)	930	if (ret)
900	return ret;	931	return ret;
901		932
@@ -914,10 +945,7 @@ static int navi10_get_current_activity_percent(struct smu_context *smu, · 12 unmodified lines
914	if (!value)	945	if (!value)
915	return -EINVAL;	946	return -EINVAL;
916		947
917	msleep(1);	948	ret = navi10_get_metrics_table(smu, &metrics);
918
919	ret = smu_update_table(smu, SMU_TABLE_SMU_METRICS, 0,
920	(void *)&metrics, false);
921	if (ret)	949	if (ret)
922	return ret;	950	return ret;
923		951
@@ -956,10 +984,9 @@ static int navi10_get_fan_speed_rpm(struct smu_context *smu, · 32 unmodified lines
956	if (!speed)	984	if (!speed)
957	return -EINVAL;	985	return -EINVAL;
958		986
959	memset(&metrics, 0, sizeof(metrics));	987	ret = navi10_get_metrics_table(smu, &metrics);
960		988	if (ret)
961	ret = smu_update_table(smu, SMU_TABLE_SMU_METRICS, 0,	989	return ret;
962	(void *)&metrics, false);
963	if (ret)	990	if (ret)
964	return ret;	991	return ret;
965		992
@@ -1307,7 +1334,7 @@ static int navi10_thermal_get_temperature(struct smu_context *smu, · 341 unmodified lines
1307	if (!value)	1334	if (!value)
1308	return -EINVAL;	1335	return -EINVAL;
1309		1336
1310	ret = smu_update_table(smu, SMU_TABLE_SMU_METRICS, 0, (void *)&metrics, false);	1337	ret = navi10_get_metrics_table(smu, &metrics);
1311	if (ret)	1338	if (ret)
1312	return ret;	1339	return ret;
1313		1340

drivers/gpu/drm/amd/powerplay/smu_v11_0.c+1−1

@@ -1391,7 +1391,7 @@ smu_v11_0_smc_fan_control(struct smu_context *smu, bool start) · 1390 unmodified lines
1391	{	1391	{
1392	int ret = 0;	1392	int ret = 0;
1393		1393
1394	if (smu_feature_is_supported(smu, SMU_FEATURE_FAN_CONTROL_BIT))	1394	if (!smu_feature_is_supported(smu, SMU_FEATURE_FAN_CONTROL_BIT))
1395	return 0;	1395	return 0;
1396		1396
1397	ret = smu_feature_set_enabled(smu, SMU_FEATURE_FAN_CONTROL_BIT, start);	1397	ret = smu_feature_set_enabled(smu, SMU_FEATURE_FAN_CONTROL_BIT, start);

drivers/gpu/drm/ast/ast_main.c+4−1

 	/* Enable extended register access */
-	ast_enable_mmio(dev);
 	ast_open_key(ast);
+	ast_enable_mmio(dev);
 	/* Find out whether P2A works or whether to use device-tree */
 	ast_detect_config_mode(dev, &scu_rev);
 {
 	struct ast_private *ast = dev->dev_private;
+	/* enable standard VGA decode */
+	ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0xa1, 0x04);
 	ast_release_firmware(dev);
 	kfree(ast->dp501_fw_addr);
 	ast_mode_fini(dev);

drivers/gpu/drm/ast/ast_mode.c+1−1

@@ -604,7 +604,7 @@ static int ast_crtc_mode_set(struct drm_crtc *crtc, · 603 unmodified lines
604	return -EINVAL;	604	return -EINVAL;
605	ast_open_key(ast);	605	ast_open_key(ast);
606		606
607	ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xa1, 0xff, 0x04);	607	ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0xa1, 0x06);
608		608
609	ast_set_std_reg(crtc, adjusted_mode, &vbios_mode);	609	ast_set_std_reg(crtc, adjusted_mode, &vbios_mode);
610	ast_set_crtc_reg(crtc, adjusted_mode, &vbios_mode);	610	ast_set_crtc_reg(crtc, adjusted_mode, &vbios_mode);

drivers/gpu/drm/ast/ast_post.c+1−1

@@ -46,7 +46,7 @@ void ast_enable_mmio(struct drm_device *dev) · 45 unmodified lines
46	{	46	{
47	struct ast_private *ast = dev->dev_private;	47	struct ast_private *ast = dev->dev_private;
48		48
49	ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xa1, 0xff, 0x04);	49	ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0xa1, 0x06);
50	}	50	}
51		51
52		52

drivers/gpu/drm/drm_modes.c+3−1

 	}
 	if (named_mode) {
-		strncpy(mode->name, name, mode_end);
+		if (mode_end + 1 > DRM_DISPLAY_MODE_LEN)
+			return false;
+		strscpy(mode->name, name, mode_end + 1);
 	} else {
 		ret = drm_mode_parse_cmdline_res_mode(name, mode_end,
 						      parse_extras,

drivers/gpu/drm/i915/display/intel_hdcp.c+2−1

@@ -536,7 +536,8 @@ int intel_hdcp_auth_downstream(struct intel_connector *connector) · 535 unmodified lines
536		536
537	if (drm_hdcp_check_ksvs_revoked(dev, ksv_fifo, num_downstream)) {	537	if (drm_hdcp_check_ksvs_revoked(dev, ksv_fifo, num_downstream)) {
538	DRM_ERROR("Revoked Ksv(s) in ksv_fifo\n");	538	DRM_ERROR("Revoked Ksv(s) in ksv_fifo\n");
539	return -EPERM;	539	ret = -EPERM;
		540	goto err;
540	}	541	}
541		542
542	/*	543	/*

drivers/gpu/drm/i915/display/vlv_dsi_pll.c+2−2

@@ -396,8 +396,8 @@ static void glk_dsi_program_esc_clock(struct drm_device *dev, · 395 unmodified lines
396	else	396	else
397	txesc2_div = 10;	397	txesc2_div = 10;
398		398
399	I915_WRITE(MIPIO_TXESC_CLK_DIV1, txesc1_div & GLK_TX_ESC_CLK_DIV1_MASK);	399	I915_WRITE(MIPIO_TXESC_CLK_DIV1, (1 << (txesc1_div - 1)) & GLK_TX_ESC_CLK_DIV1_MASK);
400	I915_WRITE(MIPIO_TXESC_CLK_DIV2, txesc2_div & GLK_TX_ESC_CLK_DIV2_MASK);	400	I915_WRITE(MIPIO_TXESC_CLK_DIV2, (1 << (txesc2_div - 1)) & GLK_TX_ESC_CLK_DIV2_MASK);
401	}	401	}
402		402
403	/* Program BXT Mipi clocks and dividers */	403	/* Program BXT Mipi clocks and dividers */

drivers/gpu/drm/i915/gem/i915_gem_execbuffer.c+9−11

 static int eb_copy_relocations(const struct i915_execbuffer *eb)
 {
+	struct drm_i915_gem_relocation_entry *relocs;
 	const unsigned int count = eb->buffer_count;
 	unsigned int i;
 	int err;
 	for (i = 0; i < count; i++) {
 		const unsigned int nreloc = eb->exec[i].relocation_count;
 		struct drm_i915_gem_relocation_entry __user *urelocs;
-		struct drm_i915_gem_relocation_entry *relocs;
 		unsigned long size;
 		unsigned long copied;
 			if (__copy_from_user((char *)relocs + copied,
 					     (char __user *)urelocs + copied,
-					     len)) {
+					     len))
-end_user:
+				goto end;
-				user_access_end();
-end:
-				kvfree(relocs);
-				err = -EFAULT;
-				goto err;
-			}
 			copied += len;
 		} while (copied < size);
 	return 0;
+end_user:
+	user_access_end();
+end:
+	kvfree(relocs);
+	err = -EFAULT;
 err:
 	while (i--) {
-		struct drm_i915_gem_relocation_entry *relocs =
+		relocs = u64_to_ptr(typeof(*relocs), eb->exec[i].relocs_ptr);
-			u64_to_ptr(typeof(*relocs), eb->exec[i].relocs_ptr);
 		if (eb->exec[i].relocation_count)
 			kvfree(relocs);
 	}

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

 			if (!intel_gvt_ggtt_validate_range(vgpu,
 				workload->wa_ctx.indirect_ctx.guest_gma,
 				workload->wa_ctx.indirect_ctx.size)) {
-				kmem_cache_free(s->workloads, workload);
 				gvt_vgpu_err("invalid wa_ctx at: 0x%lx\n",
 				    workload->wa_ctx.indirect_ctx.guest_gma);
+				kmem_cache_free(s->workloads, workload);
 				return ERR_PTR(-EINVAL);
 			}
 		}
 			if (!intel_gvt_ggtt_validate_range(vgpu,
 				workload->wa_ctx.per_ctx.guest_gma,
 				CACHELINE_BYTES)) {
-				kmem_cache_free(s->workloads, workload);
 				gvt_vgpu_err("invalid per_ctx at: 0x%lx\n",
 					workload->wa_ctx.per_ctx.guest_gma);
+				kmem_cache_free(s->workloads, workload);
 				return ERR_PTR(-EINVAL);
 			}
 		}

drivers/gpu/drm/nouveau/dispnv50/disp.c+13−9

@@ -771,16 +771,20 @@ nv50_msto_atomic_check(struct drm_encoder *encoder, · 770 unmodified lines
771	struct nv50_head_atom *asyh = nv50_head_atom(crtc_state);	771	struct nv50_head_atom *asyh = nv50_head_atom(crtc_state);
772	int slots;	772	int slots;
773		773
774	/* When restoring duplicated states, we need to make sure that the	774	if (crtc_state->mode_changed \|\| crtc_state->connectors_changed) {
775	* bw remains the same and avoid recalculating it, as the connector's	775	/*
776	* bpc may have changed after the state was duplicated	776	* When restoring duplicated states, we need to make sure that
777	*/	777	* the bw remains the same and avoid recalculating it, as the
778	if (!state->duplicated)	778	* connector's bpc may have changed after the state was
779	asyh->dp.pbn =	779	* duplicated
780	drm_dp_calc_pbn_mode(crtc_state->adjusted_mode.clock,	780	*/
781	connector->display_info.bpc * 3);	781	if (!state->duplicated) {
		782	const int bpp = connector->display_info.bpc * 3;
		783	const int clock = crtc_state->adjusted_mode.clock;
		784
		785	asyh->dp.pbn = drm_dp_calc_pbn_mode(clock, bpp);
		786	}
782		787
783	if (crtc_state->mode_changed) {
784	slots = drm_dp_atomic_find_vcpi_slots(state, &mstm->mgr,	788	slots = drm_dp_atomic_find_vcpi_slots(state, &mstm->mgr,
785	mstc->port,	789	mstc->port,
786	asyh->dp.pbn);	790	asyh->dp.pbn);

drivers/gpu/drm/rockchip/analogix_dp-rockchip.c+1−1

@@ -432,7 +432,7 @@ static int rockchip_dp_resume(struct device *dev) · 431 unmodified lines
432		432
433	static const struct dev_pm_ops rockchip_dp_pm_ops = {	433	static const struct dev_pm_ops rockchip_dp_pm_ops = {
434	#ifdef CONFIG_PM_SLEEP	434	#ifdef CONFIG_PM_SLEEP
435	.suspend = rockchip_dp_suspend,	435	.suspend_late = rockchip_dp_suspend,
436	.resume_early = rockchip_dp_resume,	436	.resume_early = rockchip_dp_resume,
437	#endif	437	#endif
438	};	438	};

drivers/gpu/drm/scheduler/sched_entity.c+2−2

@@ -95,7 +95,7 @@ static bool drm_sched_entity_is_idle(struct drm_sched_entity *entity) · 94 unmodified lines
95	rmb(); /* for list_empty to work without lock */	95	rmb(); /* for list_empty to work without lock */
96		96
97	if (list_empty(&entity->list) \|\|	97	if (list_empty(&entity->list) \|\|
98	spsc_queue_peek(&entity->job_queue) == NULL)	98	spsc_queue_count(&entity->job_queue) == 0)
99	return true;	99	return true;
100		100
101	return false;	101	return false;
@@ -281,7 +281,7 @@ void drm_sched_entity_fini(struct drm_sched_entity *entity) · 179 unmodified lines
281	/* Consumption of existing IBs wasn't completed. Forcefully	281	/* Consumption of existing IBs wasn't completed. Forcefully
282	* remove them here.	282	* remove them here.
283	*/	283	*/
284	if (spsc_queue_peek(&entity->job_queue)) {	284	if (spsc_queue_count(&entity->job_queue)) {
285	if (sched) {	285	if (sched) {
286	/* Park the kernel for a moment to make sure it isn't processing	286	/* Park the kernel for a moment to make sure it isn't processing
287	* our enity.	287	* our enity.

drivers/gpu/drm/tegra/output.c+6−2

 						       "nvidia,hpd-gpio", 0,
 						       GPIOD_IN,
 						       "HDMI hotplug detect");
-	if (IS_ERR(output->hpd_gpio))
+	if (IS_ERR(output->hpd_gpio)) {
-		return PTR_ERR(output->hpd_gpio);
+		if (PTR_ERR(output->hpd_gpio) != -ENOENT)
+			return PTR_ERR(output->hpd_gpio);
+		output->hpd_gpio = NULL;
+	}
 	if (output->hpd_gpio) {
 		err = gpiod_to_irq(output->hpd_gpio);

drivers/gpu/drm/vmwgfx/vmwgfx_msg.c+3−1

 		break;
 	}
-	if (retries == RETRIES)
+	if (retries == RETRIES) {
+		kfree(reply);
 		return -EINVAL;
+	}
 	*msg_len = reply_len;
 	*msg     = reply;

drivers/hv/hv_trace.h+1−1

@@ -1,4 +1,4 @@
1	// SPDX-License-Identifier: GPL-2.0	1	/* SPDX-License-Identifier: GPL-2.0 */
2		2
3	#undef TRACE_SYSTEM	3	#undef TRACE_SYSTEM
4	#define TRACE_SYSTEM hyperv	4	#define TRACE_SYSTEM hyperv

drivers/hwmon/lm75.c+1−1

@@ -343,7 +343,7 @@ lm75_probe(struct i2c_client client, const struct i2c_device_id id) · 342 unmodified lines
343	data->sample_time = MSEC_PER_SEC / 2;	343	data->sample_time = MSEC_PER_SEC / 2;
344	break;	344	break;
345	case tmp75b: /* not one-shot mode, Conversion rate 37Hz */	345	case tmp75b: /* not one-shot mode, Conversion rate 37Hz */
346	clr_mask \|= 1 << 15 \| 0x3 << 13;	346	clr_mask \|= 1 << 7 \| 0x3 << 5;
347	data->resolution = 12;	347	data->resolution = 12;
348	data->sample_time = MSEC_PER_SEC / 37;	348	data->sample_time = MSEC_PER_SEC / 37;
349	break;	349	break;

drivers/hwmon/nct7802.c+3−3

@@ -704,7 +704,7 @@ static struct attribute *nct7802_in_attrs[] = { · 703 unmodified lines
704	&sensor_dev_attr_in3_alarm.dev_attr.attr,	704	&sensor_dev_attr_in3_alarm.dev_attr.attr,
705	&sensor_dev_attr_in3_beep.dev_attr.attr,	705	&sensor_dev_attr_in3_beep.dev_attr.attr,
706		706
707	&sensor_dev_attr_in4_input.dev_attr.attr, /* 17 */	707	&sensor_dev_attr_in4_input.dev_attr.attr, /* 16 */
708	&sensor_dev_attr_in4_min.dev_attr.attr,	708	&sensor_dev_attr_in4_min.dev_attr.attr,
709	&sensor_dev_attr_in4_max.dev_attr.attr,	709	&sensor_dev_attr_in4_max.dev_attr.attr,
710	&sensor_dev_attr_in4_alarm.dev_attr.attr,	710	&sensor_dev_attr_in4_alarm.dev_attr.attr,
@@ -730,9 +730,9 @@ static umode_t nct7802_in_is_visible(struct kobject *kobj, · 19 unmodified lines
730		730
731	if (index >= 6 && index < 11 && (reg & 0x03) != 0x03) /* VSEN1 */	731	if (index >= 6 && index < 11 && (reg & 0x03) != 0x03) /* VSEN1 */
732	return 0;	732	return 0;
733	if (index >= 11 && index < 17 && (reg & 0x0c) != 0x0c) /* VSEN2 */	733	if (index >= 11 && index < 16 && (reg & 0x0c) != 0x0c) /* VSEN2 */
734	return 0;	734	return 0;
735	if (index >= 17 && (reg & 0x30) != 0x30) /* VSEN3 */	735	if (index >= 16 && (reg & 0x30) != 0x30) /* VSEN3 */
736	return 0;	736	return 0;
737		737
738	return attr->mode;	738	return attr->mode;

drivers/hwtracing/coresight/coresight-etm-perf.c+1−0

@@ -544,6 +544,7 @@ int etm_perf_add_symlink_sink(struct coresight_device *csdev) · 543 unmodified lines
544	/* See function coresight_get_sink_by_id() to know where this is used */	544	/* See function coresight_get_sink_by_id() to know where this is used */
545	hash = hashlen_hash(hashlen_string(NULL, name));	545	hash = hashlen_hash(hashlen_string(NULL, name));
546		546
		547	sysfs_attr_init(&ea->attr.attr);
547	ea->attr.attr.name = devm_kstrdup(dev, name, GFP_KERNEL);	548	ea->attr.attr.name = devm_kstrdup(dev, name, GFP_KERNEL);
548	if (!ea->attr.attr.name)	549	if (!ea->attr.attr.name)
549	return -ENOMEM;	550	return -ENOMEM;

drivers/hwtracing/intel_th/msu.h+1−1

@@ -1,4 +1,4 @@
1	// SPDX-License-Identifier: GPL-2.0	1	/* SPDX-License-Identifier: GPL-2.0 */
2	/*	2	/*
3	* Intel(R) Trace Hub Memory Storage Unit (MSU) data structures	3	* Intel(R) Trace Hub Memory Storage Unit (MSU) data structures
4	*	4	*

drivers/hwtracing/intel_th/pti.h+1−1

@@ -1,4 +1,4 @@
1	// SPDX-License-Identifier: GPL-2.0	1	/* SPDX-License-Identifier: GPL-2.0 */
2	/*	2	/*
3	* Intel(R) Trace Hub PTI output data structures	3	* Intel(R) Trace Hub PTI output data structures
4	*	4	*

drivers/i2c/busses/i2c-emev2.c+12−4

 	struct completion msg_done;
 	struct clk *sclk;
 	struct i2c_client *slave;
+	int irq;
 };
 static inline void em_clear_set_bit(struct em_i2c_device *priv, u8 clear, u8 set, u8 reg)
 	writeb(0, priv->base + I2C_OFS_SVA0);
+	/*
+	 * Wait for interrupt to finish. New slave irqs cannot happen because we
+	 * cleared the slave address and, thus, only extension codes will be
+	 * detected which do not use the slave ptr.
+	 */
+	synchronize_irq(priv->irq);
 	priv->slave = NULL;
 	return 0;
 {
 	struct em_i2c_device *priv;
 	struct resource *r;
-	int irq, ret;
+	int ret;
 	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
 	if (!priv)
 	em_i2c_reset(&priv->adap);
-	irq = platform_get_irq(pdev, 0);
+	priv->irq = platform_get_irq(pdev, 0);
-	ret = devm_request_irq(&pdev->dev, irq, em_i2c_irq_handler, 0,
+	ret = devm_request_irq(&pdev->dev, priv->irq, em_i2c_irq_handler, 0,
 				"em_i2c", priv);
 	if (ret)
 		goto err_clk;
 	if (ret)
 		goto err_clk;
-	dev_info(&pdev->dev, "Added i2c controller %d, irq %d\n", priv->adap.nr, irq);
+	dev_info(&pdev->dev, "Added i2c controller %d, irq %d\n", priv->adap.nr,
+		 priv->irq);
 	return 0;

drivers/i2c/busses/i2c-imx.c+6−12

 }
 /* Functions for DMA support */
-static int i2c_imx_dma_request(struct imx_i2c_struct *i2c_imx,
+static void i2c_imx_dma_request(struct imx_i2c_struct *i2c_imx,
-			       dma_addr_t phy_addr)
+						dma_addr_t phy_addr)
 {
 	struct imx_i2c_dma *dma;
 	struct dma_slave_config dma_sconfig;
 	dma = devm_kzalloc(dev, sizeof(*dma), GFP_KERNEL);
 	if (!dma)
-		return -ENOMEM;
+		return;
 	dma->chan_tx = dma_request_chan(dev, "tx");
 	if (IS_ERR(dma->chan_tx)) {
 	dev_info(dev, "using %s (tx) and %s (rx) for DMA transfers\n",
 		dma_chan_name(dma->chan_tx), dma_chan_name(dma->chan_rx));
-	return 0;
+	return;
 fail_rx:
 	dma_release_channel(dma->chan_rx);
 	dma_release_channel(dma->chan_tx);
 fail_al:
 	devm_kfree(dev, dma);
-	/* return successfully if there is no dma support */
-	return ret == -ENODEV ? 0 : ret;
 }
 static void i2c_imx_dma_callback(void *arg)
 	dev_dbg(&i2c_imx->adapter.dev, "device resources: %pR\n", res);
 	dev_dbg(&i2c_imx->adapter.dev, "adapter name: \"%s\"\n",
 		i2c_imx->adapter.name);
+	dev_info(&i2c_imx->adapter.dev, "IMX I2C adapter registered\n");
 	/* Init DMA config if supported */
-	ret = i2c_imx_dma_request(i2c_imx, phy_addr);
+	i2c_imx_dma_request(i2c_imx, phy_addr);
-	if (ret < 0)
-		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/i2c/busses/i2c-rcar.c+7−4

 	enum dma_data_direction dma_direction;
 	struct reset_control *rstc;
+	int irq;
 };
 #define rcar_i2c_priv_to_dev(p)		((p)->adap.dev.parent)
 	WARN_ON(!priv->slave);
+	/* disable irqs and ensure none is running before clearing ptr */
 	rcar_i2c_write(priv, ICSIER, 0);
 	rcar_i2c_write(priv, ICSCR, 0);
+	synchronize_irq(priv->irq);
 	priv->slave = NULL;
 	pm_runtime_put(rcar_i2c_priv_to_dev(priv));
 	struct i2c_adapter *adap;
 	struct device *dev = &pdev->dev;
 	struct i2c_timings i2c_t;
-	int irq, ret;
+	int ret;
 	/* Otherwise logic will break because some bytes must always use PIO */
 	BUILD_BUG_ON_MSG(RCAR_MIN_DMA_LEN < 3, "Invalid min DMA length");
 		pm_runtime_put(dev);
-	irq = platform_get_irq(pdev, 0);
+	priv->irq = platform_get_irq(pdev, 0);
-	ret = devm_request_irq(dev, irq, rcar_i2c_irq, 0, dev_name(dev), priv);
+	ret = devm_request_irq(dev, priv->irq, rcar_i2c_irq, 0, dev_name(dev), priv);
 	if (ret < 0) {
-		dev_err(dev, "cannot get irq %d\n", irq);
+		dev_err(dev, "cannot get irq %d\n", priv->irq);
 		goto out_pm_disable;
 	}

drivers/i2c/busses/i2c-stm32.h+1−1

@@ -1,4 +1,4 @@
1	// SPDX-License-Identifier: GPL-2.0	1	/* SPDX-License-Identifier: GPL-2.0 */
2	/*	2	/*
3	* i2c-stm32.h	3	* i2c-stm32.h
4	*	4	*

drivers/iio/accel/cros_ec_accel_legacy.c+0−1

@@ -319,7 +319,6 @@ static const struct iio_chan_spec_ext_info cros_ec_accel_legacy_ext_info[] = { · 318 unmodified lines
319	.modified = 1, \	319	.modified = 1, \
320	.info_mask_separate = \	320	.info_mask_separate = \
321	BIT(IIO_CHAN_INFO_RAW) \| \	321	BIT(IIO_CHAN_INFO_RAW) \| \
322	BIT(IIO_CHAN_INFO_SCALE) \| \
323	BIT(IIO_CHAN_INFO_CALIBBIAS), \	322	BIT(IIO_CHAN_INFO_CALIBBIAS), \
324	.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SCALE), \	323	.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SCALE), \
325	.ext_info = cros_ec_accel_legacy_ext_info, \	324	.ext_info = cros_ec_accel_legacy_ext_info, \

drivers/iio/adc/ingenic-adc.c+54−0

@@ -11,6 +11,7 @@ · 10 unmodified lines
11	#include <linux/iio/iio.h>	11	#include <linux/iio/iio.h>
12	#include <linux/io.h>	12	#include <linux/io.h>
13	#include <linux/iopoll.h>	13	#include <linux/iopoll.h>
		14	#include <linux/kernel.h>
14	#include <linux/module.h>	15	#include <linux/module.h>
15	#include <linux/mutex.h>	16	#include <linux/mutex.h>
16	#include <linux/platform_device.h>	17	#include <linux/platform_device.h>
@@ -22,8 +23,11 @@ · 5 unmodified lines
22	#define JZ_ADC_REG_ADTCH 0x18	23	#define JZ_ADC_REG_ADTCH 0x18
23	#define JZ_ADC_REG_ADBDAT 0x1c	24	#define JZ_ADC_REG_ADBDAT 0x1c
24	#define JZ_ADC_REG_ADSDAT 0x20	25	#define JZ_ADC_REG_ADSDAT 0x20
		26	#define JZ_ADC_REG_ADCLK 0x28
25		27
26	#define JZ_ADC_REG_CFG_BAT_MD BIT(4)	28	#define JZ_ADC_REG_CFG_BAT_MD BIT(4)
		29	#define JZ_ADC_REG_ADCLK_CLKDIV_LSB 0
		30	#define JZ_ADC_REG_ADCLK_CLKDIV10US_LSB 16
27		31
28	#define JZ_ADC_AUX_VREF 3300	32	#define JZ_ADC_AUX_VREF 3300
29	#define JZ_ADC_AUX_VREF_BITS 12	33	#define JZ_ADC_AUX_VREF_BITS 12
@@ -34,6 +38,8 @@ · 4 unmodified lines
34	#define JZ4740_ADC_BATTERY_HIGH_VREF (7500 * 0.986)	38	#define JZ4740_ADC_BATTERY_HIGH_VREF (7500 * 0.986)
35	#define JZ4740_ADC_BATTERY_HIGH_VREF_BITS 12	39	#define JZ4740_ADC_BATTERY_HIGH_VREF_BITS 12
36		40
		41	struct ingenic_adc;
		42
37	struct ingenic_adc_soc_data {	43	struct ingenic_adc_soc_data {
38	unsigned int battery_high_vref;	44	unsigned int battery_high_vref;
39	unsigned int battery_high_vref_bits;	45	unsigned int battery_high_vref_bits;
@@ -41,6 +47,7 @@ struct ingenic_adc_soc_data { · 1 unmodified line
41	size_t battery_raw_avail_size;	47	size_t battery_raw_avail_size;
42	const int *battery_scale_avail;	48	const int *battery_scale_avail;
43	size_t battery_scale_avail_size;	49	size_t battery_scale_avail_size;
		50	int (init_clk_div)(struct device dev, struct ingenic_adc *adc);
44	};	51	};
45		52
46	struct ingenic_adc {	53	struct ingenic_adc {
@@ -151,6 +158,42 @@ static const int jz4740_adc_battery_scale_avail[] = { · 104 unmodified lines
151	JZ_ADC_BATTERY_LOW_VREF, JZ_ADC_BATTERY_LOW_VREF_BITS,	158	JZ_ADC_BATTERY_LOW_VREF, JZ_ADC_BATTERY_LOW_VREF_BITS,
152	};	159	};
153		160
		161	static int jz4725b_adc_init_clk_div(struct device dev, struct ingenic_adc adc)
		162	{
		163	struct clk *parent_clk;
		164	unsigned long parent_rate, rate;
		165	unsigned int div_main, div_10us;
		166
		167	parent_clk = clk_get_parent(adc->clk);
		168	if (!parent_clk) {
		169	dev_err(dev, "ADC clock has no parent\n");
		170	return -ENODEV;
		171	}
		172	parent_rate = clk_get_rate(parent_clk);
		173
		174	/*
		175	* The JZ4725B ADC works at 500 kHz to 8 MHz.
		176	* We pick the highest rate possible.
		177	* In practice we typically get 6 MHz, half of the 12 MHz EXT clock.
		178	*/
		179	div_main = DIV_ROUND_UP(parent_rate, 8000000);
		180	div_main = clamp(div_main, 1u, 64u);
		181	rate = parent_rate / div_main;
		182	if (rate < 500000 \|\| rate > 8000000) {
		183	dev_err(dev, "No valid divider for ADC main clock\n");
		184	return -EINVAL;
		185	}
		186
		187	/* We also need a divider that produces a 10us clock. */
		188	div_10us = DIV_ROUND_UP(rate, 100000);
		189
		190	writel(((div_10us - 1) << JZ_ADC_REG_ADCLK_CLKDIV10US_LSB) \|
		191	(div_main - 1) << JZ_ADC_REG_ADCLK_CLKDIV_LSB,
		192	adc->base + JZ_ADC_REG_ADCLK);
		193
		194	return 0;
		195	}
		196
154	static const struct ingenic_adc_soc_data jz4725b_adc_soc_data = {	197	static const struct ingenic_adc_soc_data jz4725b_adc_soc_data = {
155	.battery_high_vref = JZ4725B_ADC_BATTERY_HIGH_VREF,	198	.battery_high_vref = JZ4725B_ADC_BATTERY_HIGH_VREF,
156	.battery_high_vref_bits = JZ4725B_ADC_BATTERY_HIGH_VREF_BITS,	199	.battery_high_vref_bits = JZ4725B_ADC_BATTERY_HIGH_VREF_BITS,
@@ -158,6 +201,7 @@ static const struct ingenic_adc_soc_data jz4725b_adc_soc_data = { · 1 unmodified line
158	.battery_raw_avail_size = ARRAY_SIZE(jz4725b_adc_battery_raw_avail),	201	.battery_raw_avail_size = ARRAY_SIZE(jz4725b_adc_battery_raw_avail),
159	.battery_scale_avail = jz4725b_adc_battery_scale_avail,	202	.battery_scale_avail = jz4725b_adc_battery_scale_avail,
160	.battery_scale_avail_size = ARRAY_SIZE(jz4725b_adc_battery_scale_avail),	203	.battery_scale_avail_size = ARRAY_SIZE(jz4725b_adc_battery_scale_avail),
		204	.init_clk_div = jz4725b_adc_init_clk_div,
161	};	205	};
162		206
163	static const struct ingenic_adc_soc_data jz4740_adc_soc_data = {	207	static const struct ingenic_adc_soc_data jz4740_adc_soc_data = {
@@ -167,6 +211,7 @@ static const struct ingenic_adc_soc_data jz4740_adc_soc_data = { · 3 unmodified lines
167	.battery_raw_avail_size = ARRAY_SIZE(jz4740_adc_battery_raw_avail),	211	.battery_raw_avail_size = ARRAY_SIZE(jz4740_adc_battery_raw_avail),
168	.battery_scale_avail = jz4740_adc_battery_scale_avail,	212	.battery_scale_avail = jz4740_adc_battery_scale_avail,
169	.battery_scale_avail_size = ARRAY_SIZE(jz4740_adc_battery_scale_avail),	213	.battery_scale_avail_size = ARRAY_SIZE(jz4740_adc_battery_scale_avail),
		214	.init_clk_div = NULL, /* no ADCLK register on JZ4740 */
170	};	215	};
171		216
172	static int ingenic_adc_read_avail(struct iio_dev *iio_dev,	217	static int ingenic_adc_read_avail(struct iio_dev *iio_dev,
@@ -317,6 +362,15 @@ static int ingenic_adc_probe(struct platform_device *pdev) · 144 unmodified lines
317	return ret;	362	return ret;
318	}	363	}
319		364
		365	/* Set clock dividers. */
		366	if (soc_data->init_clk_div) {
		367	ret = soc_data->init_clk_div(dev, adc);
		368	if (ret) {
		369	clk_disable_unprepare(adc->clk);
		370	return ret;
		371	}
		372	}
		373
320	/* Put hardware in a known passive state. */	374	/* Put hardware in a known passive state. */
321	writeb(0x00, adc->base + JZ_ADC_REG_ENABLE);	375	writeb(0x00, adc->base + JZ_ADC_REG_ENABLE);
322	writeb(0xff, adc->base + JZ_ADC_REG_CTRL);	376	writeb(0xff, adc->base + JZ_ADC_REG_CTRL);

drivers/iio/adc/max9611.c+2−2

@@ -83,7 +83,7 @@ · 82 unmodified lines
83	#define MAX9611_TEMP_MAX_POS 0x7f80	83	#define MAX9611_TEMP_MAX_POS 0x7f80
84	#define MAX9611_TEMP_MAX_NEG 0xff80	84	#define MAX9611_TEMP_MAX_NEG 0xff80
85	#define MAX9611_TEMP_MIN_NEG 0xd980	85	#define MAX9611_TEMP_MIN_NEG 0xd980
86	#define MAX9611_TEMP_MASK GENMASK(7, 15)	86	#define MAX9611_TEMP_MASK GENMASK(15, 7)
87	#define MAX9611_TEMP_SHIFT 0x07	87	#define MAX9611_TEMP_SHIFT 0x07
88	#define MAX9611_TEMP_RAW(_r) ((_r) >> MAX9611_TEMP_SHIFT)	88	#define MAX9611_TEMP_RAW(_r) ((_r) >> MAX9611_TEMP_SHIFT)
89	#define MAX9611_TEMP_SCALE_NUM 1000000	89	#define MAX9611_TEMP_SCALE_NUM 1000000
@@ -480,7 +480,7 @@ static int max9611_init(struct max9611_dev *max9611) · 390 unmodified lines
480	if (ret)	480	if (ret)
481	return ret;	481	return ret;
482		482
483	regval = ret & MAX9611_TEMP_MASK;	483	regval &= MAX9611_TEMP_MASK;
484		484
485	if ((regval > MAX9611_TEMP_MAX_POS &&	485	if ((regval > MAX9611_TEMP_MAX_POS &&
486	regval < MAX9611_TEMP_MIN_NEG) \|\|	486	regval < MAX9611_TEMP_MIN_NEG) \|\|

drivers/iio/adc/rcar-gyroadc.c+2−2

@@ -382,7 +382,7 @@ static int rcar_gyroadc_parse_subdevs(struct iio_dev *indio_dev) · 381 unmodified lines
382	dev_err(dev,	382	dev_err(dev,
383	"Only %i channels supported with %pOFn, but reg = <%i>.\n",	383	"Only %i channels supported with %pOFn, but reg = <%i>.\n",
384	num_channels, child, reg);	384	num_channels, child, reg);
385	return ret;	385	return -EINVAL;
386	}	386	}
387	}	387	}
388		388
@@ -391,7 +391,7 @@ static int rcar_gyroadc_parse_subdevs(struct iio_dev *indio_dev) · 2 unmodified lines
391	dev_err(dev,	391	dev_err(dev,
392	"Channel %i uses different ADC mode than the rest.\n",	392	"Channel %i uses different ADC mode than the rest.\n",
393	reg);	393	reg);
394	return ret;	394	return -EINVAL;
395	}	395	}
396		396
397	/* Channel is valid, grab the regulator. */	397	/* Channel is valid, grab the regulator. */

drivers/iio/frequency/adf4371.c+4−4

@@ -276,11 +276,11 @@ static int adf4371_set_freq(struct adf4371_state *st, unsigned long long freq, · 275 unmodified lines
276	st->buf[0] = st->integer >> 8;	276	st->buf[0] = st->integer >> 8;
277	st->buf[1] = 0x40; /* REG12 default */	277	st->buf[1] = 0x40; /* REG12 default */
278	st->buf[2] = 0x00;	278	st->buf[2] = 0x00;
279	st->buf[3] = st->fract2 & 0xFF;	279	st->buf[3] = st->fract1 & 0xFF;
280	st->buf[4] = st->fract2 >> 7;	280	st->buf[4] = st->fract1 >> 8;
281	st->buf[5] = st->fract2 >> 15;	281	st->buf[5] = st->fract1 >> 16;
282	st->buf[6] = ADF4371_FRAC2WORD_L(st->fract2 & 0x7F) \|	282	st->buf[6] = ADF4371_FRAC2WORD_L(st->fract2 & 0x7F) \|
283	ADF4371_FRAC1WORD(st->fract1 >> 23);	283	ADF4371_FRAC1WORD(st->fract1 >> 24);
284	st->buf[7] = ADF4371_FRAC2WORD_H(st->fract2 >> 7);	284	st->buf[7] = ADF4371_FRAC2WORD_H(st->fract2 >> 7);
285	st->buf[8] = st->mod2 & 0xFF;	285	st->buf[8] = st->mod2 & 0xFF;
286	st->buf[9] = ADF4371_MOD2WORD(st->mod2 >> 8);	286	st->buf[9] = ADF4371_MOD2WORD(st->mod2 >> 8);

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

@@ -845,6 +845,25 @@ static const struct iio_chan_spec inv_mpu_channels[] = { · 844 unmodified lines
845	INV_MPU6050_CHAN(IIO_ACCEL, IIO_MOD_Z, INV_MPU6050_SCAN_ACCL_Z),	845	INV_MPU6050_CHAN(IIO_ACCEL, IIO_MOD_Z, INV_MPU6050_SCAN_ACCL_Z),
846	};	846	};
847		847
		848	static const unsigned long inv_mpu_scan_masks[] = {
		849	/* 3-axis accel */
		850	BIT(INV_MPU6050_SCAN_ACCL_X)
		851	\| BIT(INV_MPU6050_SCAN_ACCL_Y)
		852	\| BIT(INV_MPU6050_SCAN_ACCL_Z),
		853	/* 3-axis gyro */
		854	BIT(INV_MPU6050_SCAN_GYRO_X)
		855	\| BIT(INV_MPU6050_SCAN_GYRO_Y)
		856	\| BIT(INV_MPU6050_SCAN_GYRO_Z),
		857	/* 6-axis accel + gyro */
		858	BIT(INV_MPU6050_SCAN_ACCL_X)
		859	\| BIT(INV_MPU6050_SCAN_ACCL_Y)
		860	\| BIT(INV_MPU6050_SCAN_ACCL_Z)
		861	\| BIT(INV_MPU6050_SCAN_GYRO_X)
		862	\| BIT(INV_MPU6050_SCAN_GYRO_Y)
		863	\| BIT(INV_MPU6050_SCAN_GYRO_Z),
		864	0,
		865	};
		866
848	static const struct iio_chan_spec inv_icm20602_channels[] = {	867	static const struct iio_chan_spec inv_icm20602_channels[] = {
849	IIO_CHAN_SOFT_TIMESTAMP(INV_ICM20602_SCAN_TIMESTAMP),	868	IIO_CHAN_SOFT_TIMESTAMP(INV_ICM20602_SCAN_TIMESTAMP),
850	{	869	{
@@ -871,6 +890,28 @@ static const struct iio_chan_spec inv_icm20602_channels[] = { · 20 unmodified lines
871	INV_MPU6050_CHAN(IIO_ACCEL, IIO_MOD_Z, INV_ICM20602_SCAN_ACCL_Z),	890	INV_MPU6050_CHAN(IIO_ACCEL, IIO_MOD_Z, INV_ICM20602_SCAN_ACCL_Z),
872	};	891	};
873		892
		893	static const unsigned long inv_icm20602_scan_masks[] = {
		894	/* 3-axis accel + temp (mandatory) */
		895	BIT(INV_ICM20602_SCAN_ACCL_X)
		896	\| BIT(INV_ICM20602_SCAN_ACCL_Y)
		897	\| BIT(INV_ICM20602_SCAN_ACCL_Z)
		898	\| BIT(INV_ICM20602_SCAN_TEMP),
		899	/* 3-axis gyro + temp (mandatory) */
		900	BIT(INV_ICM20602_SCAN_GYRO_X)
		901	\| BIT(INV_ICM20602_SCAN_GYRO_Y)
		902	\| BIT(INV_ICM20602_SCAN_GYRO_Z)
		903	\| BIT(INV_ICM20602_SCAN_TEMP),
		904	/* 6-axis accel + gyro + temp (mandatory) */
		905	BIT(INV_ICM20602_SCAN_ACCL_X)
		906	\| BIT(INV_ICM20602_SCAN_ACCL_Y)
		907	\| BIT(INV_ICM20602_SCAN_ACCL_Z)
		908	\| BIT(INV_ICM20602_SCAN_GYRO_X)
		909	\| BIT(INV_ICM20602_SCAN_GYRO_Y)
		910	\| BIT(INV_ICM20602_SCAN_GYRO_Z)
		911	\| BIT(INV_ICM20602_SCAN_TEMP),
		912	0,
		913	};
		914
874	/*	915	/*
875	* The user can choose any frequency between INV_MPU6050_MIN_FIFO_RATE and	916	* The user can choose any frequency between INV_MPU6050_MIN_FIFO_RATE and
876	* INV_MPU6050_MAX_FIFO_RATE, but only these frequencies are matched by the	917	* INV_MPU6050_MAX_FIFO_RATE, but only these frequencies are matched by the
@@ -1130,9 +1171,11 @@ int inv_mpu_core_probe(struct regmap regmap, int irq, const char name, · 253 unmodified lines
1130	if (chip_type == INV_ICM20602) {	1171	if (chip_type == INV_ICM20602) {
1131	indio_dev->channels = inv_icm20602_channels;	1172	indio_dev->channels = inv_icm20602_channels;
1132	indio_dev->num_channels = ARRAY_SIZE(inv_icm20602_channels);	1173	indio_dev->num_channels = ARRAY_SIZE(inv_icm20602_channels);
		1174	indio_dev->available_scan_masks = inv_icm20602_scan_masks;
1133	} else {	1175	} else {
1134	indio_dev->channels = inv_mpu_channels;	1176	indio_dev->channels = inv_mpu_channels;
1135	indio_dev->num_channels = ARRAY_SIZE(inv_mpu_channels);	1177	indio_dev->num_channels = ARRAY_SIZE(inv_mpu_channels);
		1178	indio_dev->available_scan_masks = inv_mpu_scan_masks;
1136	}	1179	}
1137		1180
1138	indio_dev->info = &mpu_info;	1181	indio_dev->info = &mpu_info;

drivers/infiniband/core/counters.c+6−0

 	int ret;
 	port_counter = &dev->port_data[port].port_counter;
+	if (!port_counter->hstats)
+		return -EOPNOTSUPP;
 	mutex_lock(&port_counter->lock);
 	if (on) {
 		ret = __counter_set_mode(&port_counter->mode,
 	if (!rdma_is_port_valid(dev, port))
 		return -EINVAL;
+	if (!dev->port_data[port].port_counter.hstats)
+		return -EOPNOTSUPP;
 	qp = rdma_counter_get_qp(dev, qp_num);
 	if (!qp)
 		return -ENOENT;

drivers/infiniband/core/nldev.c+6−2

 	if (fill_nldev_handle(msg, device) ||
 	    nla_put_u32(msg, RDMA_NLDEV_ATTR_PORT_INDEX, port) ||
-	    nla_put_u32(msg, RDMA_NLDEV_ATTR_STAT_MODE, mode))
+	    nla_put_u32(msg, RDMA_NLDEV_ATTR_STAT_MODE, mode)) {
+		ret = -EMSGSIZE;
 		goto err_msg;
+	}
 	if ((mode == RDMA_COUNTER_MODE_AUTO) &&
-	    nla_put_u32(msg, RDMA_NLDEV_ATTR_STAT_AUTO_MODE_MASK, mask))
+	    nla_put_u32(msg, RDMA_NLDEV_ATTR_STAT_AUTO_MODE_MASK, mask)) {
+		ret = -EMSGSIZE;
 		goto err_msg;
+	}
 	nlmsg_end(msg, nlh);
 	ib_device_put(device);

drivers/infiniband/core/umem_odp.c+0−4

 	 * prevent any further fault handling on this MR.
 	 */
 	ib_umem_notifier_start_account(umem_odp);
-	umem_odp->dying = 1;
-	/* Make sure that the fact the umem is dying is out before we release
-	 * all pending page faults. */
-	smp_wmb();
 	complete_all(&umem_odp->notifier_completion);
 	umem_odp->umem.context->invalidate_range(
 		umem_odp, ib_umem_start(umem_odp), ib_umem_end(umem_odp));

drivers/infiniband/hw/mlx5/devx.c+6−5

 			event_sub->eventfd =
 				eventfd_ctx_fdget(redirect_fd);
-			if (IS_ERR(event_sub)) {
+			if (IS_ERR(event_sub->eventfd)) {
 				err = PTR_ERR(event_sub->eventfd);
 				event_sub->eventfd = NULL;
 				goto err;
 	struct devx_async_event_file *ev_file = filp->private_data;
 	struct devx_event_subscription *event_sub, *event_sub_tmp;
 	struct devx_async_event_data *entry, *tmp;
+	struct mlx5_ib_dev *dev = ev_file->dev;
-	mutex_lock(&ev_file->dev->devx_event_table.event_xa_lock);
+	mutex_lock(&dev->devx_event_table.event_xa_lock);
 	/* delete the subscriptions which are related to this FD */
 	list_for_each_entry_safe(event_sub, event_sub_tmp,
 				 &ev_file->subscribed_events_list, file_list) {
-		devx_cleanup_subscription(ev_file->dev, event_sub);
+		devx_cleanup_subscription(dev, event_sub);
 		if (event_sub->eventfd)
 			eventfd_ctx_put(event_sub->eventfd);
 		kfree_rcu(event_sub, rcu);
 	}
-	mutex_unlock(&ev_file->dev->devx_event_table.event_xa_lock);
+	mutex_unlock(&dev->devx_event_table.event_xa_lock);
 	/* free the pending events allocation */
 	if (!ev_file->omit_data) {
 	}
 	uverbs_close_fd(filp);
-	put_device(&ev_file->dev->ib_dev.dev);
+	put_device(&dev->ib_dev.dev);
 	return 0;
 }

drivers/infiniband/hw/mlx5/odp.c+9−15

@@ -579,7 +579,6 @@ static int pagefault_mr(struct mlx5_ib_dev dev, struct mlx5_ib_mr mr, · 578 unmodified lines
579	u32 flags)	579	u32 flags)
580	{	580	{
581	int npages = 0, current_seq, page_shift, ret, np;	581	int npages = 0, current_seq, page_shift, ret, np;
582	bool implicit = false;
583	struct ib_umem_odp *odp_mr = to_ib_umem_odp(mr->umem);	582	struct ib_umem_odp *odp_mr = to_ib_umem_odp(mr->umem);
584	bool downgrade = flags & MLX5_PF_FLAGS_DOWNGRADE;	583	bool downgrade = flags & MLX5_PF_FLAGS_DOWNGRADE;
585	bool prefetch = flags & MLX5_PF_FLAGS_PREFETCH;	584	bool prefetch = flags & MLX5_PF_FLAGS_PREFETCH;
@@ -594,7 +593,6 @@ static int pagefault_mr(struct mlx5_ib_dev dev, struct mlx5_ib_mr mr, · 8 unmodified lines
594	if (IS_ERR(odp))	593	if (IS_ERR(odp))
595	return PTR_ERR(odp);	594	return PTR_ERR(odp);
596	mr = odp->private;	595	mr = odp->private;
597	implicit = true;
598	} else {	596	} else {
599	odp = odp_mr;	597	odp = odp_mr;
600	}	598	}
@@ -682,19 +680,15 @@ next_mr: · 81 unmodified lines
682		680
683	out:	681	out:
684	if (ret == -EAGAIN) {	682	if (ret == -EAGAIN) {
685	if (implicit \|\| !odp->dying) {	683	unsigned long timeout = msecs_to_jiffies(MMU_NOTIFIER_TIMEOUT);
686	unsigned long timeout =	684
687	msecs_to_jiffies(MMU_NOTIFIER_TIMEOUT);	685	if (!wait_for_completion_timeout(&odp->notifier_completion,
688		686	timeout)) {
689	if (!wait_for_completion_timeout(	687	mlx5_ib_warn(
690	&odp->notifier_completion,	688	dev,
691	timeout)) {	689	"timeout waiting for mmu notifier. seq %d against %d. notifiers_count=%d\n",
692	mlx5_ib_warn(dev, "timeout waiting for mmu notifier. seq %d against %d. notifiers_count=%d\n",	690	current_seq, odp->notifiers_seq,
693	current_seq, odp->notifiers_seq, odp->notifiers_count);	691	odp->notifiers_count);
694	}
695	} else {
696	/* The MR is being killed, kill the QP as well. */
697	ret = -EFAULT;
698	}	692	}
699	}	693	}
700		694

drivers/infiniband/sw/siw/Kconfig+1−1

@@ -1,6 +1,6 @@
1	config RDMA_SIW	1	config RDMA_SIW
2	tristate "Software RDMA over TCP/IP (iWARP) driver"	2	tristate "Software RDMA over TCP/IP (iWARP) driver"
3	depends on INET && INFINIBAND && LIBCRC32C && 64BIT	3	depends on INET && INFINIBAND && LIBCRC32C
4	select DMA_VIRT_OPS	4	select DMA_VIRT_OPS
5	help	5	help
6	This driver implements the iWARP RDMA transport over	6	This driver implements the iWARP RDMA transport over

drivers/infiniband/sw/siw/siw.h+1−1

@@ -214,7 +214,7 @@ struct siw_wqe { · 213 unmodified lines
214	struct siw_cq {	214	struct siw_cq {
215	struct ib_cq base_cq;	215	struct ib_cq base_cq;
216	spinlock_t lock;	216	spinlock_t lock;
217	u64 *notify;	217	struct siw_cq_ctrl *notify;
218	struct siw_cqe *queue;	218	struct siw_cqe *queue;
219	u32 cq_put;	219	u32 cq_put;
220	u32 cq_get;	220	u32 cq_get;

drivers/infiniband/sw/siw/siw_main.c+1−3

 out_err:
 	siw_cpu_info.num_nodes = 0;
-	while (i) {
+	while (--i >= 0)
 		kfree(siw_cpu_info.tx_valid_cpus[i]);
-		siw_cpu_info.tx_valid_cpus[i--] = NULL;
-	}
 	kfree(siw_cpu_info.tx_valid_cpus);
 	siw_cpu_info.tx_valid_cpus = NULL;

drivers/infiniband/sw/siw/siw_qp.c+10−4

  */
 static bool siw_cq_notify_now(struct siw_cq *cq, u32 flags)
 {
-	u64 cq_notify;
+	u32 cq_notify;
 	if (!cq->base_cq.comp_handler)
 		return false;
-	cq_notify = READ_ONCE(*cq->notify);
+	/* Read application shared notification state */
+	cq_notify = READ_ONCE(cq->notify->flags);
 	if ((cq_notify & SIW_NOTIFY_NEXT_COMPLETION) ||
 	    ((cq_notify & SIW_NOTIFY_SOLICITED) &&
 	     (flags & SIW_WQE_SOLICITED))) {
-		/* dis-arm CQ */
+		/*
-		smp_store_mb(*cq->notify, SIW_NOTIFY_NOT);
+		 * CQ notification is one-shot: Since the
+		 * current CQE causes user notification,
+		 * the CQ gets dis-aremd and must be re-aremd
+		 * by the user for a new notification.
+		 */
+		WRITE_ONCE(cq->notify->flags, SIW_NOTIFY_NOT);
 		return true;
 	}

drivers/infiniband/sw/siw/siw_verbs.c+11−5

 	spin_lock_init(&cq->lock);
-	cq->notify = &((struct siw_cq_ctrl *)&cq->queue[size])->notify;
+	cq->notify = (struct siw_cq_ctrl *)&cq->queue[size];
 	if (udata) {
 		struct siw_uresp_create_cq uresp = {};
 	siw_dbg_cq(cq, "flags: 0x%02x\n", flags);
 	if ((flags & IB_CQ_SOLICITED_MASK) == IB_CQ_SOLICITED)
-		/* CQ event for next solicited completion */
+		/*
-		smp_store_mb(*cq->notify, SIW_NOTIFY_SOLICITED);
+		 * Enable CQ event for next solicited completion.
+		 * and make it visible to all associated producers.
+		 */
+		smp_store_mb(cq->notify->flags, SIW_NOTIFY_SOLICITED);
 	else
-		/* CQ event for any signalled completion */
+		/*
-		smp_store_mb(*cq->notify, SIW_NOTIFY_ALL);
+		 * Enable CQ event for any signalled completion.
+		 * and make it visible to all associated producers.
+		 */
+		smp_store_mb(cq->notify->flags, SIW_NOTIFY_ALL);
 	if (flags & IB_CQ_REPORT_MISSED_EVENTS)
 		return cq->cq_put - cq->cq_get;

drivers/input/joystick/iforce/iforce-usb.c+5−0

 		return -ENODEV;
 	epirq = &interface->endpoint[0].desc;
+	if (!usb_endpoint_is_int_in(epirq))
+		return -ENODEV;
 	epout = &interface->endpoint[1].desc;
+	if (!usb_endpoint_is_int_out(epout))
+		return -ENODEV;
 	iforce_usb = kzalloc(sizeof(*iforce_usb), GFP_KERNEL);
 	if (!iforce_usb)

drivers/input/keyboard/Kconfig+2−0

 	depends on ACPI && EFI
 	depends on SPI
 	depends on X86 || COMPILE_TEST
+	depends on LEDS_CLASS
+	select CRC16
 	help
 	  Say Y here if you are running Linux on any Apple MacBook8,1 or later,
 	  or any MacBookPro13,* or MacBookPro14,*.

drivers/input/keyboard/applespi.c+16−13

  * struct tp_finger - single trackpad finger structure, le16-aligned
  *
  * @origin:		zero when switching track finger
- * @abs_x:		absolute x coodinate
+ * @abs_x:		absolute x coordinate
- * @abs_y:		absolute y coodinate
+ * @abs_y:		absolute y coordinate
- * @rel_x:		relative x coodinate
+ * @rel_x:		relative x coordinate
- * @rel_y:		relative y coodinate
+ * @rel_y:		relative y coordinate
  * @tool_major:		tool area, major axis
  * @tool_minor:		tool area, minor axis
  * @orientation:	16384 when point, else 15 bit angle
 static void applespi_debug_update_dimensions(struct applespi_data *applespi,
 					     const struct tp_finger *f)
 {
-	applespi->tp_dim_min_x = min_t(int, applespi->tp_dim_min_x, f->abs_x);
+	applespi->tp_dim_min_x = min(applespi->tp_dim_min_x,
-	applespi->tp_dim_max_x = max_t(int, applespi->tp_dim_max_x, f->abs_x);
+				     le16_to_int(f->abs_x));
-	applespi->tp_dim_min_y = min_t(int, applespi->tp_dim_min_y, f->abs_y);
+	applespi->tp_dim_max_x = max(applespi->tp_dim_max_x,
-	applespi->tp_dim_max_y = max_t(int, applespi->tp_dim_max_y, f->abs_y);
+				     le16_to_int(f->abs_x));
+	applespi->tp_dim_min_y = min(applespi->tp_dim_min_y,
+				     le16_to_int(f->abs_y));
+	applespi->tp_dim_max_y = max(applespi->tp_dim_max_y,
+				     le16_to_int(f->abs_y));
 }
 static int applespi_tp_dim_open(struct inode *inode, struct file *file)
 		size_t tp_len;
 		tp = &message->touchpad;
-		tp_len = sizeof(*tp) +
+		tp_len = struct_size(tp, fingers, tp->number_of_fingers);
-			 tp->number_of_fingers * sizeof(tp->fingers[0]);
 		if (le16_to_cpu(message->length) + 2 != tp_len) {
 			dev_warn_ratelimited(&applespi->spi->dev,
 	efi_attr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS |
 		   EFI_VARIABLE_RUNTIME_ACCESS;
-	sts = efivar_entry_set_safe(EFI_BL_LEVEL_NAME, efi_guid, efi_attr, true,
+	sts = efivar_entry_set_safe((efi_char16_t *)EFI_BL_LEVEL_NAME, efi_guid,
-				    efi_data_len, &efi_data);
+				    efi_attr, true, efi_data_len, &efi_data);
 	if (sts)
 		dev_warn(&applespi->spi->dev,
 			 "Error saving backlight level to EFI vars: %d\n", sts);
 };
 MODULE_DEVICE_TABLE(acpi, applespi_acpi_match);
-const struct dev_pm_ops applespi_pm_ops = {
+static const struct dev_pm_ops applespi_pm_ops = {
 	SET_SYSTEM_SLEEP_PM_OPS(applespi_suspend, applespi_resume)
 	.poweroff_late	= applespi_poweroff_late,
 };

drivers/input/mouse/elantech.c+26−29

 				  leave_breadcrumbs);
 }
+static bool elantech_use_host_notify(struct psmouse *psmouse,
+				     struct elantech_device_info *info)
+{
+	if (ETP_NEW_IC_SMBUS_HOST_NOTIFY(info->fw_version))
+		return true;
+	switch (info->bus) {
+	case ETP_BUS_PS2_ONLY:
+		/* expected case */
+		break;
+	case ETP_BUS_SMB_HST_NTFY_ONLY:
+	case ETP_BUS_PS2_SMB_HST_NTFY:
+		/* SMbus implementation is stable since 2018 */
+		if (dmi_get_bios_year() >= 2018)
+			return true;
+		/* fall through */
+	default:
+		psmouse_dbg(psmouse,
+			    "Ignoring SMBus bus provider %d\n", info->bus);
+		break;
+	}
+	return false;
+}
 /**
  * elantech_setup_smbus - called once the PS/2 devices are enumerated
  * and decides to instantiate a SMBus InterTouch device.
 		 * i2c_blacklist_pnp_ids.
 		 * Old ICs are up to the user to decide.
 		 */
-		if (!ETP_NEW_IC_SMBUS_HOST_NOTIFY(info->fw_version) ||
+		if (!elantech_use_host_notify(psmouse, info) ||
 		    psmouse_matches_pnp_id(psmouse, i2c_blacklist_pnp_ids))
 			return -ENXIO;
 	}
 	return 0;
 }
-static bool elantech_use_host_notify(struct psmouse *psmouse,
-				     struct elantech_device_info *info)
-{
-	if (ETP_NEW_IC_SMBUS_HOST_NOTIFY(info->fw_version))
-		return true;
-	switch (info->bus) {
-	case ETP_BUS_PS2_ONLY:
-		/* expected case */
-		break;
-	case ETP_BUS_SMB_ALERT_ONLY:
-		/* fall-through  */
-	case ETP_BUS_PS2_SMB_ALERT:
-		psmouse_dbg(psmouse, "Ignoring SMBus provider through alert protocol.\n");
-		break;
-	case ETP_BUS_SMB_HST_NTFY_ONLY:
-		/* fall-through  */
-	case ETP_BUS_PS2_SMB_HST_NTFY:
-		return true;
-	default:
-		psmouse_dbg(psmouse,
-			    "Ignoring SMBus bus provider %d.\n",
-			    info->bus);
-	}
-	return false;
-}
 int elantech_init_smbus(struct psmouse *psmouse)
 {
 	struct elantech_device_info info;

drivers/input/mouse/synaptics.c+1−0

@@ -182,6 +182,7 @@ static const char * const smbus_pnp_ids[] = { · 181 unmodified lines
182	"LEN2055", /* E580 */	182	"LEN2055", /* E580 */
183	"SYN3052", /* HP EliteBook 840 G4 */	183	"SYN3052", /* HP EliteBook 840 G4 */
184	"SYN3221", /* HP 15-ay000 */	184	"SYN3221", /* HP 15-ay000 */
		185	"SYN323d", /* HP Spectre X360 13-w013dx */
185	NULL	186	NULL
186	};	187	};
187		188

drivers/input/tablet/kbtab.c+4−2

 	if (intf->cur_altsetting->desc.bNumEndpoints < 1)
 		return -ENODEV;
+	endpoint = &intf->cur_altsetting->endpoint[0].desc;
+	if (!usb_endpoint_is_int_in(endpoint))
+		return -ENODEV;
 	kbtab = kzalloc(sizeof(struct kbtab), GFP_KERNEL);
 	input_dev = input_allocate_device();
 	if (!kbtab || !input_dev)
 	input_set_abs_params(input_dev, ABS_Y, 0, 0x1750, 4, 0);
 	input_set_abs_params(input_dev, ABS_PRESSURE, 0, 0xff, 0, 0);
-	endpoint = &intf->cur_altsetting->endpoint[0].desc;
 	usb_fill_int_urb(kbtab->irq, dev,
 			 usb_rcvintpipe(dev, endpoint->bEndpointAddress),
 			 kbtab->data, 8,

drivers/input/touchscreen/usbtouchscreen.c+2−0

@@ -1659,6 +1659,8 @@ static int usbtouch_probe(struct usb_interface *intf, · 1658 unmodified lines
1659	if (!usbtouch \|\| !input_dev)	1659	if (!usbtouch \|\| !input_dev)
1660	goto out_free;	1660	goto out_free;
1661		1661
		1662	mutex_init(&usbtouch->pm_mutex);
		1663
1662	type = &usbtouch_dev_info[id->driver_info];	1664	type = &usbtouch_dev_info[id->driver_info];
1663	usbtouch->type = type;	1665	usbtouch->type = type;
1664	if (!type->process_pkt)	1666	if (!type->process_pkt)

drivers/iommu/arm-smmu-v3.c+2−2

@@ -1186,8 +1186,8 @@ static void arm_smmu_write_strtab_ent(struct arm_smmu_master *master, u32 sid, · 1185 unmodified lines
1186	ste_live = true;	1186	ste_live = true;
1187	break;	1187	break;
1188	case STRTAB_STE_0_CFG_ABORT:	1188	case STRTAB_STE_0_CFG_ABORT:
1189	if (disable_bypass)	1189	BUG_ON(!disable_bypass);
1190	break;	1190	break;
1191	default:	1191	default:
1192	BUG(); /* STE corruption */	1192	BUG(); /* STE corruption */
1193	}	1193	}

drivers/iommu/dma-iommu.c+14−11

 {
 	struct iommu_domain *domain = iommu_get_dma_domain(dev);
 	struct iommu_dma_cookie *cookie = domain->iova_cookie;
-	size_t iova_off = 0;
+	struct iova_domain *iovad = &cookie->iovad;
+	size_t iova_off = iova_offset(iovad, phys);
 	dma_addr_t iova;
-	if (cookie->type == IOMMU_DMA_IOVA_COOKIE) {
+	size = iova_align(iovad, size + iova_off);
-		iova_off = iova_offset(&cookie->iovad, phys);
-		size = iova_align(&cookie->iovad, size + iova_off);
-	}
 	iova = iommu_dma_alloc_iova(domain, size, dma_get_mask(dev), dev);
 	if (!iova)
 	struct iova_domain *iovad = &cookie->iovad;
 	bool coherent = dev_is_dma_coherent(dev);
 	int ioprot = dma_info_to_prot(DMA_BIDIRECTIONAL, coherent, attrs);
-	pgprot_t prot = arch_dma_mmap_pgprot(dev, PAGE_KERNEL, attrs);
+	pgprot_t prot = dma_pgprot(dev, PAGE_KERNEL, attrs);
 	unsigned int count, min_size, alloc_sizes = domain->pgsize_bitmap;
 	struct page **pages;
 	struct sg_table sgt;
 		 * - and wouldn't make the resulting output segment too long
 		 */
 		if (cur_len && !s_iova_off && (dma_addr & seg_mask) &&
-		    (cur_len + s_length <= max_len)) {
+		    (max_len - cur_len >= s_length)) {
 			/* ...then concatenate it with the previous one */
 			cur_len += s_length;
 		} else {
 		return NULL;
 	if (IS_ENABLED(CONFIG_DMA_REMAP) && (!coherent || PageHighMem(page))) {
-		pgprot_t prot = arch_dma_mmap_pgprot(dev, PAGE_KERNEL, attrs);
+		pgprot_t prot = dma_pgprot(dev, PAGE_KERNEL, attrs);
 		cpu_addr = dma_common_contiguous_remap(page, alloc_size,
 				VM_USERMAP, prot, __builtin_return_address(0));
 	unsigned long pfn, off = vma->vm_pgoff;
 	int ret;
-	vma->vm_page_prot = arch_dma_mmap_pgprot(dev, vma->vm_page_prot, attrs);
+	vma->vm_page_prot = dma_pgprot(dev, vma->vm_page_prot, attrs);
 	if (dma_mmap_from_dev_coherent(dev, vma, cpu_addr, size, &ret))
 		return ret;
 	if (!msi_page)
 		return NULL;
-	iova = __iommu_dma_map(dev, msi_addr, size, prot);
+	iova = iommu_dma_alloc_iova(domain, size, dma_get_mask(dev), dev);
-	if (iova == DMA_MAPPING_ERROR)
+	if (!iova)
 		goto out_free_page;
+	if (iommu_map(domain, iova, msi_addr, size, prot))
+		goto out_free_iova;
 	INIT_LIST_HEAD(&msi_page->list);
 	msi_page->phys = msi_addr;
 	msi_page->iova = iova;
 	list_add(&msi_page->list, &cookie->msi_page_list);
 	return msi_page;
+out_free_iova:
+	iommu_dma_free_iova(cookie, iova, size);
 out_free_page:
 	kfree(msi_page);
 	return NULL;

drivers/iommu/intel-iommu-debugfs.c+1−1

@@ -235,7 +235,7 @@ static void ctx_tbl_walk(struct seq_file m, struct intel_iommu iommu, u16 bus) · 234 unmodified lines
235	tbl_wlk.ctx_entry = context;	235	tbl_wlk.ctx_entry = context;
236	m->private = &tbl_wlk;	236	m->private = &tbl_wlk;
237		237
238	if (pasid_supported(iommu) && is_pasid_enabled(context)) {	238	if (dmar_readq(iommu->reg + DMAR_RTADDR_REG) & DMA_RTADDR_SMT) {
239	pasid_dir_ptr = context->lo & VTD_PAGE_MASK;	239	pasid_dir_ptr = context->lo & VTD_PAGE_MASK;
240	pasid_dir_size = get_pasid_dir_size(context);	240	pasid_dir_size = get_pasid_dir_size(context);
241	pasid_dir_walk(m, pasid_dir_ptr, pasid_dir_size);	241	pasid_dir_walk(m, pasid_dir_ptr, pasid_dir_size);

drivers/iommu/intel-iommu.c+9−2

 				dmar_domain = to_dmar_domain(domain);
 				dmar_domain->flags |= DOMAIN_FLAG_LOSE_CHILDREN;
 			}
+			dmar_remove_one_dev_info(dev);
 			get_private_domain_for_dev(dev);
 		}
 	/* free the private domain */
 	if (domain->flags & DOMAIN_FLAG_LOSE_CHILDREN &&
-	    !(domain->flags & DOMAIN_FLAG_STATIC_IDENTITY))
+	    !(domain->flags & DOMAIN_FLAG_STATIC_IDENTITY) &&
+	    list_empty(&domain->devices))
 		domain_exit(info->domain);
 	free_devinfo_mem(info);
 	spin_lock_irqsave(&device_domain_lock, flags);
 	info = dev->archdata.iommu;
-	__dmar_remove_one_dev_info(info);
+	if (info)
+		__dmar_remove_one_dev_info(info);
 	spin_unlock_irqrestore(&device_domain_lock, flags);
 }
 		if (device_def_domain_type(dev) == IOMMU_DOMAIN_IDENTITY) {
 			ret = iommu_request_dm_for_dev(dev);
 			if (ret) {
+				dmar_remove_one_dev_info(dev);
 				dmar_domain->flags |= DOMAIN_FLAG_LOSE_CHILDREN;
 				domain_add_dev_info(si_domain, dev);
 				dev_info(dev,
 		if (device_def_domain_type(dev) == IOMMU_DOMAIN_DMA) {
 			ret = iommu_request_dma_domain_for_dev(dev);
 			if (ret) {
+				dmar_remove_one_dev_info(dev);
 				dmar_domain->flags |= DOMAIN_FLAG_LOSE_CHILDREN;
 				if (!get_private_domain_for_dev(dev)) {
 					dev_warn(dev,
 	if (!iommu)
 		return;
+	dmar_remove_one_dev_info(dev);
 	iommu_group_remove_device(dev);
 	iommu_device_unlink(&iommu->iommu, dev);

drivers/md/bcache/sysfs.c+12−8

 	"writethrough",
 	"writeback",
 	"writearound",
-	"none"
+	"none",
+	NULL
 };
 /* Default is 0 ("auto") */
 static const char * const bch_stop_on_failure_modes[] = {
 	"auto",
-	"always"
+	"always",
+	NULL
 };
 static const char * const cache_replacement_policies[] = {
 	"lru",
 	"fifo",
-	"random"
+	"random",
+	NULL
 };
 static const char * const error_actions[] = {
 	"unregister",
-	"panic"
+	"panic",
+	NULL
 };
 write_attribute(attach);
 	}
 	if (attr == &sysfs_cache_mode) {
-		v = sysfs_match_string(bch_cache_modes, buf);
+		v = __sysfs_match_string(bch_cache_modes, -1, buf);
 		if (v < 0)
 			return v;
 	}
 	if (attr == &sysfs_stop_when_cache_set_failed) {
-		v = sysfs_match_string(bch_stop_on_failure_modes, buf);
+		v = __sysfs_match_string(bch_stop_on_failure_modes, -1, buf);
 		if (v < 0)
 			return v;
 			    0, UINT_MAX);
 	if (attr == &sysfs_errors) {
-		v = sysfs_match_string(error_actions, buf);
+		v = __sysfs_match_string(error_actions, -1, buf);
 		if (v < 0)
 			return v;
 	}
 	if (attr == &sysfs_cache_replacement_policy) {
-		v = sysfs_match_string(cache_replacement_policies, buf);
+		v = __sysfs_match_string(cache_replacement_policies, -1, buf);
 		if (v < 0)
 			return v;

drivers/media/platform/omap/omap_vout_vrfb.c+1−2

@@ -253,8 +253,7 @@ int omap_vout_prepare_vrfb(struct omap_vout_device *vout, · 252 unmodified lines
253	*/	253	*/
254		254
255	pixsize = vout->bpp * vout->vrfb_bpp;	255	pixsize = vout->bpp * vout->vrfb_bpp;
256	dst_icg = ((MAX_PIXELS_PER_LINE * pixsize) -	256	dst_icg = MAX_PIXELS_PER_LINE * pixsize - vout->pix.width * vout->bpp;
257	(vout->pix.width * vout->bpp)) + 1;
258		257
259	xt->src_start = vout->buf_phy_addr[vb->i];	258	xt->src_start = vout->buf_phy_addr[vb->i];
260	xt->dst_start = vout->vrfb_context[vb->i].paddr[0];	259	xt->dst_start = vout->vrfb_context[vb->i].paddr[0];

drivers/media/platform/vivid/vivid-core.c+4−4

 	/* start creating the vb2 queues */
 	if (dev->has_vid_cap) {
+		snprintf(dev->vid_cap_dev.name, sizeof(dev->vid_cap_dev.name),
+			 "vivid-%03d-vid-cap", inst);
 		/* initialize vid_cap queue */
 		q = &dev->vb_vid_cap_q;
 		q->type = dev->multiplanar ? V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE :
 	}
 	if (dev->has_vid_out) {
+		snprintf(dev->vid_out_dev.name, sizeof(dev->vid_out_dev.name),
+			 "vivid-%03d-vid-out", inst);
 		/* initialize vid_out queue */
 		q = &dev->vb_vid_out_q;
 		q->type = dev->multiplanar ? V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE :
 	/* finally start creating the device nodes */
 	if (dev->has_vid_cap) {
 		vfd = &dev->vid_cap_dev;
-		snprintf(vfd->name, sizeof(vfd->name),
-			 "vivid-%03d-vid-cap", inst);
 		vfd->fops = &vivid_fops;
 		vfd->ioctl_ops = &vivid_ioctl_ops;
 		vfd->device_caps = dev->vid_cap_caps;
 	if (dev->has_vid_out) {
 		vfd = &dev->vid_out_dev;
-		snprintf(vfd->name, sizeof(vfd->name),
-			 "vivid-%03d-vid-out", inst);
 		vfd->vfl_dir = VFL_DIR_TX;
 		vfd->fops = &vivid_fops;
 		vfd->ioctl_ops = &vivid_ioctl_ops;

drivers/mfd/db8500-prcmu.c+2−0

 	switch (divsel) {
 	case PRCM_DSI_PLLOUT_SEL_PHI_4:
 		div *= 2;
+		/* Fall through */
 	case PRCM_DSI_PLLOUT_SEL_PHI_2:
 		div *= 2;
+		/* Fall through */
 	case PRCM_DSI_PLLOUT_SEL_PHI:
 		return pll_rate(PRCM_PLLDSI_FREQ, clock_rate(PRCMU_HDMICLK),
 			PLL_RAW) / div;

drivers/mfd/omap-usb-host.c+2−2

@@ -308,7 +308,7 @@ static int usbhs_runtime_resume(struct device *dev) · 307 unmodified lines
308	i, r);	308	i, r);
309	}	309	}
310	}	310	}
311	/* Fall through as HSIC mode needs utmi_clk */	311	/* Fall through - as HSIC mode needs utmi_clk */
312		312
313	case OMAP_EHCI_PORT_MODE_TLL:	313	case OMAP_EHCI_PORT_MODE_TLL:
314	if (!IS_ERR(omap->utmi_clk[i])) {	314	if (!IS_ERR(omap->utmi_clk[i])) {
@@ -344,7 +344,7 @@ static int usbhs_runtime_suspend(struct device *dev) · 29 unmodified lines
344		344
345	if (!IS_ERR(omap->hsic480m_clk[i]))	345	if (!IS_ERR(omap->hsic480m_clk[i]))
346	clk_disable_unprepare(omap->hsic480m_clk[i]);	346	clk_disable_unprepare(omap->hsic480m_clk[i]);
347	/* Fall through as utmi_clks were used in HSIC mode */	347	/* Fall through - as utmi_clks were used in HSIC mode */
348		348
349	case OMAP_EHCI_PORT_MODE_TLL:	349	case OMAP_EHCI_PORT_MODE_TLL:
350	if (!IS_ERR(omap->utmi_clk[i]))	350	if (!IS_ERR(omap->utmi_clk[i]))

drivers/misc/Kconfig+1−0

@@ -465,6 +465,7 @@ config PCI_ENDPOINT_TEST · 464 unmodified lines
465		465
466	config XILINX_SDFEC	466	config XILINX_SDFEC
467	tristate "Xilinx SDFEC 16"	467	tristate "Xilinx SDFEC 16"
		468	depends on HAS_IOMEM
468	help	469	help
469	This option enables support for the Xilinx SDFEC (Soft Decision	470	This option enables support for the Xilinx SDFEC (Soft Decision
470	Forward Error Correction) driver. This enables a char driver	471	Forward Error Correction) driver. This enables a char driver

drivers/misc/habanalabs/command_submission.c+1−1

@@ -683,7 +683,7 @@ int hl_cs_ioctl(struct hl_fpriv hpriv, void data) · 682 unmodified lines
683		683
684	rc = hl_poll_timeout_memory(hdev,	684	rc = hl_poll_timeout_memory(hdev,
685	&ctx->thread_ctx_switch_wait_token, tmp, (tmp == 1),	685	&ctx->thread_ctx_switch_wait_token, tmp, (tmp == 1),
686	100, jiffies_to_usecs(hdev->timeout_jiffies));	686	100, jiffies_to_usecs(hdev->timeout_jiffies), false);
687		687
688	if (rc == -ETIMEDOUT) {	688	if (rc == -ETIMEDOUT) {
689	dev_err(hdev->dev,	689	dev_err(hdev->dev,

drivers/misc/habanalabs/device.c+2−3

 	rc = hl_ctx_init(hdev, hdev->kernel_ctx, true);
 	if (rc) {
 		dev_err(hdev->dev, "failed to initialize kernel context\n");
-		goto free_ctx;
+		kfree(hdev->kernel_ctx);
+		goto mmu_fini;
 	}
 	rc = hl_cb_pool_init(hdev);
 	if (hl_ctx_put(hdev->kernel_ctx) != 1)
 		dev_err(hdev->dev,
 			"kernel ctx is still alive on initialization failure\n");
-free_ctx:
-	kfree(hdev->kernel_ctx);
 mmu_fini:
 	hl_mmu_fini(hdev);
 eq_fini:

drivers/misc/habanalabs/firmware_if.c+4−18

 {
 	const struct firmware *fw;
 	const u64 *fw_data;
-	size_t fw_size, i;
+	size_t fw_size;
 	int rc;
 	rc = request_firmware(&fw, fw_name, hdev->dev);
 	fw_data = (const u64 *) fw->data;
-	if ((fw->size % 8) != 0)
+	memcpy_toio(dst, fw_data, fw_size);
-		fw_size -= 8;
-	for (i = 0 ; i < fw_size ; i += 8, fw_data++, dst += 8) {
-		if (!(i & (0x80000 - 1))) {
-			dev_dbg(hdev->dev,
-				"copied so far %zu out of %zu for %s firmware",
-				i, fw_size, fw_name);
-			usleep_range(20, 100);
-		}
-		writeq(*fw_data, dst);
-	}
-	if ((fw->size % 8) != 0)
-		writel(*(const u32 *) fw_data, dst);
 out:
 	release_firmware(fw);
 	}
 	rc = hl_poll_timeout_memory(hdev, &pkt->fence, tmp,
-				(tmp == ARMCP_PACKET_FENCE_VAL), 1000, timeout);
+				(tmp == ARMCP_PACKET_FENCE_VAL), 1000,
+				timeout, true);
 	hl_hw_queue_inc_ci_kernel(hdev, hw_queue_id);

drivers/misc/habanalabs/goya/goya.c+50−27

 				GOYA_ASYNC_EVENT_ID_PI_UPDATE);
 }
-void goya_flush_pq_write(struct hl_device *hdev, u64 *pq, u64 exp_val)
+void goya_pqe_write(struct hl_device *hdev, __le64 *pqe, struct hl_bd *bd)
 {
-	/* Not needed in Goya */
+	/* The QMANs are on the SRAM so need to copy to IO space */
+	memcpy_toio((void __iomem *) pqe, bd, sizeof(struct hl_bd));
 }
 static void *goya_dma_alloc_coherent(struct hl_device *hdev, size_t size,
 	}
 	rc = hl_poll_timeout_memory(hdev, fence_ptr, tmp,
-				(tmp == GOYA_QMAN0_FENCE_VAL), 1000, timeout);
+				(tmp == GOYA_QMAN0_FENCE_VAL), 1000,
+				timeout, true);
 	hl_hw_queue_inc_ci_kernel(hdev, GOYA_QUEUE_ID_DMA_0);
 	}
 	rc = hl_poll_timeout_memory(hdev, fence_ptr, tmp, (tmp == fence_val),
-					1000, GOYA_TEST_QUEUE_WAIT_USEC);
+					1000, GOYA_TEST_QUEUE_WAIT_USEC, true);
 	hl_hw_queue_inc_ci_kernel(hdev, hw_queue_id);
 	int rc;
 	dev_dbg(hdev->dev, "DMA packet details:\n");
-	dev_dbg(hdev->dev, "source == 0x%llx\n", user_dma_pkt->src_addr);
+	dev_dbg(hdev->dev, "source == 0x%llx\n",
-	dev_dbg(hdev->dev, "destination == 0x%llx\n", user_dma_pkt->dst_addr);
+		le64_to_cpu(user_dma_pkt->src_addr));
-	dev_dbg(hdev->dev, "size == %u\n", user_dma_pkt->tsize);
+	dev_dbg(hdev->dev, "destination == 0x%llx\n",
+		le64_to_cpu(user_dma_pkt->dst_addr));
+	dev_dbg(hdev->dev, "size == %u\n", le32_to_cpu(user_dma_pkt->tsize));
 	ctl = le32_to_cpu(user_dma_pkt->ctl);
 	user_dir = (ctl & GOYA_PKT_LIN_DMA_CTL_DMA_DIR_MASK) >>
 				struct packet_lin_dma *user_dma_pkt)
 {
 	dev_dbg(hdev->dev, "DMA packet details:\n");
-	dev_dbg(hdev->dev, "source == 0x%llx\n", user_dma_pkt->src_addr);
+	dev_dbg(hdev->dev, "source == 0x%llx\n",
-	dev_dbg(hdev->dev, "destination == 0x%llx\n", user_dma_pkt->dst_addr);
+		le64_to_cpu(user_dma_pkt->src_addr));
-	dev_dbg(hdev->dev, "size == %u\n", user_dma_pkt->tsize);
+	dev_dbg(hdev->dev, "destination == 0x%llx\n",
+		le64_to_cpu(user_dma_pkt->dst_addr));
+	dev_dbg(hdev->dev, "size == %u\n", le32_to_cpu(user_dma_pkt->tsize));
 	/*
 	 * WA for HW-23.
 	dev_dbg(hdev->dev, "WREG32 packet details:\n");
 	dev_dbg(hdev->dev, "reg_offset == 0x%x\n", reg_offset);
-	dev_dbg(hdev->dev, "value      == 0x%x\n", wreg_pkt->value);
+	dev_dbg(hdev->dev, "value      == 0x%x\n",
+		le32_to_cpu(wreg_pkt->value));
 	if (reg_offset != (mmDMA_CH_0_WR_COMP_ADDR_LO & 0x1FFF)) {
 		dev_err(hdev->dev, "WREG32 packet with illegal address 0x%x\n",
 	while (cb_parsed_length < parser->user_cb_size) {
 		enum packet_id pkt_id;
 		u16 pkt_size;
-		void *user_pkt;
+		struct goya_packet *user_pkt;
-		user_pkt = (void *) (uintptr_t)
+		user_pkt = (struct goya_packet *) (uintptr_t)
 			(parser->user_cb->kernel_address + cb_parsed_length);
-		pkt_id = (enum packet_id) (((*(u64 *) user_pkt) &
+		pkt_id = (enum packet_id) (
+				(le64_to_cpu(user_pkt->header) &
 				PACKET_HEADER_PACKET_ID_MASK) >>
 					PACKET_HEADER_PACKET_ID_SHIFT);
 			 * need to validate here as well because patch_cb() is
 			 * not called in MMU path while this function is called
 			 */
-			rc = goya_validate_wreg32(hdev, parser, user_pkt);
+			rc = goya_validate_wreg32(hdev,
+				parser, (struct packet_wreg32 *) user_pkt);
 			break;
 		case PACKET_WREG_BULK:
 		case PACKET_LIN_DMA:
 			if (is_mmu)
 				rc = goya_validate_dma_pkt_mmu(hdev, parser,
-						user_pkt);
+					(struct packet_lin_dma *) user_pkt);
 			else
 				rc = goya_validate_dma_pkt_no_mmu(hdev, parser,
-						user_pkt);
+					(struct packet_lin_dma *) user_pkt);
 			break;
 		case PACKET_MSG_LONG:
 		enum packet_id pkt_id;
 		u16 pkt_size;
 		u32 new_pkt_size = 0;
-		void *user_pkt, *kernel_pkt;
+		struct goya_packet *user_pkt, *kernel_pkt;
-		user_pkt = (void *) (uintptr_t)
+		user_pkt = (struct goya_packet *) (uintptr_t)
 			(parser->user_cb->kernel_address + cb_parsed_length);
-		kernel_pkt = (void *) (uintptr_t)
+		kernel_pkt = (struct goya_packet *) (uintptr_t)
 			(parser->patched_cb->kernel_address +
 					cb_patched_cur_length);
-		pkt_id = (enum packet_id) (((*(u64 *) user_pkt) &
+		pkt_id = (enum packet_id) (
+				(le64_to_cpu(user_pkt->header) &
 				PACKET_HEADER_PACKET_ID_MASK) >>
 					PACKET_HEADER_PACKET_ID_SHIFT);
 		switch (pkt_id) {
 		case PACKET_LIN_DMA:
-			rc = goya_patch_dma_packet(hdev, parser, user_pkt,
+			rc = goya_patch_dma_packet(hdev, parser,
-						kernel_pkt, &new_pkt_size);
+					(struct packet_lin_dma *) user_pkt,
+					(struct packet_lin_dma *) kernel_pkt,
+					&new_pkt_size);
 			cb_patched_cur_length += new_pkt_size;
 			break;
 		case PACKET_WREG_32:
 			memcpy(kernel_pkt, user_pkt, pkt_size);
 			cb_patched_cur_length += pkt_size;
-			rc = goya_validate_wreg32(hdev, parser, kernel_pkt);
+			rc = goya_validate_wreg32(hdev, parser,
+					(struct packet_wreg32 *) kernel_pkt);
 			break;
 		case PACKET_WREG_BULK:
 	size_t total_pkt_size;
 	long result;
 	int rc;
+	int irq_num_entries, irq_arr_index;
+	__le32 *goya_irq_arr;
 	total_pkt_size = sizeof(struct armcp_unmask_irq_arr_packet) +
 			irq_arr_size;
 	if (!pkt)
 		return -ENOMEM;
-	pkt->length = cpu_to_le32(irq_arr_size / sizeof(irq_arr[0]));
+	irq_num_entries = irq_arr_size / sizeof(irq_arr[0]);
-	memcpy(&pkt->irqs, irq_arr, irq_arr_size);
+	pkt->length = cpu_to_le32(irq_num_entries);
+	/* We must perform any necessary endianness conversation on the irq
+	 * array being passed to the goya hardware
+	 */
+	for (irq_arr_index = 0, goya_irq_arr = (__le32 *) &pkt->irqs;
+			irq_arr_index < irq_num_entries ; irq_arr_index++)
+		goya_irq_arr[irq_arr_index] =
+				cpu_to_le32(irq_arr[irq_arr_index]);
 	pkt->armcp_pkt.ctl = cpu_to_le32(ARMCP_PACKET_UNMASK_RAZWI_IRQ_ARRAY <<
 						ARMCP_PKT_CTL_OPCODE_SHIFT);
 	.resume = goya_resume,
 	.cb_mmap = goya_cb_mmap,
 	.ring_doorbell = goya_ring_doorbell,
-	.flush_pq_write = goya_flush_pq_write,
+	.pqe_write = goya_pqe_write,
 	.asic_dma_alloc_coherent = goya_dma_alloc_coherent,
 	.asic_dma_free_coherent = goya_dma_free_coherent,
 	.get_int_queue_base = goya_get_int_queue_base,

drivers/misc/habanalabs/goya/goyaP.h+1−1

@@ -177,7 +177,7 @@ int goya_late_init(struct hl_device *hdev); · 176 unmodified lines
177	void goya_late_fini(struct hl_device *hdev);	177	void goya_late_fini(struct hl_device *hdev);
178		178
179	void goya_ring_doorbell(struct hl_device *hdev, u32 hw_queue_id, u32 pi);	179	void goya_ring_doorbell(struct hl_device *hdev, u32 hw_queue_id, u32 pi);
180	void goya_flush_pq_write(struct hl_device hdev, u64 pq, u64 exp_val);	180	void goya_pqe_write(struct hl_device hdev, __le64 pqe, struct hl_bd *bd);
181	void goya_update_eq_ci(struct hl_device *hdev, u32 val);	181	void goya_update_eq_ci(struct hl_device *hdev, u32 val);
182	void goya_restore_phase_topology(struct hl_device *hdev);	182	void goya_restore_phase_topology(struct hl_device *hdev);
183	int goya_context_switch(struct hl_device *hdev, u32 asid);	183	int goya_context_switch(struct hl_device *hdev, u32 asid);

drivers/misc/habanalabs/habanalabs.h+21−4

  * @resume: handles IP specific H/W or SW changes for resume.
  * @cb_mmap: maps a CB.
  * @ring_doorbell: increment PI on a given QMAN.
- * @flush_pq_write: flush PQ entry write if necessary, WARN if flushing failed.
+ * @pqe_write: Write the PQ entry to the PQ. This is ASIC-specific
+ *             function because the PQs are located in different memory areas
+ *             per ASIC (SRAM, DRAM, Host memory) and therefore, the method of
+ *             writing the PQE must match the destination memory area
+ *             properties.
  * @asic_dma_alloc_coherent: Allocate coherent DMA memory by calling
  *                           dma_alloc_coherent(). This is ASIC function because
  *                           its implementation is not trivial when the driver
 	int (*cb_mmap)(struct hl_device *hdev, struct vm_area_struct *vma,
 			u64 kaddress, phys_addr_t paddress, u32 size);
 	void (*ring_doorbell)(struct hl_device *hdev, u32 hw_queue_id, u32 pi);
-	void (*flush_pq_write)(struct hl_device *hdev, u64 *pq, u64 exp_val);
+	void (*pqe_write)(struct hl_device *hdev, __le64 *pqe,
+			struct hl_bd *bd);
 	void* (*asic_dma_alloc_coherent)(struct hl_device *hdev, size_t size,
 					dma_addr_t *dma_handle, gfp_t flag);
 	void (*asic_dma_free_coherent)(struct hl_device *hdev, size_t size,
 /*
  * address in this macro points always to a memory location in the
  * host's (server's) memory. That location is updated asynchronously
- * either by the direct access of the device or by another core
+ * either by the direct access of the device or by another core.
+ *
+ * To work both in LE and BE architectures, we need to distinguish between the
+ * two states (device or another core updates the memory location). Therefore,
+ * if mem_written_by_device is true, the host memory being polled will be
+ * updated directly by the device. If false, the host memory being polled will
+ * be updated by host CPU. Required so host knows whether or not the memory
+ * might need to be byte-swapped before returning value to caller.
  */
-#define hl_poll_timeout_memory(hdev, addr, val, cond, sleep_us, timeout_us) \
+#define hl_poll_timeout_memory(hdev, addr, val, cond, sleep_us, timeout_us, \
+				mem_written_by_device) \
 ({ \
 	ktime_t __timeout; \
 	/* timeout should be longer when working with simulator */ \
 		/* Verify we read updates done by other cores or by device */ \
 		mb(); \
 		(val) = *((u32 *) (uintptr_t) (addr)); \
+		if (mem_written_by_device) \
+			(val) = le32_to_cpu(val); \
 		if (cond) \
 			break; \
 		if (timeout_us && ktime_compare(ktime_get(), __timeout) > 0) { \
 			(val) = *((u32 *) (uintptr_t) (addr)); \
+			if (mem_written_by_device) \
+				(val) = le32_to_cpu(val); \
 			break; \
 		} \
 		if (sleep_us) \

drivers/misc/habanalabs/hw_queue.c+5−9

 	struct hl_device *hdev = job->cs->ctx->hdev;
 	struct hl_hw_queue *q = &hdev->kernel_queues[job->hw_queue_id];
 	struct hl_bd bd;
-	u64 *pi, *pbd = (u64 *) &bd;
+	__le64 *pi;
 	bd.ctl = 0;
-	bd.len = __cpu_to_le32(job->job_cb_size);
+	bd.len = cpu_to_le32(job->job_cb_size);
-	bd.ptr = __cpu_to_le64((u64) (uintptr_t) job->user_cb);
+	bd.ptr = cpu_to_le64((u64) (uintptr_t) job->user_cb);
-	pi = (u64 *) (uintptr_t) (q->kernel_address +
+	pi = (__le64 *) (uintptr_t) (q->kernel_address +
 		((q->pi & (q->int_queue_len - 1)) * sizeof(bd)));
-	pi[0] = pbd[0];
-	pi[1] = pbd[1];
 	q->pi++;
 	q->pi &= ((q->int_queue_len << 1) - 1);
-	/* Flush PQ entry write. Relevant only for specific ASICs */
+	hdev->asic_funcs->pqe_write(hdev, pi, &bd);
-	hdev->asic_funcs->flush_pq_write(hdev, pi, pbd[0]);
 	hdev->asic_funcs->ring_doorbell(hdev, q->hw_queue_id, q->pi);
 }

drivers/misc/habanalabs/include/goya/goya_packets.h+13−0

@@ -52,6 +52,19 @@ enum goya_dma_direction { · 51 unmodified lines
52	#define GOYA_PKT_CTL_MB_SHIFT 31	52	#define GOYA_PKT_CTL_MB_SHIFT 31
53	#define GOYA_PKT_CTL_MB_MASK 0x80000000	53	#define GOYA_PKT_CTL_MB_MASK 0x80000000
54		54
		55	/* All packets have, at least, an 8-byte header, which contains
		56	* the packet type. The kernel driver uses the packet header for packet
		57	* validation and to perform any necessary required preparation before
		58	* sending them off to the hardware.
		59	*/
		60	struct goya_packet {
		61	__le64 header;
		62	/* The rest of the packet data follows. Use the corresponding
		63	* packet_XXX struct to deference the data, based on packet type
		64	*/
		65	u8 contents[0];
		66	};
		67
55	struct packet_nop {	68	struct packet_nop {
56	__le32 reserved;	69	__le32 reserved;
57	__le32 ctl;	70	__le32 ctl;

drivers/misc/habanalabs/irq.c+13−14

 	struct hl_cs_job *job;
 	bool shadow_index_valid;
 	u16 shadow_index;
-	u32 *cq_entry;
+	struct hl_cq_entry *cq_entry, *cq_base;
-	u32 *cq_base;
 	if (hdev->disabled) {
 		dev_dbg(hdev->dev,
 		return IRQ_HANDLED;
 	}
-	cq_base = (u32 *) (uintptr_t) cq->kernel_address;
+	cq_base = (struct hl_cq_entry *) (uintptr_t) cq->kernel_address;
 	while (1) {
-		bool entry_ready = ((cq_base[cq->ci] & CQ_ENTRY_READY_MASK)
+		bool entry_ready = ((le32_to_cpu(cq_base[cq->ci].data) &
+					CQ_ENTRY_READY_MASK)
 						>> CQ_ENTRY_READY_SHIFT);
 		if (!entry_ready)
 			break;
-		cq_entry = (u32 *) &cq_base[cq->ci];
+		cq_entry = (struct hl_cq_entry *) &cq_base[cq->ci];
-		/*
+		/* Make sure we read CQ entry contents after we've
-		 * Make sure we read CQ entry contents after we've
 		 * checked the ownership bit.
 		 */
 		dma_rmb();
-		shadow_index_valid =
+		shadow_index_valid = ((le32_to_cpu(cq_entry->data) &
-			((*cq_entry & CQ_ENTRY_SHADOW_INDEX_VALID_MASK)
+					CQ_ENTRY_SHADOW_INDEX_VALID_MASK)
 					>> CQ_ENTRY_SHADOW_INDEX_VALID_SHIFT);
-		shadow_index = (u16)
+		shadow_index = (u16) ((le32_to_cpu(cq_entry->data) &
-			((*cq_entry & CQ_ENTRY_SHADOW_INDEX_MASK)
+					CQ_ENTRY_SHADOW_INDEX_MASK)
 					>> CQ_ENTRY_SHADOW_INDEX_SHIFT);
 		queue = &hdev->kernel_queues[cq->hw_queue_id];
 			queue_work(hdev->cq_wq, &job->finish_work);
 		}
-		/*
+		/* Update ci of the context's queue. There is no
-		 * Update ci of the context's queue. There is no
 		 * need to protect it with spinlock because this update is
 		 * done only inside IRQ and there is a different IRQ per
 		 * queue
 		queue->ci = hl_queue_inc_ptr(queue->ci);
 		/* Clear CQ entry ready bit */
-		cq_base[cq->ci] &= ~CQ_ENTRY_READY_MASK;
+		cq_entry->data = cpu_to_le32(le32_to_cpu(cq_entry->data) &
+						~CQ_ENTRY_READY_MASK);
 		cq->ci = hl_cq_inc_ptr(cq->ci);

drivers/misc/habanalabs/memory.c+2−0

 			dev_dbg(hdev->dev,
 				"page list 0x%p of asid %d is still alive\n",
 				phys_pg_list, ctx->asid);
+			atomic64_sub(phys_pg_list->total_size,
+					&hdev->dram_used_mem);
 			free_phys_pg_pack(hdev, phys_pg_list);
 			idr_remove(&vm->phys_pg_pack_handles, i);
 		}

drivers/mmc/host/cavium.c+3−1

 {
 	data->bytes_xfered = data->blocks * data->blksz;
 	data->error = 0;
+	dma_unmap_sg(host->dev, data->sg, data->sg_len, get_dma_dir(data));
 	return 1;
 }
 		mmc->max_segs = 1;
 	/* DMA size field can address up to 8 MB */
-	mmc->max_seg_size = 8 * 1024 * 1024;
+	mmc->max_seg_size = min_t(unsigned int, 8 * 1024 * 1024,
+				  dma_get_max_seg_size(host->dev));
 	mmc->max_req_size = mmc->max_seg_size;
 	/* External DMA is in 512 byte blocks */
 	mmc->max_blk_size = 512;

drivers/mmc/host/sdhci-acpi.c+1−1

@@ -883,7 +883,7 @@ static int sdhci_acpi_runtime_resume(struct device *dev) · 882 unmodified lines
883		883
884	sdhci_acpi_byt_setting(&c->pdev->dev);	884	sdhci_acpi_byt_setting(&c->pdev->dev);
885		885
886	return sdhci_runtime_resume_host(c->host);	886	return sdhci_runtime_resume_host(c->host, 0);
887	}	887	}
888		888
889	#endif	889	#endif

drivers/mmc/host/sdhci-esdhc-imx.c+1−1

@@ -1705,7 +1705,7 @@ static int sdhci_esdhc_runtime_resume(struct device *dev) · 1704 unmodified lines
1705	esdhc_pltfm_set_clock(host, imx_data->actual_clock);	1705	esdhc_pltfm_set_clock(host, imx_data->actual_clock);
1706	}	1706	}
1707		1707
1708	err = sdhci_runtime_resume_host(host);	1708	err = sdhci_runtime_resume_host(host, 0);
1709	if (err)	1709	if (err)
1710	goto disable_ipg_clk;	1710	goto disable_ipg_clk;
1711		1711

drivers/mmc/host/sdhci-of-at91.c+1−1

@@ -289,7 +289,7 @@ static int sdhci_at91_runtime_resume(struct device *dev) · 288 unmodified lines
289	}	289	}
290		290
291	out:	291	out:
292	return sdhci_runtime_resume_host(host);	292	return sdhci_runtime_resume_host(host, 0);
293	}	293	}
294	#endif /* CONFIG_PM */	294	#endif /* CONFIG_PM */
295		295

drivers/mmc/host/sdhci-pci-core.c+2−2

@@ -167,7 +167,7 @@ static int sdhci_pci_runtime_suspend_host(struct sdhci_pci_chip *chip) · 166 unmodified lines
167		167
168	err_pci_runtime_suspend:	168	err_pci_runtime_suspend:
169	while (--i >= 0)	169	while (--i >= 0)
170	sdhci_runtime_resume_host(chip->slots[i]->host);	170	sdhci_runtime_resume_host(chip->slots[i]->host, 0);
171	return ret;	171	return ret;
172	}	172	}
173		173
@@ -181,7 +181,7 @@ static int sdhci_pci_runtime_resume_host(struct sdhci_pci_chip *chip) · 7 unmodified lines
181	if (!slot)	181	if (!slot)
182	continue;	182	continue;
183		183
184	ret = sdhci_runtime_resume_host(slot->host);	184	ret = sdhci_runtime_resume_host(slot->host, 0);
185	if (ret)	185	if (ret)
186	return ret;	186	return ret;
187	}	187	}

drivers/mmc/host/sdhci-pxav3.c+1−1

@@ -554,7 +554,7 @@ static int sdhci_pxav3_runtime_resume(struct device *dev) · 553 unmodified lines
554	if (!IS_ERR(pxa->clk_core))	554	if (!IS_ERR(pxa->clk_core))
555	clk_prepare_enable(pxa->clk_core);	555	clk_prepare_enable(pxa->clk_core);
556		556
557	return sdhci_runtime_resume_host(host);	557	return sdhci_runtime_resume_host(host, 0);
558	}	558	}
559	#endif	559	#endif
560		560

drivers/mmc/host/sdhci-s3c.c+1−1

@@ -745,7 +745,7 @@ static int sdhci_s3c_runtime_resume(struct device *dev) · 744 unmodified lines
745	clk_prepare_enable(busclk);	745	clk_prepare_enable(busclk);
746	if (ourhost->cur_clk >= 0)	746	if (ourhost->cur_clk >= 0)
747	clk_prepare_enable(ourhost->clk_bus[ourhost->cur_clk]);	747	clk_prepare_enable(ourhost->clk_bus[ourhost->cur_clk]);
748	ret = sdhci_runtime_resume_host(host);	748	ret = sdhci_runtime_resume_host(host, 0);
749	return ret;	749	return ret;
750	}	750	}
751	#endif	751	#endif

drivers/mmc/host/sdhci-sprd.c+1−1

@@ -696,7 +696,7 @@ static int sdhci_sprd_runtime_resume(struct device *dev) · 695 unmodified lines
696	if (ret)	696	if (ret)
697	goto clk_disable;	697	goto clk_disable;
698		698
699	sdhci_runtime_resume_host(host);	699	sdhci_runtime_resume_host(host, 1);
700	return 0;	700	return 0;
701		701
702	clk_disable:	702	clk_disable:

drivers/mmc/host/sdhci-xenon.c+1−1

@@ -638,7 +638,7 @@ static int xenon_runtime_resume(struct device *dev) · 637 unmodified lines
638	priv->restore_needed = false;	638	priv->restore_needed = false;
639	}	639	}
640		640
641	ret = sdhci_runtime_resume_host(host);	641	ret = sdhci_runtime_resume_host(host, 0);
642	if (ret)	642	if (ret)
643	goto out;	643	goto out;
644	return 0;	644	return 0;

drivers/mmc/host/sdhci.c+2−2

@@ -3320,7 +3320,7 @@ int sdhci_runtime_suspend_host(struct sdhci_host *host) · 3319 unmodified lines
3320	}	3320	}
3321	EXPORT_SYMBOL_GPL(sdhci_runtime_suspend_host);	3321	EXPORT_SYMBOL_GPL(sdhci_runtime_suspend_host);
3322		3322
3323	int sdhci_runtime_resume_host(struct sdhci_host *host)	3323	int sdhci_runtime_resume_host(struct sdhci_host *host, int soft_reset)
3324	{	3324	{
3325	struct mmc_host *mmc = host->mmc;	3325	struct mmc_host *mmc = host->mmc;
3326	unsigned long flags;	3326	unsigned long flags;
@@ -3331,7 +3331,7 @@ int sdhci_runtime_resume_host(struct sdhci_host *host) · 4 unmodified lines
3331	host->ops->enable_dma(host);	3331	host->ops->enable_dma(host);
3332	}	3332	}
3333		3333
3334	sdhci_init(host, 0);	3334	sdhci_init(host, soft_reset);
3335		3335
3336	if (mmc->ios.power_mode != MMC_POWER_UNDEFINED &&	3336	if (mmc->ios.power_mode != MMC_POWER_UNDEFINED &&
3337	mmc->ios.power_mode != MMC_POWER_OFF) {	3337	mmc->ios.power_mode != MMC_POWER_OFF) {

drivers/mmc/host/sdhci.h+1−1

@@ -781,7 +781,7 @@ void sdhci_adma_write_desc(struct sdhci_host host, void *desc, · 780 unmodified lines
781	int sdhci_suspend_host(struct sdhci_host *host);	781	int sdhci_suspend_host(struct sdhci_host *host);
782	int sdhci_resume_host(struct sdhci_host *host);	782	int sdhci_resume_host(struct sdhci_host *host);
783	int sdhci_runtime_suspend_host(struct sdhci_host *host);	783	int sdhci_runtime_suspend_host(struct sdhci_host *host);
784	int sdhci_runtime_resume_host(struct sdhci_host *host);	784	int sdhci_runtime_resume_host(struct sdhci_host *host, int soft_reset);
785	#endif	785	#endif
786		786
787	void sdhci_cqe_enable(struct mmc_host *mmc);	787	void sdhci_cqe_enable(struct mmc_host *mmc);

drivers/mtd/spi-nor/spi-nor.c+3−2

 		default:
 			/* Kept only for backward compatibility purpose. */
 			params->quad_enable = spansion_quad_enable;
-			if (nor->clear_sr_bp)
-				nor->clear_sr_bp = spi_nor_spansion_clear_sr_bp;
 			break;
 		}
 	int err;
 	if (nor->clear_sr_bp) {
+		if (nor->quad_enable == spansion_quad_enable)
+			nor->clear_sr_bp = spi_nor_spansion_clear_sr_bp;
 		err = nor->clear_sr_bp(nor);
 		if (err) {
 			dev_err(nor->dev,

drivers/net/bonding/bond_main.c+2−0

 done:
 	bond_dev->vlan_features = vlan_features;
 	bond_dev->hw_enc_features = enc_features | NETIF_F_GSO_ENCAP_ALL |
+				    NETIF_F_HW_VLAN_CTAG_TX |
+				    NETIF_F_HW_VLAN_STAG_TX |
 				    NETIF_F_GSO_UDP_L4;
 	bond_dev->mpls_features = mpls_features;
 	bond_dev->gso_max_segs = gso_max_segs;

drivers/net/dsa/sja1105/sja1105_main.c+0−4

 {
 	struct sja1105_private *priv = ds->priv;
 	struct device *dev = ds->dev;
-	u16 rx_vid, tx_vid;
 	int i;
-	rx_vid = dsa_8021q_rx_vid(ds, port);
-	tx_vid = dsa_8021q_tx_vid(ds, port);
 	for (i = 0; i < SJA1105_MAX_L2_LOOKUP_COUNT; i++) {
 		struct sja1105_l2_lookup_entry l2_lookup = {0};
 		u8 macaddr[ETH_ALEN];

drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c+4−3

 	/* if VF indicate to PF this function is going down (PF will delete sp
 	 * elements and clear initializations
 	 */
-	if (IS_VF(bp))
+	if (IS_VF(bp)) {
+		bnx2x_clear_vlan_info(bp);
 		bnx2x_vfpf_close_vf(bp);
-	else if (unload_mode != UNLOAD_RECOVERY)
+	} else if (unload_mode != UNLOAD_RECOVERY) {
 		/* if this is a normal/close unload need to clean up chip*/
 		bnx2x_chip_cleanup(bp, unload_mode, keep_link);
-	else {
+	} else {
 		/* Send the UNLOAD_REQUEST to the MCP */
 		bnx2x_send_unload_req(bp, unload_mode);

drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h+2−0

@@ -425,6 +425,8 @@ void bnx2x_set_reset_global(struct bnx2x *bp); · 424 unmodified lines
425	void bnx2x_disable_close_the_gate(struct bnx2x *bp);	425	void bnx2x_disable_close_the_gate(struct bnx2x *bp);
426	int bnx2x_init_hw_func_cnic(struct bnx2x *bp);	426	int bnx2x_init_hw_func_cnic(struct bnx2x *bp);
427		427
		428	void bnx2x_clear_vlan_info(struct bnx2x *bp);
		429
428	/**	430	/**
429	* bnx2x_sp_event - handle ramrods completion.	431	* bnx2x_sp_event - handle ramrods completion.
430	*	432	*

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c+12−5

 	return rc;
 }
+void bnx2x_clear_vlan_info(struct bnx2x *bp)
+{
+	struct bnx2x_vlan_entry *vlan;
+	/* Mark that hw forgot all entries */
+	list_for_each_entry(vlan, &bp->vlan_reg, link)
+		vlan->hw = false;
+	bp->vlan_cnt = 0;
+}
 static int bnx2x_del_all_vlans(struct bnx2x *bp)
 {
 	struct bnx2x_vlan_mac_obj *vlan_obj = &bp->sp_objs[0].vlan_obj;
 	unsigned long ramrod_flags = 0, vlan_flags = 0;
-	struct bnx2x_vlan_entry *vlan;
 	int rc;
 	__set_bit(RAMROD_COMP_WAIT, &ramrod_flags);
 	if (rc)
 		return rc;
-	/* Mark that hw forgot all entries */
+	bnx2x_clear_vlan_info(bp);
-	list_for_each_entry(vlan, &bp->vlan_reg, link)
-		vlan->hw = false;
-	bp->vlan_cnt = 0;
 	return 0;
 }

drivers/net/ethernet/broadcom/bnxt/bnxt.c+25−11

 	if (bnapi->events & BNXT_RX_EVENT) {
 		struct bnxt_rx_ring_info *rxr = bnapi->rx_ring;
-		bnxt_db_write(bp, &rxr->rx_db, rxr->rx_prod);
 		if (bnapi->events & BNXT_AGG_EVENT)
 			bnxt_db_write(bp, &rxr->rx_agg_db, rxr->rx_agg_prod);
+		bnxt_db_write(bp, &rxr->rx_db, rxr->rx_prod);
 	}
 	bnapi->events = 0;
 }
 static int bnxt_hwrm_ring_alloc(struct bnxt *bp)
 {
+	bool agg_rings = !!(bp->flags & BNXT_FLAG_AGG_RINGS);
 	int i, rc = 0;
 	u32 type;
 		if (rc)
 			goto err_out;
 		bnxt_set_db(bp, &rxr->rx_db, type, map_idx, ring->fw_ring_id);
-		bnxt_db_write(bp, &rxr->rx_db, rxr->rx_prod);
+		/* If we have agg rings, post agg buffers first. */
+		if (!agg_rings)
+			bnxt_db_write(bp, &rxr->rx_db, rxr->rx_prod);
 		bp->grp_info[map_idx].rx_fw_ring_id = ring->fw_ring_id;
 		if (bp->flags & BNXT_FLAG_CHIP_P5) {
 			struct bnxt_cp_ring_info *cpr = &bnapi->cp_ring;
 		}
 	}
-	if (bp->flags & BNXT_FLAG_AGG_RINGS) {
+	if (agg_rings) {
 		type = HWRM_RING_ALLOC_AGG;
 		for (i = 0; i < bp->rx_nr_rings; i++) {
 			struct bnxt_rx_ring_info *rxr = &bp->rx_ring[i];
 			bnxt_set_db(bp, &rxr->rx_agg_db, type, map_idx,
 				    ring->fw_ring_id);
 			bnxt_db_write(bp, &rxr->rx_agg_db, rxr->rx_agg_prod);
+			bnxt_db_write(bp, &rxr->rx_db, rxr->rx_prod);
 			bp->grp_info[grp_idx].agg_fw_ring_id = ring->fw_ring_id;
 		}
 	}
 		bnxt_hwrm_vnic_set_rss(bp, i, false);
 }
-static void bnxt_hwrm_resource_free(struct bnxt *bp, bool close_path,
+static void bnxt_clear_vnic(struct bnxt *bp)
-				    bool irq_re_init)
 {
-	if (bp->vnic_info) {
+	if (!bp->vnic_info)
-		bnxt_hwrm_clear_vnic_filter(bp);
+		return;
+	bnxt_hwrm_clear_vnic_filter(bp);
+	if (!(bp->flags & BNXT_FLAG_CHIP_P5)) {
 		/* clear all RSS setting before free vnic ctx */
 		bnxt_hwrm_clear_vnic_rss(bp);
 		bnxt_hwrm_vnic_ctx_free(bp);
-		/* before free the vnic, undo the vnic tpa settings */
-		if (bp->flags & BNXT_FLAG_TPA)
-			bnxt_set_tpa(bp, false);
-		bnxt_hwrm_vnic_free(bp);
 	}
+	/* before free the vnic, undo the vnic tpa settings */
+	if (bp->flags & BNXT_FLAG_TPA)
+		bnxt_set_tpa(bp, false);
+	bnxt_hwrm_vnic_free(bp);
+	if (bp->flags & BNXT_FLAG_CHIP_P5)
+		bnxt_hwrm_vnic_ctx_free(bp);
+}
+static void bnxt_hwrm_resource_free(struct bnxt *bp, bool close_path,
+				    bool irq_re_init)
+{
+	bnxt_clear_vnic(bp);
 	bnxt_hwrm_ring_free(bp, close_path);
 	bnxt_hwrm_ring_grp_free(bp);
 	if (irq_re_init) {

drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c+6−3

@@ -98,10 +98,13 @@ static int bnxt_hwrm_nvm_req(struct bnxt bp, u32 param_id, void msg, · 97 unmodified lines
98	if (idx)	98	if (idx)
99	req->dimensions = cpu_to_le16(1);	99	req->dimensions = cpu_to_le16(1);
100		100
101	if (req->req_type == cpu_to_le16(HWRM_NVM_SET_VARIABLE))	101	if (req->req_type == cpu_to_le16(HWRM_NVM_SET_VARIABLE)) {
102	memcpy(data_addr, buf, bytesize);	102	memcpy(data_addr, buf, bytesize);
103		103	rc = hwrm_send_message(bp, msg, msg_len, HWRM_CMD_TIMEOUT);
104	rc = hwrm_send_message(bp, msg, msg_len, HWRM_CMD_TIMEOUT);	104	} else {
		105	rc = hwrm_send_message_silent(bp, msg, msg_len,
		106	HWRM_CMD_TIMEOUT);
		107	}
105	if (!rc && req->req_type == cpu_to_le16(HWRM_NVM_GET_VARIABLE))	108	if (!rc && req->req_type == cpu_to_le16(HWRM_NVM_GET_VARIABLE))
106	memcpy(buf, data_addr, bytesize);	109	memcpy(buf, data_addr, bytesize);
107		110

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c+5−7

 	mutex_lock(&bp->hwrm_cmd_lock);
 	hwrm_err = _hwrm_send_message(bp, &install, sizeof(install),
 				      INSTALL_PACKAGE_TIMEOUT);
-	if (hwrm_err)
+	if (hwrm_err) {
-		goto flash_pkg_exit;
-	if (resp->error_code) {
 		u8 error_code = ((struct hwrm_err_output *)resp)->cmd_err;
-		if (error_code == NVM_INSTALL_UPDATE_CMD_ERR_CODE_FRAG_ERR) {
+		if (resp->error_code && error_code ==
+		    NVM_INSTALL_UPDATE_CMD_ERR_CODE_FRAG_ERR) {
 			install.flags |= cpu_to_le16(
 			       NVM_INSTALL_UPDATE_REQ_FLAGS_ALLOWED_TO_DEFRAG);
 			hwrm_err = _hwrm_send_message(bp, &install,
 						      sizeof(install),
 						      INSTALL_PACKAGE_TIMEOUT);
-			if (hwrm_err)
-				goto flash_pkg_exit;
 		}
+		if (hwrm_err)
+			goto flash_pkg_exit;
 	}
 	if (resp->result) {

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c+3−5

@@ -1236,7 +1236,7 @@ static int __bnxt_tc_del_flow(struct bnxt *bp, · 1235 unmodified lines
1236	static void bnxt_tc_set_flow_dir(struct bnxt bp, struct bnxt_tc_flow flow,	1236	static void bnxt_tc_set_flow_dir(struct bnxt bp, struct bnxt_tc_flow flow,
1237	u16 src_fid)	1237	u16 src_fid)
1238	{	1238	{
1239	flow->dir = (bp->pf.fw_fid == src_fid) ? BNXT_DIR_RX : BNXT_DIR_TX;	1239	flow->l2_key.dir = (bp->pf.fw_fid == src_fid) ? BNXT_DIR_RX : BNXT_DIR_TX;
1240	}	1240	}
1241		1241
1242	static void bnxt_tc_set_src_fid(struct bnxt bp, struct bnxt_tc_flow flow,	1242	static void bnxt_tc_set_src_fid(struct bnxt bp, struct bnxt_tc_flow flow,
@@ -1285,9 +1285,7 @@ static int bnxt_tc_add_flow(struct bnxt *bp, u16 src_fid, · 42 unmodified lines
1285	goto free_node;	1285	goto free_node;
1286		1286
1287	bnxt_tc_set_src_fid(bp, flow, src_fid);	1287	bnxt_tc_set_src_fid(bp, flow, src_fid);
1288		1288	bnxt_tc_set_flow_dir(bp, flow, flow->src_fid);
1289	if (bp->fw_cap & BNXT_FW_CAP_OVS_64BIT_HANDLE)
1290	bnxt_tc_set_flow_dir(bp, flow, src_fid);
1291		1289
1292	if (!bnxt_tc_can_offload(bp, flow)) {	1290	if (!bnxt_tc_can_offload(bp, flow)) {
1293	rc = -EOPNOTSUPP;	1291	rc = -EOPNOTSUPP;
@@ -1407,7 +1405,7 @@ static void bnxt_fill_cfa_stats_req(struct bnxt *bp, · 113 unmodified lines
1407	* 2. 15th bit of flow_handle must specify the flow	1405	* 2. 15th bit of flow_handle must specify the flow
1408	* direction (TX/RX).	1406	* direction (TX/RX).
1409	*/	1407	*/
1410	if (flow_node->flow.dir == BNXT_DIR_RX)	1408	if (flow_node->flow.l2_key.dir == BNXT_DIR_RX)
1411	handle = CFA_FLOW_INFO_REQ_FLOW_HANDLE_DIR_RX \|	1409	handle = CFA_FLOW_INFO_REQ_FLOW_HANDLE_DIR_RX \|
1412	CFA_FLOW_INFO_REQ_FLOW_HANDLE_MAX_MASK;	1410	CFA_FLOW_INFO_REQ_FLOW_HANDLE_MAX_MASK;
1413	else	1411	else

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.h+3−3

 	__be16		inner_vlan_tci;
 	__be16		ether_type;
 	u8		num_vlans;
+	u8		dir;
+#define BNXT_DIR_RX	1
+#define BNXT_DIR_TX	0
 };
 struct bnxt_tc_l3_key {
 	/* flow applicable to pkts ingressing on this fid */
 	u16				src_fid;
-	u8				dir;
-#define BNXT_DIR_RX	1
-#define BNXT_DIR_TX	0
 	struct bnxt_tc_l2_key		l2_key;
 	struct bnxt_tc_l2_key		l2_mask;
 	struct bnxt_tc_l3_key		l3_key;

drivers/net/ethernet/cavium/common/cavium_ptp.c+1−1

@@ -10,7 +10,7 @@ · 9 unmodified lines
10		10
11	#include "cavium_ptp.h"	11	#include "cavium_ptp.h"
12		12
13	#define DRV_NAME "Cavium PTP Driver"	13	#define DRV_NAME "cavium_ptp"
14		14
15	#define PCI_DEVICE_ID_CAVIUM_PTP 0xA00C	15	#define PCI_DEVICE_ID_CAVIUM_PTP 0xA00C
16	#define PCI_DEVICE_ID_CAVIUM_RST 0xA00E	16	#define PCI_DEVICE_ID_CAVIUM_RST 0xA00E

drivers/net/ethernet/cavium/liquidio/request_manager.c+3−1

 	}
 	oct->num_iqs++;
-	if (oct->fn_list.enable_io_queues(oct))
+	if (oct->fn_list.enable_io_queues(oct)) {
+		octeon_delete_instr_queue(oct, iq_no);
 		return 1;
+	}
 	return 0;
 }

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c+3−1

 		return -ENOMEM;
 	err = bitmap_parse_user(ubuf, count, t, adap->sge.egr_sz);
-	if (err)
+	if (err) {
+		kvfree(t);
 		return err;
+	}
 	bitmap_copy(adap->sge.blocked_fl, t, adap->sge.egr_sz);
 	kvfree(t);

drivers/net/ethernet/ezchip/nps_enet.h+2−2

@@ -167,7 +167,7 @@ struct nps_enet_priv { · 166 unmodified lines
167	};	167	};
168		168
169	/**	169	/**
170	* nps_reg_set - Sets ENET register with provided value.	170	* nps_enet_reg_set - Sets ENET register with provided value.
171	* @priv: Pointer to EZchip ENET private data structure.	171	* @priv: Pointer to EZchip ENET private data structure.
172	* @reg: Register offset from base address.	172	* @reg: Register offset from base address.
173	* @value: Value to set in register.	173	* @value: Value to set in register.
@@ -179,7 +179,7 @@ static inline void nps_enet_reg_set(struct nps_enet_priv *priv, · 5 unmodified lines
179	}	179	}
180		180
181	/**	181	/**
182	* nps_reg_get - Gets value of specified ENET register.	182	* nps_enet_reg_get - Gets value of specified ENET register.
183	* @priv: Pointer to EZchip ENET private data structure.	183	* @priv: Pointer to EZchip ENET private data structure.
184	* @reg: Register offset from base address.	184	* @reg: Register offset from base address.
185	*	185	*

drivers/net/ethernet/ibm/ibmveth.c+5−4

 	struct net_device *netdev;
 	struct ibmveth_adapter *adapter;
 	unsigned char *mac_addr_p;
-	unsigned int *mcastFilterSize_p;
+	__be32 *mcastFilterSize_p;
 	long ret;
 	unsigned long ret_attr;
 		return -EINVAL;
 	}
-	mcastFilterSize_p = (unsigned int *)vio_get_attribute(dev,
+	mcastFilterSize_p = (__be32 *)vio_get_attribute(dev,
-						VETH_MCAST_FILTER_SIZE, NULL);
+							VETH_MCAST_FILTER_SIZE,
+							NULL);
 	if (!mcastFilterSize_p) {
 		dev_err(&dev->dev, "Can't find VETH_MCAST_FILTER_SIZE "
 			"attribute\n");
 	adapter->vdev = dev;
 	adapter->netdev = netdev;
-	adapter->mcastFilterSize = *mcastFilterSize_p;
+	adapter->mcastFilterSize = be32_to_cpu(*mcastFilterSize_p);
 	adapter->pool_config = 0;
 	netif_napi_add(netdev, &adapter->napi, ibmveth_poll, 16);

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

 		lpar_rc = send_subcrq_indirect(adapter, handle_array[queue_num],
 					       (u64)tx_buff->indir_dma,
 					       (u64)num_entries);
+		dma_unmap_single(dev, tx_buff->indir_dma,
+				 sizeof(tx_buff->indir_arr), DMA_TO_DEVICE);
 	} else {
 		tx_buff->num_entries = num_entries;
 		lpar_rc = send_subcrq(adapter, handle_array[queue_num],
 	union sub_crq *next;
 	int index;
 	int i, j;
-	u8 *first;
 restart_loop:
 	while (pending_scrq(adapter, scrq)) {
 				txbuff->data_dma[j] = 0;
 			}
-			/* if sub_crq was sent indirectly */
-			first = &txbuff->indir_arr[0].generic.first;
-			if (*first == IBMVNIC_CRQ_CMD) {
-				dma_unmap_single(dev, txbuff->indir_dma,
-						 sizeof(txbuff->indir_arr),
-						 DMA_TO_DEVICE);
-				*first = 0;
-			}
 			if (txbuff->last_frag) {
 				dev_kfree_skb_any(txbuff->skb);

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c+1−4

 		return;
 	}
 	if (ixgbe_check_fw_error(adapter)) {
-		if (!test_bit(__IXGBE_DOWN, &adapter->state)) {
+		if (!test_bit(__IXGBE_DOWN, &adapter->state))
-			rtnl_lock();
 			unregister_netdev(adapter->netdev);
-			rtnl_unlock();
-		}
 		ixgbe_service_event_complete(adapter);
 		return;
 	}

drivers/net/ethernet/mellanox/mlx4/en_rx.c+2−1

 	err = mlx4_qp_alloc(mdev->dev, priv->base_qpn, rss_map->indir_qp);
 	if (err) {
 		en_err(priv, "Failed to allocate RSS indirection QP\n");
-		goto rss_err;
+		goto qp_alloc_err;
 	}
 	rss_map->indir_qp->event = mlx4_en_sqp_event;
 		       MLX4_QP_STATE_RST, NULL, 0, 0, rss_map->indir_qp);
 	mlx4_qp_remove(mdev->dev, rss_map->indir_qp);
 	mlx4_qp_free(mdev->dev, rss_map->indir_qp);
+qp_alloc_err:
 	kfree(rss_map->indir_qp);
 	rss_map->indir_qp = NULL;
 rss_err:

drivers/net/ethernet/mellanox/mlx5/core/en.h+9−2

 struct mlx5e_tx_wqe {
 	struct mlx5_wqe_ctrl_seg ctrl;
-	struct mlx5_wqe_eth_seg  eth;
+	union {
-	struct mlx5_wqe_data_seg data[0];
+		struct {
+			struct mlx5_wqe_eth_seg  eth;
+			struct mlx5_wqe_data_seg data[0];
+		};
+		u8 tls_progress_params_ctx[0];
+	};
 };
 struct mlx5e_rx_wqe_ll {
 u32 mlx5e_ethtool_get_rxfh_indir_size(struct mlx5e_priv *priv);
 int mlx5e_ethtool_get_ts_info(struct mlx5e_priv *priv,
 			      struct ethtool_ts_info *info);
+int mlx5e_ethtool_flash_device(struct mlx5e_priv *priv,
+			       struct ethtool_flash *flash);
 void mlx5e_ethtool_get_pauseparam(struct mlx5e_priv *priv,
 				  struct ethtool_pauseparam *pauseparam);
 int mlx5e_ethtool_set_pauseparam(struct mlx5e_priv *priv,

drivers/net/ethernet/mellanox/mlx5/core/en/reporter_tx.c+9−10

 	u8 state;
 	int err;
-	if (!test_bit(MLX5E_SQ_STATE_RECOVERING, &sq->state))
-		return 0;
 	err = mlx5_core_query_sq_state(mdev, sq->sqn, &state);
 	if (err) {
 		netdev_err(dev, "Failed to query SQ 0x%x state. err = %d\n",
 			   sq->sqn, err);
-		return err;
+		goto out;
 	}
-	if (state != MLX5_SQC_STATE_ERR) {
+	if (state != MLX5_SQC_STATE_ERR)
-		netdev_err(dev, "SQ 0x%x not in ERROR state\n", sq->sqn);
+		goto out;
-		return -EINVAL;
-	}
 	mlx5e_tx_disable_queue(sq->txq);
 	err = mlx5e_wait_for_sq_flush(sq);
 	if (err)
-		return err;
+		goto out;
 	/* At this point, no new packets will arrive from the stack as TXQ is
 	 * marked with QUEUE_STATE_DRV_XOFF. In addition, NAPI cleared all
 	err = mlx5e_sq_to_ready(sq, state);
 	if (err)
-		return err;
+		goto out;
 	mlx5e_reset_txqsq_cc_pc(sq);
 	sq->stats->recover++;
+	clear_bit(MLX5E_SQ_STATE_RECOVERING, &sq->state);
 	mlx5e_activate_txqsq(sq);
 	return 0;
+out:
+	clear_bit(MLX5E_SQ_STATE_RECOVERING, &sq->state);
+	return err;
 }
 static int mlx5_tx_health_report(struct devlink_health_reporter *tx_reporter,

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

 {
 	set_bit(MLX5E_RQ_STATE_ENABLED, &c->xskrq.state);
 	/* TX queue is created active. */
+	spin_lock(&c->xskicosq_lock);
 	mlx5e_trigger_irq(&c->xskicosq);
+	spin_unlock(&c->xskicosq_lock);
 }
 void mlx5e_deactivate_xsk(struct mlx5e_channel *c)

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls.h+4−2

 #include "accel/tls.h"
 #define MLX5E_KTLS_STATIC_UMR_WQE_SZ \
-	(sizeof(struct mlx5e_umr_wqe) + MLX5_ST_SZ_BYTES(tls_static_params))
+	(offsetof(struct mlx5e_umr_wqe, tls_static_params_ctx) + \
+	 MLX5_ST_SZ_BYTES(tls_static_params))
 #define MLX5E_KTLS_STATIC_WQEBBS \
 	(DIV_ROUND_UP(MLX5E_KTLS_STATIC_UMR_WQE_SZ, MLX5_SEND_WQE_BB))
 #define MLX5E_KTLS_PROGRESS_WQE_SZ \
-	(sizeof(struct mlx5e_tx_wqe) + MLX5_ST_SZ_BYTES(tls_progress_params))
+	(offsetof(struct mlx5e_tx_wqe, tls_progress_params_ctx) + \
+	 MLX5_ST_SZ_BYTES(tls_progress_params))
 #define MLX5E_KTLS_PROGRESS_WQEBBS \
 	(DIV_ROUND_UP(MLX5E_KTLS_PROGRESS_WQE_SZ, MLX5_SEND_WQE_BB))
 #define MLX5E_KTLS_MAX_DUMP_WQEBBS 2

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_tx.c+5−5

@@ -69,7 +69,7 @@ build_static_params(struct mlx5e_umr_wqe *wqe, u16 pc, u32 sqn, · 68 unmodified lines
69	cseg->qpn_ds = cpu_to_be32((sqn << MLX5_WQE_CTRL_QPN_SHIFT) \|	69	cseg->qpn_ds = cpu_to_be32((sqn << MLX5_WQE_CTRL_QPN_SHIFT) \|
70	STATIC_PARAMS_DS_CNT);	70	STATIC_PARAMS_DS_CNT);
71	cseg->fm_ce_se = fence ? MLX5_FENCE_MODE_INITIATOR_SMALL : 0;	71	cseg->fm_ce_se = fence ? MLX5_FENCE_MODE_INITIATOR_SMALL : 0;
72	cseg->imm = cpu_to_be32(priv_tx->tisn);	72	cseg->tisn = cpu_to_be32(priv_tx->tisn << 8);
73		73
74	ucseg->flags = MLX5_UMR_INLINE;	74	ucseg->flags = MLX5_UMR_INLINE;
75	ucseg->bsf_octowords = cpu_to_be16(MLX5_ST_SZ_BYTES(tls_static_params) / 16);	75	ucseg->bsf_octowords = cpu_to_be16(MLX5_ST_SZ_BYTES(tls_static_params) / 16);
@@ -80,7 +80,7 @@ build_static_params(struct mlx5e_umr_wqe *wqe, u16 pc, u32 sqn, · 4 unmodified lines
80	static void	80	static void
81	fill_progress_params_ctx(void ctx, struct mlx5e_ktls_offload_context_tx priv_tx)	81	fill_progress_params_ctx(void ctx, struct mlx5e_ktls_offload_context_tx priv_tx)
82	{	82	{
83	MLX5_SET(tls_progress_params, ctx, pd, priv_tx->tisn);	83	MLX5_SET(tls_progress_params, ctx, tisn, priv_tx->tisn);
84	MLX5_SET(tls_progress_params, ctx, record_tracker_state,	84	MLX5_SET(tls_progress_params, ctx, record_tracker_state,
85	MLX5E_TLS_PROGRESS_PARAMS_RECORD_TRACKER_STATE_START);	85	MLX5E_TLS_PROGRESS_PARAMS_RECORD_TRACKER_STATE_START);
86	MLX5_SET(tls_progress_params, ctx, auth_state,	86	MLX5_SET(tls_progress_params, ctx, auth_state,
@@ -104,7 +104,7 @@ build_progress_params(struct mlx5e_tx_wqe *wqe, u16 pc, u32 sqn, · 17 unmodified lines
104	PROGRESS_PARAMS_DS_CNT);	104	PROGRESS_PARAMS_DS_CNT);
105	cseg->fm_ce_se = fence ? MLX5_FENCE_MODE_INITIATOR_SMALL : 0;	105	cseg->fm_ce_se = fence ? MLX5_FENCE_MODE_INITIATOR_SMALL : 0;
106		106
107	fill_progress_params_ctx(wqe->data, priv_tx);	107	fill_progress_params_ctx(wqe->tls_progress_params_ctx, priv_tx);
108	}	108	}
109		109
110	static void tx_fill_wi(struct mlx5e_txqsq *sq,	110	static void tx_fill_wi(struct mlx5e_txqsq *sq,
@@ -278,7 +278,7 @@ tx_post_resync_dump(struct mlx5e_txqsq sq, struct sk_buff skb, · 167 unmodified lines
278		278
279	cseg->opmod_idx_opcode = cpu_to_be32((sq->pc << 8) \| MLX5_OPCODE_DUMP);	279	cseg->opmod_idx_opcode = cpu_to_be32((sq->pc << 8) \| MLX5_OPCODE_DUMP);
280	cseg->qpn_ds = cpu_to_be32((sq->sqn << 8) \| ds_cnt);	280	cseg->qpn_ds = cpu_to_be32((sq->sqn << 8) \| ds_cnt);
281	cseg->imm = cpu_to_be32(tisn);	281	cseg->tisn = cpu_to_be32(tisn << 8);
282	cseg->fm_ce_se = first ? MLX5_FENCE_MODE_INITIATOR_SMALL : 0;	282	cseg->fm_ce_se = first ? MLX5_FENCE_MODE_INITIATOR_SMALL : 0;
283		283
284	eseg->inline_hdr.sz = cpu_to_be16(ihs);	284	eseg->inline_hdr.sz = cpu_to_be16(ihs);
@@ -434,7 +434,7 @@ struct sk_buff mlx5e_ktls_handle_tx_skb(struct net_device netdev, · 149 unmodified lines
434	priv_tx->expected_seq = seq + datalen;	434	priv_tx->expected_seq = seq + datalen;
435		435
436	cseg = &(*wqe)->ctrl;	436	cseg = &(*wqe)->ctrl;
437	cseg->imm = cpu_to_be32(priv_tx->tisn);	437	cseg->tisn = cpu_to_be32(priv_tx->tisn << 8);
438		438
439	stats->tls_encrypted_packets += skb_is_gso(skb) ? skb_shinfo(skb)->gso_segs : 1;	439	stats->tls_encrypted_packets += skb_is_gso(skb) ? skb_shinfo(skb)->gso_segs : 1;
440	stats->tls_encrypted_bytes += datalen;	440	stats->tls_encrypted_bytes += datalen;

drivers/net/ethernet/mellanox/mlx5/core/en_arfs.c+34−63

 	return &arfs_t->rules_hash[bucket_idx];
 }
-static u8 arfs_get_ip_proto(const struct sk_buff *skb)
-{
-	return (skb->protocol == htons(ETH_P_IP)) ?
-		ip_hdr(skb)->protocol : ipv6_hdr(skb)->nexthdr;
-}
 static struct arfs_table *arfs_get_table(struct mlx5e_arfs_tables *arfs,
 					 u8 ip_proto, __be16 etype)
 {
 	arfs_may_expire_flow(priv);
 }
-/* return L4 destination port from ip4/6 packets */
-static __be16 arfs_get_dst_port(const struct sk_buff *skb)
-{
-	char *transport_header;
-	transport_header = skb_transport_header(skb);
-	if (arfs_get_ip_proto(skb) == IPPROTO_TCP)
-		return ((struct tcphdr *)transport_header)->dest;
-	return ((struct udphdr *)transport_header)->dest;
-}
-/* return L4 source port from ip4/6 packets */
-static __be16 arfs_get_src_port(const struct sk_buff *skb)
-{
-	char *transport_header;
-	transport_header = skb_transport_header(skb);
-	if (arfs_get_ip_proto(skb) == IPPROTO_TCP)
-		return ((struct tcphdr *)transport_header)->source;
-	return ((struct udphdr *)transport_header)->source;
-}
 static struct arfs_rule *arfs_alloc_rule(struct mlx5e_priv *priv,
 					 struct arfs_table *arfs_t,
-					 const struct sk_buff *skb,
+					 const struct flow_keys *fk,
 					 u16 rxq, u32 flow_id)
 {
 	struct arfs_rule *rule;
 	INIT_WORK(&rule->arfs_work, arfs_handle_work);
 	tuple = &rule->tuple;
-	tuple->etype = skb->protocol;
+	tuple->etype = fk->basic.n_proto;
+	tuple->ip_proto = fk->basic.ip_proto;
 	if (tuple->etype == htons(ETH_P_IP)) {
-		tuple->src_ipv4 = ip_hdr(skb)->saddr;
+		tuple->src_ipv4 = fk->addrs.v4addrs.src;
-		tuple->dst_ipv4 = ip_hdr(skb)->daddr;
+		tuple->dst_ipv4 = fk->addrs.v4addrs.dst;
 	} else {
-		memcpy(&tuple->src_ipv6, &ipv6_hdr(skb)->saddr,
+		memcpy(&tuple->src_ipv6, &fk->addrs.v6addrs.src,
 		       sizeof(struct in6_addr));
-		memcpy(&tuple->dst_ipv6, &ipv6_hdr(skb)->daddr,
+		memcpy(&tuple->dst_ipv6, &fk->addrs.v6addrs.dst,
 		       sizeof(struct in6_addr));
 	}
-	tuple->ip_proto = arfs_get_ip_proto(skb);
+	tuple->src_port = fk->ports.src;
-	tuple->src_port = arfs_get_src_port(skb);
+	tuple->dst_port = fk->ports.dst;
-	tuple->dst_port = arfs_get_dst_port(skb);
 	rule->flow_id = flow_id;
 	rule->filter_id = priv->fs.arfs.last_filter_id++ % RPS_NO_FILTER;
 	return rule;
 }
-static bool arfs_cmp_ips(struct arfs_tuple *tuple,
+static bool arfs_cmp(const struct arfs_tuple *tuple, const struct flow_keys *fk)
-			 const struct sk_buff *skb)
 {
-	if (tuple->etype == htons(ETH_P_IP) &&
+	if (tuple->src_port != fk->ports.src || tuple->dst_port != fk->ports.dst)
-	    tuple->src_ipv4 == ip_hdr(skb)->saddr &&
+		return false;
-	    tuple->dst_ipv4 == ip_hdr(skb)->daddr)
+	if (tuple->etype != fk->basic.n_proto)
-		return true;
+		return false;
-	if (tuple->etype == htons(ETH_P_IPV6) &&
+	if (tuple->etype == htons(ETH_P_IP))
-	    (!memcmp(&tuple->src_ipv6, &ipv6_hdr(skb)->saddr,
+		return tuple->src_ipv4 == fk->addrs.v4addrs.src &&
-		     sizeof(struct in6_addr))) &&
+		       tuple->dst_ipv4 == fk->addrs.v4addrs.dst;
-	    (!memcmp(&tuple->dst_ipv6, &ipv6_hdr(skb)->daddr,
+	if (tuple->etype == htons(ETH_P_IPV6))
-		     sizeof(struct in6_addr))))
+		return !memcmp(&tuple->src_ipv6, &fk->addrs.v6addrs.src,
-		return true;
+			       sizeof(struct in6_addr)) &&
+		       !memcmp(&tuple->dst_ipv6, &fk->addrs.v6addrs.dst,
+			       sizeof(struct in6_addr));
 	return false;
 }
 static struct arfs_rule *arfs_find_rule(struct arfs_table *arfs_t,
-					const struct sk_buff *skb)
+					const struct flow_keys *fk)
 {
 	struct arfs_rule *arfs_rule;
 	struct hlist_head *head;
-	__be16 src_port = arfs_get_src_port(skb);
-	__be16 dst_port = arfs_get_dst_port(skb);
-	head = arfs_hash_bucket(arfs_t, src_port, dst_port);
+	head = arfs_hash_bucket(arfs_t, fk->ports.src, fk->ports.dst);
 	hlist_for_each_entry(arfs_rule, head, hlist) {
-		if (arfs_rule->tuple.src_port == src_port &&
+		if (arfs_cmp(&arfs_rule->tuple, fk))
-		    arfs_rule->tuple.dst_port == dst_port &&
-		    arfs_cmp_ips(&arfs_rule->tuple, skb)) {
 			return arfs_rule;
-		}
 	}
 	return NULL;
 	struct mlx5e_arfs_tables *arfs = &priv->fs.arfs;
 	struct arfs_table *arfs_t;
 	struct arfs_rule *arfs_rule;
+	struct flow_keys fk;
+	if (!skb_flow_dissect_flow_keys(skb, &fk, 0))
+		return -EPROTONOSUPPORT;
-	if (skb->protocol != htons(ETH_P_IP) &&
+	if (fk.basic.n_proto != htons(ETH_P_IP) &&
-	    skb->protocol != htons(ETH_P_IPV6))
+	    fk.basic.n_proto != htons(ETH_P_IPV6))
 		return -EPROTONOSUPPORT;
 	if (skb->encapsulation)
 		return -EPROTONOSUPPORT;
-	arfs_t = arfs_get_table(arfs, arfs_get_ip_proto(skb), skb->protocol);
+	arfs_t = arfs_get_table(arfs, fk.basic.ip_proto, fk.basic.n_proto);
 	if (!arfs_t)
 		return -EPROTONOSUPPORT;
 	spin_lock_bh(&arfs->arfs_lock);
-	arfs_rule = arfs_find_rule(arfs_t, skb);
+	arfs_rule = arfs_find_rule(arfs_t, &fk);
 	if (arfs_rule) {
 		if (arfs_rule->rxq == rxq_index) {
 			spin_unlock_bh(&arfs->arfs_lock);
 		}
 		arfs_rule->rxq = rxq_index;
 	} else {
-		arfs_rule = arfs_alloc_rule(priv, arfs_t, skb,
+		arfs_rule = arfs_alloc_rule(priv, arfs_t, &fk, rxq_index, flow_id);
-					    rxq_index, flow_id);
 		if (!arfs_rule) {
 			spin_unlock_bh(&arfs->arfs_lock);
 			return -ENOMEM;

drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c+46−0

@@ -1081,6 +1081,14 @@ int mlx5e_ethtool_set_link_ksettings(struct mlx5e_priv *priv, · 1080 unmodified lines
1081	link_modes = autoneg == AUTONEG_ENABLE ? ethtool2ptys_adver_func(adver) :	1081	link_modes = autoneg == AUTONEG_ENABLE ? ethtool2ptys_adver_func(adver) :
1082	mlx5e_port_speed2linkmodes(mdev, speed, !ext);	1082	mlx5e_port_speed2linkmodes(mdev, speed, !ext);
1083		1083
		1084	if ((link_modes & MLX5E_PROT_MASK(MLX5E_56GBASE_R4)) &&
		1085	autoneg != AUTONEG_ENABLE) {
		1086	netdev_err(priv->netdev, "%s: 56G link speed requires autoneg enabled\n",
		1087	__func__);
		1088	err = -EINVAL;
		1089	goto out;
		1090	}
		1091
1084	link_modes = link_modes & eproto.cap;	1092	link_modes = link_modes & eproto.cap;
1085	if (!link_modes) {	1093	if (!link_modes) {
1086	netdev_err(priv->netdev, "%s: Not supported link mode(s) requested",	1094	netdev_err(priv->netdev, "%s: Not supported link mode(s) requested",
@@ -1338,6 +1346,9 @@ int mlx5e_ethtool_set_pauseparam(struct mlx5e_priv *priv, · 251 unmodified lines
1338	struct mlx5_core_dev *mdev = priv->mdev;	1346	struct mlx5_core_dev *mdev = priv->mdev;
1339	int err;	1347	int err;
1340		1348
		1349	if (!MLX5_CAP_GEN(mdev, vport_group_manager))
		1350	return -EOPNOTSUPP;
		1351
1341	if (pauseparam->autoneg)	1352	if (pauseparam->autoneg)
1342	return -EINVAL;	1353	return -EINVAL;
1343		1354
@@ -1679,6 +1690,40 @@ static int mlx5e_get_module_eeprom(struct net_device *netdev, · 335 unmodified lines
1679	return 0;	1690	return 0;
1680	}	1691	}
1681		1692
		1693	int mlx5e_ethtool_flash_device(struct mlx5e_priv *priv,
		1694	struct ethtool_flash *flash)
		1695	{
		1696	struct mlx5_core_dev *mdev = priv->mdev;
		1697	struct net_device *dev = priv->netdev;
		1698	const struct firmware *fw;
		1699	int err;
		1700
		1701	if (flash->region != ETHTOOL_FLASH_ALL_REGIONS)
		1702	return -EOPNOTSUPP;
		1703
		1704	err = request_firmware_direct(&fw, flash->data, &dev->dev);
		1705	if (err)
		1706	return err;
		1707
		1708	dev_hold(dev);
		1709	rtnl_unlock();
		1710
		1711	err = mlx5_firmware_flash(mdev, fw, NULL);
		1712	release_firmware(fw);
		1713
		1714	rtnl_lock();
		1715	dev_put(dev);
		1716	return err;
		1717	}
		1718
		1719	static int mlx5e_flash_device(struct net_device *dev,
		1720	struct ethtool_flash *flash)
		1721	{
		1722	struct mlx5e_priv *priv = netdev_priv(dev);
		1723
		1724	return mlx5e_ethtool_flash_device(priv, flash);
		1725	}
		1726
1682	static int set_pflag_cqe_based_moder(struct net_device *netdev, bool enable,	1727	static int set_pflag_cqe_based_moder(struct net_device *netdev, bool enable,
1683	bool is_rx_cq)	1728	bool is_rx_cq)
1684	{	1729	{
@@ -1965,6 +2010,7 @@ const struct ethtool_ops mlx5e_ethtool_ops = { · 280 unmodified lines
1965	.set_wol = mlx5e_set_wol,	2010	.set_wol = mlx5e_set_wol,
1966	.get_module_info = mlx5e_get_module_info,	2011	.get_module_info = mlx5e_get_module_info,
1967	.get_module_eeprom = mlx5e_get_module_eeprom,	2012	.get_module_eeprom = mlx5e_get_module_eeprom,
		2013	.flash_device = mlx5e_flash_device,
1968	.get_priv_flags = mlx5e_get_priv_flags,	2014	.get_priv_flags = mlx5e_get_priv_flags,
1969	.set_priv_flags = mlx5e_set_priv_flags,	2015	.set_priv_flags = mlx5e_set_priv_flags,
1970	.self_test = mlx5e_self_test,	2016	.self_test = mlx5e_self_test,

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

@@ -1323,7 +1323,6 @@ err_free_txqsq: · 1322 unmodified lines
1323	void mlx5e_activate_txqsq(struct mlx5e_txqsq *sq)	1323	void mlx5e_activate_txqsq(struct mlx5e_txqsq *sq)
1324	{	1324	{
1325	sq->txq = netdev_get_tx_queue(sq->channel->netdev, sq->txq_ix);	1325	sq->txq = netdev_get_tx_queue(sq->channel->netdev, sq->txq_ix);
1326	clear_bit(MLX5E_SQ_STATE_RECOVERING, &sq->state);
1327	set_bit(MLX5E_SQ_STATE_ENABLED, &sq->state);	1326	set_bit(MLX5E_SQ_STATE_ENABLED, &sq->state);
1328	netdev_tx_reset_queue(sq->txq);	1327	netdev_tx_reset_queue(sq->txq);
1329	netif_tx_start_queue(sq->txq);	1328	netif_tx_start_queue(sq->txq);

drivers/net/ethernet/mellanox/mlx5/core/en_tc.c+21−12

 			      struct mlx5_flow_spec *spec,
 			      struct flow_cls_offload *f,
 			      struct net_device *filter_dev,
-			      u8 *match_level, u8 *tunnel_match_level)
+			      u8 *inner_match_level, u8 *outer_match_level)
 {
 	struct netlink_ext_ack *extack = f->common.extack;
 	void *headers_c = MLX5_ADDR_OF(fte_match_param, spec->match_criteria,
 	struct flow_dissector *dissector = rule->match.dissector;
 	u16 addr_type = 0;
 	u8 ip_proto = 0;
+	u8 *match_level;
-	*match_level = MLX5_MATCH_NONE;
+	match_level = outer_match_level;
 	if (dissector->used_keys &
 	    ~(BIT(FLOW_DISSECTOR_KEY_META) |
 	}
 	if (mlx5e_get_tc_tun(filter_dev)) {
-		if (parse_tunnel_attr(priv, spec, f, filter_dev, tunnel_match_level))
+		if (parse_tunnel_attr(priv, spec, f, filter_dev,
+				      outer_match_level))
 			return -EOPNOTSUPP;
-		/* In decap flow, header pointers should point to the inner
+		/* At this point, header pointers should point to the inner
 		 * headers, outer header were already set by parse_tunnel_attr
 		 */
+		match_level = inner_match_level;
 		headers_c = get_match_headers_criteria(MLX5_FLOW_CONTEXT_ACTION_DECAP,
 						       spec);
 		headers_v = get_match_headers_value(MLX5_FLOW_CONTEXT_ACTION_DECAP,
 			    struct flow_cls_offload *f,
 			    struct net_device *filter_dev)
 {
+	u8 inner_match_level, outer_match_level, non_tunnel_match_level;
 	struct netlink_ext_ack *extack = f->common.extack;
 	struct mlx5_core_dev *dev = priv->mdev;
 	struct mlx5_eswitch *esw = dev->priv.eswitch;
 	struct mlx5e_rep_priv *rpriv = priv->ppriv;
-	u8 match_level, tunnel_match_level = MLX5_MATCH_NONE;
 	struct mlx5_eswitch_rep *rep;
 	bool is_eswitch_flow;
 	int err;
-	err = __parse_cls_flower(priv, spec, f, filter_dev, &match_level, &tunnel_match_level);
+	inner_match_level = MLX5_MATCH_NONE;
+	outer_match_level = MLX5_MATCH_NONE;
+	err = __parse_cls_flower(priv, spec, f, filter_dev, &inner_match_level,
+				 &outer_match_level);
+	non_tunnel_match_level = (inner_match_level == MLX5_MATCH_NONE) ?
+				 outer_match_level : inner_match_level;
 	is_eswitch_flow = mlx5e_is_eswitch_flow(flow);
 	if (!err && is_eswitch_flow) {
 		rep = rpriv->rep;
 		if (rep->vport != MLX5_VPORT_UPLINK &&
 		    (esw->offloads.inline_mode != MLX5_INLINE_MODE_NONE &&
-		    esw->offloads.inline_mode < match_level)) {
+		    esw->offloads.inline_mode < non_tunnel_match_level)) {
 			NL_SET_ERR_MSG_MOD(extack,
 					   "Flow is not offloaded due to min inline setting");
 			netdev_warn(priv->netdev,
 				    "Flow is not offloaded due to min inline setting, required %d actual %d\n",
-				    match_level, esw->offloads.inline_mode);
+				    non_tunnel_match_level, esw->offloads.inline_mode);
 			return -EOPNOTSUPP;
 		}
 	}
 	if (is_eswitch_flow) {
-		flow->esw_attr->match_level = match_level;
+		flow->esw_attr->inner_match_level = inner_match_level;
-		flow->esw_attr->tunnel_match_level = tunnel_match_level;
+		flow->esw_attr->outer_match_level = outer_match_level;
 	} else {
-		flow->nic_attr->match_level = match_level;
+		flow->nic_attr->match_level = non_tunnel_match_level;
 	}
 	return err;
 	esw_attr->parse_attr = parse_attr;
 	esw_attr->chain = f->common.chain_index;
-	esw_attr->prio = TC_H_MAJ(f->common.prio) >> 16;
+	esw_attr->prio = f->common.prio;
 	esw_attr->in_rep = in_rep;
 	esw_attr->in_mdev = in_mdev;

drivers/net/ethernet/mellanox/mlx5/core/eswitch.h+2−2

@@ -390,8 +390,8 @@ struct mlx5_esw_flow_attr { · 389 unmodified lines
390	struct mlx5_termtbl_handle *termtbl;	390	struct mlx5_termtbl_handle *termtbl;
391	} dests[MLX5_MAX_FLOW_FWD_VPORTS];	391	} dests[MLX5_MAX_FLOW_FWD_VPORTS];
392	u32 mod_hdr_id;	392	u32 mod_hdr_id;
393	u8 match_level;	393	u8 inner_match_level;
394	u8 tunnel_match_level;	394	u8 outer_match_level;
395	struct mlx5_fc *counter;	395	struct mlx5_fc *counter;
396	u32 chain;	396	u32 chain;
397	u16 prio;	397	u16 prio;

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

 	mlx5_eswitch_set_rule_source_port(esw, spec, attr);
-	if (flow_act.action & MLX5_FLOW_CONTEXT_ACTION_DECAP) {
+	if (attr->outer_match_level != MLX5_MATCH_NONE)
-		if (attr->tunnel_match_level != MLX5_MATCH_NONE)
-			spec->match_criteria_enable |= MLX5_MATCH_OUTER_HEADERS;
-		if (attr->match_level != MLX5_MATCH_NONE)
-			spec->match_criteria_enable |= MLX5_MATCH_INNER_HEADERS;
-	} else if (attr->match_level != MLX5_MATCH_NONE) {
 		spec->match_criteria_enable |= MLX5_MATCH_OUTER_HEADERS;
-	}
+	if (attr->inner_match_level != MLX5_MATCH_NONE)
+		spec->match_criteria_enable |= MLX5_MATCH_INNER_HEADERS;
 	if (flow_act.action & MLX5_FLOW_CONTEXT_ACTION_MOD_HDR)
 		flow_act.modify_id = attr->mod_hdr_id;
 	mlx5_eswitch_set_rule_source_port(esw, spec, attr);
 	spec->match_criteria_enable |= MLX5_MATCH_MISC_PARAMETERS;
-	if (attr->match_level != MLX5_MATCH_NONE)
+	if (attr->outer_match_level != MLX5_MATCH_NONE)
 		spec->match_criteria_enable |= MLX5_MATCH_OUTER_HEADERS;
 	rule = mlx5_add_flow_rules(fast_fdb, spec, &flow_act, dest, i);

drivers/net/ethernet/mellanox/mlx5/core/ipoib/ethtool.c+9−0

 	return mlx5e_ethtool_get_ts_info(priv, info);
 }
+static int mlx5i_flash_device(struct net_device *netdev,
+			      struct ethtool_flash *flash)
+{
+	struct mlx5e_priv *priv = mlx5i_epriv(netdev);
+	return mlx5e_ethtool_flash_device(priv, flash);
+}
 enum mlx5_ptys_width {
 	MLX5_PTYS_WIDTH_1X	= 1 << 0,
 	MLX5_PTYS_WIDTH_2X	= 1 << 1,
 	.get_ethtool_stats  = mlx5i_get_ethtool_stats,
 	.get_ringparam      = mlx5i_get_ringparam,
 	.set_ringparam      = mlx5i_set_ringparam,
+	.flash_device       = mlx5i_flash_device,
 	.get_channels       = mlx5i_get_channels,
 	.set_channels       = mlx5i_set_channels,
 	.get_coalesce       = mlx5i_get_coalesce,

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

@@ -27,6 +27,7 @@ int mlx5_create_encryption_key(struct mlx5_core_dev *mdev, · 26 unmodified lines
27	case 128:	27	case 128:
28	general_obj_key_size =	28	general_obj_key_size =
29	MLX5_GENERAL_OBJECT_TYPE_ENCRYPTION_KEY_KEY_SIZE_128;	29	MLX5_GENERAL_OBJECT_TYPE_ENCRYPTION_KEY_KEY_SIZE_128;
		30	key_p += sz_bytes;
30	break;	31	break;
31	case 256:	32	case 256:
32	general_obj_key_size =	33	general_obj_key_size =

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

@@ -477,7 +477,7 @@ int mlxsw_sp_acl_rulei_commit(struct mlxsw_sp_acl_rule_info *rulei) · 476 unmodified lines
477	void mlxsw_sp_acl_rulei_priority(struct mlxsw_sp_acl_rule_info *rulei,	477	void mlxsw_sp_acl_rulei_priority(struct mlxsw_sp_acl_rule_info *rulei,
478	unsigned int priority)	478	unsigned int priority)
479	{	479	{
480	rulei->priority = priority >> 16;	480	rulei->priority = priority;
481	}	481	}
482		482
483	void mlxsw_sp_acl_rulei_keymask_u32(struct mlxsw_sp_acl_rule_info *rulei,	483	void mlxsw_sp_acl_rulei_keymask_u32(struct mlxsw_sp_acl_rule_info *rulei,

drivers/net/ethernet/mellanox/mlxsw/spectrum_ptp.c+55−83

@@ -29,7 +29,7 @@ · 28 unmodified lines
29		29
30	struct mlxsw_sp_ptp_state {	30	struct mlxsw_sp_ptp_state {
31	struct mlxsw_sp *mlxsw_sp;	31	struct mlxsw_sp *mlxsw_sp;
32	struct rhashtable unmatched_ht;	32	struct rhltable unmatched_ht;
33	spinlock_t unmatched_lock; /* protects the HT */	33	spinlock_t unmatched_lock; /* protects the HT */
34	struct delayed_work ht_gc_dw;	34	struct delayed_work ht_gc_dw;
35	u32 gc_cycle;	35	u32 gc_cycle;
@@ -45,7 +45,7 @@ struct mlxsw_sp1_ptp_key { · 9 unmodified lines
45		45
46	struct mlxsw_sp1_ptp_unmatched {	46	struct mlxsw_sp1_ptp_unmatched {
47	struct mlxsw_sp1_ptp_key key;	47	struct mlxsw_sp1_ptp_key key;
48	struct rhash_head ht_node;	48	struct rhlist_head ht_node;
49	struct rcu_head rcu;	49	struct rcu_head rcu;
50	struct sk_buff *skb;	50	struct sk_buff *skb;
51	u64 timestamp;	51	u64 timestamp;
@@ -359,7 +359,7 @@ static int mlxsw_sp_ptp_parse(struct sk_buff *skb, · 307 unmodified lines
359	/* Returns NULL on successful insertion, a pointer on conflict, or an ERR_PTR on	359	/* Returns NULL on successful insertion, a pointer on conflict, or an ERR_PTR on
360	* error.	360	* error.
361	*/	361	*/
362	static struct mlxsw_sp1_ptp_unmatched *	362	static int
363	mlxsw_sp1_ptp_unmatched_save(struct mlxsw_sp *mlxsw_sp,	363	mlxsw_sp1_ptp_unmatched_save(struct mlxsw_sp *mlxsw_sp,
364	struct mlxsw_sp1_ptp_key key,	364	struct mlxsw_sp1_ptp_key key,
365	struct sk_buff *skb,	365	struct sk_buff *skb,
@@ -368,41 +368,51 @@ mlxsw_sp1_ptp_unmatched_save(struct mlxsw_sp *mlxsw_sp, · 2 unmodified lines
368	int cycles = MLXSW_SP1_PTP_HT_GC_TIMEOUT / MLXSW_SP1_PTP_HT_GC_INTERVAL;	368	int cycles = MLXSW_SP1_PTP_HT_GC_TIMEOUT / MLXSW_SP1_PTP_HT_GC_INTERVAL;
369	struct mlxsw_sp_ptp_state *ptp_state = mlxsw_sp->ptp_state;	369	struct mlxsw_sp_ptp_state *ptp_state = mlxsw_sp->ptp_state;
370	struct mlxsw_sp1_ptp_unmatched *unmatched;	370	struct mlxsw_sp1_ptp_unmatched *unmatched;
371	struct mlxsw_sp1_ptp_unmatched *conflict;	371	int err;
372		372
373	unmatched = kzalloc(sizeof(*unmatched), GFP_ATOMIC);	373	unmatched = kzalloc(sizeof(*unmatched), GFP_ATOMIC);
374	if (!unmatched)	374	if (!unmatched)
375	return ERR_PTR(-ENOMEM);	375	return -ENOMEM;
376		376
377	unmatched->key = key;	377	unmatched->key = key;
378	unmatched->skb = skb;	378	unmatched->skb = skb;
379	unmatched->timestamp = timestamp;	379	unmatched->timestamp = timestamp;
380	unmatched->gc_cycle = mlxsw_sp->ptp_state->gc_cycle + cycles;	380	unmatched->gc_cycle = mlxsw_sp->ptp_state->gc_cycle + cycles;
381		381
382	conflict = rhashtable_lookup_get_insert_fast(&ptp_state->unmatched_ht,	382	err = rhltable_insert(&ptp_state->unmatched_ht, &unmatched->ht_node,
383	&unmatched->ht_node,	383	mlxsw_sp1_ptp_unmatched_ht_params);
384	mlxsw_sp1_ptp_unmatched_ht_params);	384	if (err)
385	if (conflict)
386	kfree(unmatched);	385	kfree(unmatched);
387		386
388	return conflict;	387	return err;
389	}	388	}
390		389
391	static struct mlxsw_sp1_ptp_unmatched *	390	static struct mlxsw_sp1_ptp_unmatched *
392	mlxsw_sp1_ptp_unmatched_lookup(struct mlxsw_sp *mlxsw_sp,	391	mlxsw_sp1_ptp_unmatched_lookup(struct mlxsw_sp *mlxsw_sp,
393	struct mlxsw_sp1_ptp_key key)	392	struct mlxsw_sp1_ptp_key key, int *p_length)
394	{	393	{
395	return rhashtable_lookup(&mlxsw_sp->ptp_state->unmatched_ht, &key,	394	struct mlxsw_sp1_ptp_unmatched unmatched, last = NULL;
396	mlxsw_sp1_ptp_unmatched_ht_params);	395	struct rhlist_head tmp, list;
		396	int length = 0;
		397
		398	list = rhltable_lookup(&mlxsw_sp->ptp_state->unmatched_ht, &key,
		399	mlxsw_sp1_ptp_unmatched_ht_params);
		400	rhl_for_each_entry_rcu(unmatched, tmp, list, ht_node) {
		401	last = unmatched;
		402	length++;
		403	}
		404
		405	*p_length = length;
		406	return last;
397	}	407	}
398		408
399	static int	409	static int
400	mlxsw_sp1_ptp_unmatched_remove(struct mlxsw_sp *mlxsw_sp,	410	mlxsw_sp1_ptp_unmatched_remove(struct mlxsw_sp *mlxsw_sp,
401	struct mlxsw_sp1_ptp_unmatched *unmatched)	411	struct mlxsw_sp1_ptp_unmatched *unmatched)
402	{	412	{
403	return rhashtable_remove_fast(&mlxsw_sp->ptp_state->unmatched_ht,	413	return rhltable_remove(&mlxsw_sp->ptp_state->unmatched_ht,
404	&unmatched->ht_node,	414	&unmatched->ht_node,
405	mlxsw_sp1_ptp_unmatched_ht_params);	415	mlxsw_sp1_ptp_unmatched_ht_params);
406	}	416	}
407		417
408	/* This function is called in the following scenarios:	418	/* This function is called in the following scenarios:
@@ -489,75 +499,38 @@ static void mlxsw_sp1_ptp_got_piece(struct mlxsw_sp *mlxsw_sp, · 80 unmodified lines
489	struct mlxsw_sp1_ptp_key key,	499	struct mlxsw_sp1_ptp_key key,
490	struct sk_buff *skb, u64 timestamp)	500	struct sk_buff *skb, u64 timestamp)
491	{	501	{
492	struct mlxsw_sp1_ptp_unmatched unmatched, conflict;	502	struct mlxsw_sp1_ptp_unmatched *unmatched;
		503	int length;
493	int err;	504	int err;
494		505
495	rcu_read_lock();	506	rcu_read_lock();
496		507
497	unmatched = mlxsw_sp1_ptp_unmatched_lookup(mlxsw_sp, key);
498
499	spin_lock(&mlxsw_sp->ptp_state->unmatched_lock);	508	spin_lock(&mlxsw_sp->ptp_state->unmatched_lock);
500		509
501	if (unmatched) {	510	unmatched = mlxsw_sp1_ptp_unmatched_lookup(mlxsw_sp, key, &length);
502	/* There was an unmatched entry when we looked, but it may have
503	* been removed before we took the lock.
504	*/
505	err = mlxsw_sp1_ptp_unmatched_remove(mlxsw_sp, unmatched);
506	if (err)
507	unmatched = NULL;
508	}
509
510	if (!unmatched) {
511	/* We have no unmatched entry, but one may have been added after
512	* we looked, but before we took the lock.
513	*/
514	unmatched = mlxsw_sp1_ptp_unmatched_save(mlxsw_sp, key,
515	skb, timestamp);
516	if (IS_ERR(unmatched)) {
517	if (skb)
518	mlxsw_sp1_ptp_packet_finish(mlxsw_sp, skb,
519	key.local_port,
520	key.ingress, NULL);
521	unmatched = NULL;
522	} else if (unmatched) {
523	/* Save just told us, under lock, that the entry is
524	* there, so this has to work.
525	*/
526	err = mlxsw_sp1_ptp_unmatched_remove(mlxsw_sp,
527	unmatched);
528	WARN_ON_ONCE(err);
529	}
530	}
531
532	/* If unmatched is non-NULL here, it comes either from the lookup, or
533	* from the save attempt above. In either case the entry was removed
534	* from the hash table. If unmatched is NULL, a new unmatched entry was
535	* added to the hash table, and there was no conflict.
536	*/
537
538	if (skb && unmatched && unmatched->timestamp) {	511	if (skb && unmatched && unmatched->timestamp) {
539	unmatched->skb = skb;	512	unmatched->skb = skb;
540	} else if (timestamp && unmatched && unmatched->skb) {	513	} else if (timestamp && unmatched && unmatched->skb) {
541	unmatched->timestamp = timestamp;	514	unmatched->timestamp = timestamp;
542	} else if (unmatched) {	515	} else {
543	/* unmatched holds an older entry of the same type: either an	516	/* Either there is no entry to match, or one that is there is
544	* skb if we are handling skb, or a timestamp if we are handling	517	* incompatible.
545	* timestamp. We can't match that up, so save what we have.
546	*/	518	*/
547	conflict = mlxsw_sp1_ptp_unmatched_save(mlxsw_sp, key,	519	if (length < 100)
548	skb, timestamp);	520	err = mlxsw_sp1_ptp_unmatched_save(mlxsw_sp, key,
549	if (IS_ERR(conflict)) {	521	skb, timestamp);
550	if (skb)	522	else
551	mlxsw_sp1_ptp_packet_finish(mlxsw_sp, skb,	523	err = -E2BIG;
552	key.local_port,	524	if (err && skb)
553	key.ingress, NULL);	525	mlxsw_sp1_ptp_packet_finish(mlxsw_sp, skb,
554	} else {	526	key.local_port,
555	/* Above, we removed an object with this key from the	527	key.ingress, NULL);
556	* hash table, under lock, so conflict can not be a	528	unmatched = NULL;
557	* valid pointer.	529	}
558	*/	530
559	WARN_ON_ONCE(conflict);	531	if (unmatched) {
560	}	532	err = mlxsw_sp1_ptp_unmatched_remove(mlxsw_sp, unmatched);
		533	WARN_ON_ONCE(err);
561	}	534	}
562		535
563	spin_unlock(&mlxsw_sp->ptp_state->unmatched_lock);	536	spin_unlock(&mlxsw_sp->ptp_state->unmatched_lock);
@@ -669,9 +642,8 @@ mlxsw_sp1_ptp_ht_gc_collect(struct mlxsw_sp_ptp_state *ptp_state, · 105 unmodified lines
669	local_bh_disable();	642	local_bh_disable();
670		643
671	spin_lock(&ptp_state->unmatched_lock);	644	spin_lock(&ptp_state->unmatched_lock);
672	err = rhashtable_remove_fast(&ptp_state->unmatched_ht,	645	err = rhltable_remove(&ptp_state->unmatched_ht, &unmatched->ht_node,
673	&unmatched->ht_node,	646	mlxsw_sp1_ptp_unmatched_ht_params);
674	mlxsw_sp1_ptp_unmatched_ht_params);
675	spin_unlock(&ptp_state->unmatched_lock);	647	spin_unlock(&ptp_state->unmatched_lock);
676		648
677	if (err)	649	if (err)
@@ -702,7 +674,7 @@ static void mlxsw_sp1_ptp_ht_gc(struct work_struct *work) · 24 unmodified lines
702	ptp_state = container_of(dwork, struct mlxsw_sp_ptp_state, ht_gc_dw);	674	ptp_state = container_of(dwork, struct mlxsw_sp_ptp_state, ht_gc_dw);
703	gc_cycle = ptp_state->gc_cycle++;	675	gc_cycle = ptp_state->gc_cycle++;
704		676
705	rhashtable_walk_enter(&ptp_state->unmatched_ht, &iter);	677	rhltable_walk_enter(&ptp_state->unmatched_ht, &iter);
706	rhashtable_walk_start(&iter);	678	rhashtable_walk_start(&iter);
707	while ((obj = rhashtable_walk_next(&iter))) {	679	while ((obj = rhashtable_walk_next(&iter))) {
708	if (IS_ERR(obj))	680	if (IS_ERR(obj))
@@ -855,8 +827,8 @@ struct mlxsw_sp_ptp_state mlxsw_sp1_ptp_init(struct mlxsw_sp mlxsw_sp) · 146 unmodified lines
855		827
856	spin_lock_init(&ptp_state->unmatched_lock);	828	spin_lock_init(&ptp_state->unmatched_lock);
857		829
858	err = rhashtable_init(&ptp_state->unmatched_ht,	830	err = rhltable_init(&ptp_state->unmatched_ht,
859	&mlxsw_sp1_ptp_unmatched_ht_params);	831	&mlxsw_sp1_ptp_unmatched_ht_params);
860	if (err)	832	if (err)
861	goto err_hashtable_init;	833	goto err_hashtable_init;
862		834
@@ -891,7 +863,7 @@ err_fifo_clr: · 28 unmodified lines
891	err_mtptpt1_set:	863	err_mtptpt1_set:
892	mlxsw_sp_ptp_mtptpt_set(mlxsw_sp, MLXSW_REG_MTPTPT_TRAP_ID_PTP0, 0);	864	mlxsw_sp_ptp_mtptpt_set(mlxsw_sp, MLXSW_REG_MTPTPT_TRAP_ID_PTP0, 0);
893	err_mtptpt_set:	865	err_mtptpt_set:
894	rhashtable_destroy(&ptp_state->unmatched_ht);	866	rhltable_destroy(&ptp_state->unmatched_ht);
895	err_hashtable_init:	867	err_hashtable_init:
896	kfree(ptp_state);	868	kfree(ptp_state);
897	return ERR_PTR(err);	869	return ERR_PTR(err);
@@ -906,8 +878,8 @@ void mlxsw_sp1_ptp_fini(struct mlxsw_sp_ptp_state *ptp_state) · 8 unmodified lines
906	mlxsw_sp1_ptp_set_fifo_clr_on_trap(mlxsw_sp, false);	878	mlxsw_sp1_ptp_set_fifo_clr_on_trap(mlxsw_sp, false);
907	mlxsw_sp_ptp_mtptpt_set(mlxsw_sp, MLXSW_REG_MTPTPT_TRAP_ID_PTP1, 0);	879	mlxsw_sp_ptp_mtptpt_set(mlxsw_sp, MLXSW_REG_MTPTPT_TRAP_ID_PTP1, 0);
908	mlxsw_sp_ptp_mtptpt_set(mlxsw_sp, MLXSW_REG_MTPTPT_TRAP_ID_PTP0, 0);	880	mlxsw_sp_ptp_mtptpt_set(mlxsw_sp, MLXSW_REG_MTPTPT_TRAP_ID_PTP0, 0);
909	rhashtable_free_and_destroy(&ptp_state->unmatched_ht,	881	rhltable_free_and_destroy(&ptp_state->unmatched_ht,
910	&mlxsw_sp1_ptp_unmatched_free_fn, NULL);	882	&mlxsw_sp1_ptp_unmatched_free_fn, NULL);
911	kfree(ptp_state);	883	kfree(ptp_state);
912	}	884	}
913		885

drivers/net/ethernet/mscc/ocelot_flower.c+3−9

 	struct ocelot_port *port;
 };
-static u16 get_prio(u32 prio)
-{
-	/* prio starts from 0x1000 while the ids starts from 0 */
-	return prio >> 16;
-}
 static int ocelot_flower_parse_action(struct flow_cls_offload *f,
 				      struct ocelot_ace_rule *rule)
 {
 	}
 finished_key_parsing:
-	ocelot_rule->prio = get_prio(f->common.prio);
+	ocelot_rule->prio = f->common.prio;
 	ocelot_rule->id = f->cookie;
 	return ocelot_flower_parse_action(f, ocelot_rule);
 }
 	struct ocelot_ace_rule rule;
 	int ret;
-	rule.prio = get_prio(f->common.prio);
+	rule.prio = f->common.prio;
 	rule.port = port_block->port;
 	rule.id = f->cookie;
 	struct ocelot_ace_rule rule;
 	int ret;
-	rule.prio = get_prio(f->common.prio);
+	rule.prio = f->common.prio;
 	rule.port = port_block->port;
 	rule.id = f->cookie;
 	ret = ocelot_ace_rule_stats_update(&rule);

drivers/net/ethernet/myricom/myri10ge/myri10ge.c+1−1

@@ -3918,7 +3918,7 @@ static int myri10ge_probe(struct pci_dev pdev, const struct pci_device_id ent) · 3917 unmodified lines
3918	* setup (if available). */	3918	* setup (if available). */
3919	status = myri10ge_request_irq(mgp);	3919	status = myri10ge_request_irq(mgp);
3920	if (status != 0)	3920	if (status != 0)
3921	goto abort_with_firmware;	3921	goto abort_with_slices;
3922	myri10ge_free_irq(mgp);	3922	myri10ge_free_irq(mgp);
3923		3923
3924	/* Save configuration space to be restored if the	3924	/* Save configuration space to be restored if the

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

@@ -93,7 +93,7 @@ nfp_flower_install_rate_limiter(struct nfp_app app, struct net_device netdev, · 92 unmodified lines
93	return -EOPNOTSUPP;	93	return -EOPNOTSUPP;
94	}	94	}
95		95
96	if (flow->common.prio != (1 << 16)) {	96	if (flow->common.prio != 1) {
97	NL_SET_ERR_MSG_MOD(extack, "unsupported offload: qos rate limit offload requires highest priority");	97	NL_SET_ERR_MSG_MOD(extack, "unsupported offload: qos rate limit offload requires highest priority");
98	return -EOPNOTSUPP;	98	return -EOPNOTSUPP;
99	}	99	}

drivers/net/ethernet/renesas/ravb_main.c+6−2

 // SPDX-License-Identifier: GPL-2.0
 /* Renesas Ethernet AVB device driver
  *
- * Copyright (C) 2014-2015 Renesas Electronics Corporation
+ * Copyright (C) 2014-2019 Renesas Electronics Corporation
  * Copyright (C) 2015 Renesas Solutions Corp.
  * Copyright (C) 2015-2016 Cogent Embedded, Inc. <source@cogentembedded.com>
  *
 			kfree(ts_skb);
 			if (tag == tfa_tag) {
 				skb_tstamp_tx(skb, &shhwtstamps);
+				dev_consume_skb_any(skb);
 				break;
+			} else {
+				dev_kfree_skb_any(skb);
 			}
 		}
 		ravb_modify(ndev, TCCR, TCCR_TFR, TCCR_TFR);
 			}
 			goto unmap;
 		}
-		ts_skb->skb = skb;
+		ts_skb->skb = skb_get(skb);
 		ts_skb->tag = priv->ts_skb_tag++;
 		priv->ts_skb_tag &= 0x3ff;
 		list_add_tail(&ts_skb->list, &priv->ts_skb_list);
 	/* Clear the timestamp list */
 	list_for_each_entry_safe(ts_skb, ts_skb2, &priv->ts_skb_list, list) {
 		list_del(&ts_skb->list);
+		kfree_skb(ts_skb->skb);
 		kfree(ts_skb);
 	}

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

@@ -94,7 +94,7 @@ static int tc_fill_entry(struct stmmac_priv *priv, · 93 unmodified lines
94	struct stmmac_tc_entry entry, frag = NULL;	94	struct stmmac_tc_entry entry, frag = NULL;
95	struct tc_u32_sel *sel = cls->knode.sel;	95	struct tc_u32_sel *sel = cls->knode.sel;
96	u32 off, data, mask, real_off, rem;	96	u32 off, data, mask, real_off, rem;
97	u32 prio = cls->common.prio;	97	u32 prio = cls->common.prio << 16;
98	int ret;	98	int ret;
99		99
100	/* Only 1 match per entry */	100	/* Only 1 match per entry */

drivers/net/ethernet/toshiba/tc35815.c+1−1

@@ -1504,7 +1504,7 @@ tc35815_rx(struct net_device *dev, int limit) · 1503 unmodified lines
1504	pci_unmap_single(lp->pci_dev,	1504	pci_unmap_single(lp->pci_dev,
1505	lp->rx_skbs[cur_bd].skb_dma,	1505	lp->rx_skbs[cur_bd].skb_dma,
1506	RX_BUF_SIZE, PCI_DMA_FROMDEVICE);	1506	RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
1507	if (!HAVE_DMA_RXALIGN(lp) && NET_IP_ALIGN)	1507	if (!HAVE_DMA_RXALIGN(lp) && NET_IP_ALIGN != 0)
1508	memmove(skb->data, skb->data - NET_IP_ALIGN,	1508	memmove(skb->data, skb->data - NET_IP_ALIGN,
1509	pkt_len);	1509	pkt_len);
1510	data = skb_put(skb, pkt_len);	1510	data = skb_put(skb, pkt_len);

drivers/net/ethernet/tundra/tsi108_eth.c+3−2

 static void tsi108_stat_carry(struct net_device *dev)
 {
 	struct tsi108_prv_data *data = netdev_priv(dev);
+	unsigned long flags;
 	u32 carry1, carry2;
-	spin_lock_irq(&data->misclock);
+	spin_lock_irqsave(&data->misclock, flags);
 	carry1 = TSI_READ(TSI108_STAT_CARRY1);
 	carry2 = TSI_READ(TSI108_STAT_CARRY2);
 			      TSI108_STAT_TXPAUSEDROP_CARRY,
 			      &data->tx_pause_drop);
-	spin_unlock_irq(&data->misclock);
+	spin_unlock_irqrestore(&data->misclock, flags);
 }
 /* Read a stat counter atomically with respect to carries.

drivers/net/hyperv/netvsc_drv.c+7−2

 			       struct rtnl_link_stats64 *t)
 {
 	struct net_device_context *ndev_ctx = netdev_priv(net);
-	struct netvsc_device *nvdev = rcu_dereference_rtnl(ndev_ctx->nvdev);
+	struct netvsc_device *nvdev;
 	struct netvsc_vf_pcpu_stats vf_tot;
 	int i;
+	rcu_read_lock();
+	nvdev = rcu_dereference(ndev_ctx->nvdev);
 	if (!nvdev)
-		return;
+		goto out;
 	netdev_stats_to_stats64(t, &net->stats);
 		t->rx_packets	+= packets;
 		t->multicast	+= multicast;
 	}
+out:
+	rcu_read_unlock();
 }
 static int netvsc_set_mac_addr(struct net_device *ndev, void *p)

drivers/net/netdevsim/dev.c+25−38

 	debugfs_remove_recursive(nsim_dev_port->ddir);
 }
+static struct net *nsim_devlink_net(struct devlink *devlink)
+{
+	return &init_net;
+}
 static u64 nsim_dev_ipv4_fib_resource_occ_get(void *priv)
 {
-	struct nsim_dev *nsim_dev = priv;
+	struct net *net = priv;
-	return nsim_fib_get_val(nsim_dev->fib_data,
+	return nsim_fib_get_val(net, NSIM_RESOURCE_IPV4_FIB, false);
-				NSIM_RESOURCE_IPV4_FIB, false);
 }
 static u64 nsim_dev_ipv4_fib_rules_res_occ_get(void *priv)
 {
-	struct nsim_dev *nsim_dev = priv;
+	struct net *net = priv;
-	return nsim_fib_get_val(nsim_dev->fib_data,
+	return nsim_fib_get_val(net, NSIM_RESOURCE_IPV4_FIB_RULES, false);
-				NSIM_RESOURCE_IPV4_FIB_RULES, false);
 }
 static u64 nsim_dev_ipv6_fib_resource_occ_get(void *priv)
 {
-	struct nsim_dev *nsim_dev = priv;
+	struct net *net = priv;
-	return nsim_fib_get_val(nsim_dev->fib_data,
+	return nsim_fib_get_val(net, NSIM_RESOURCE_IPV6_FIB, false);
-				NSIM_RESOURCE_IPV6_FIB, false);
 }
 static u64 nsim_dev_ipv6_fib_rules_res_occ_get(void *priv)
 {
-	struct nsim_dev *nsim_dev = priv;
+	struct net *net = priv;
-	return nsim_fib_get_val(nsim_dev->fib_data,
+	return nsim_fib_get_val(net, NSIM_RESOURCE_IPV6_FIB_RULES, false);
-				NSIM_RESOURCE_IPV6_FIB_RULES, false);
 }
 static int nsim_dev_resources_register(struct devlink *devlink)
 {
-	struct nsim_dev *nsim_dev = devlink_priv(devlink);
 	struct devlink_resource_size_params params = {
 		.size_max = (u64)-1,
 		.size_granularity = 1,
 		.unit = DEVLINK_RESOURCE_UNIT_ENTRY
 	};
+	struct net *net = nsim_devlink_net(devlink);
 	int err;
 	u64 n;
 		goto out;
 	}
-	n = nsim_fib_get_val(nsim_dev->fib_data,
+	n = nsim_fib_get_val(net, NSIM_RESOURCE_IPV4_FIB, true);
-			     NSIM_RESOURCE_IPV4_FIB, true);
 	err = devlink_resource_register(devlink, "fib", n,
 					NSIM_RESOURCE_IPV4_FIB,
 					NSIM_RESOURCE_IPV4, &params);
 		return err;
 	}
-	n = nsim_fib_get_val(nsim_dev->fib_data,
+	n = nsim_fib_get_val(net, NSIM_RESOURCE_IPV4_FIB_RULES, true);
-			     NSIM_RESOURCE_IPV4_FIB_RULES, true);
 	err = devlink_resource_register(devlink, "fib-rules", n,
 					NSIM_RESOURCE_IPV4_FIB_RULES,
 					NSIM_RESOURCE_IPV4, &params);
 		goto out;
 	}
-	n = nsim_fib_get_val(nsim_dev->fib_data,
+	n = nsim_fib_get_val(net, NSIM_RESOURCE_IPV6_FIB, true);
-			     NSIM_RESOURCE_IPV6_FIB, true);
 	err = devlink_resource_register(devlink, "fib", n,
 					NSIM_RESOURCE_IPV6_FIB,
 					NSIM_RESOURCE_IPV6, &params);
 		return err;
 	}
-	n = nsim_fib_get_val(nsim_dev->fib_data,
+	n = nsim_fib_get_val(net, NSIM_RESOURCE_IPV6_FIB_RULES, true);
-			     NSIM_RESOURCE_IPV6_FIB_RULES, true);
 	err = devlink_resource_register(devlink, "fib-rules", n,
 					NSIM_RESOURCE_IPV6_FIB_RULES,
 					NSIM_RESOURCE_IPV6, &params);
 	devlink_resource_occ_get_register(devlink,
 					  NSIM_RESOURCE_IPV4_FIB,
 					  nsim_dev_ipv4_fib_resource_occ_get,
-					  nsim_dev);
+					  net);
 	devlink_resource_occ_get_register(devlink,
 					  NSIM_RESOURCE_IPV4_FIB_RULES,
 					  nsim_dev_ipv4_fib_rules_res_occ_get,
-					  nsim_dev);
+					  net);
 	devlink_resource_occ_get_register(devlink,
 					  NSIM_RESOURCE_IPV6_FIB,
 					  nsim_dev_ipv6_fib_resource_occ_get,
-					  nsim_dev);
+					  net);
 	devlink_resource_occ_get_register(devlink,
 					  NSIM_RESOURCE_IPV6_FIB_RULES,
 					  nsim_dev_ipv6_fib_rules_res_occ_get,
-					  nsim_dev);
+					  net);
 out:
 	return err;
 }
 static int nsim_dev_reload(struct devlink *devlink,
 			   struct netlink_ext_ack *extack)
 {
-	struct nsim_dev *nsim_dev = devlink_priv(devlink);
 	enum nsim_resource_id res_ids[] = {
 		NSIM_RESOURCE_IPV4_FIB, NSIM_RESOURCE_IPV4_FIB_RULES,
 		NSIM_RESOURCE_IPV6_FIB, NSIM_RESOURCE_IPV6_FIB_RULES
 	};
+	struct net *net = nsim_devlink_net(devlink);
 	int i;
 	for (i = 0; i < ARRAY_SIZE(res_ids); ++i) {
 		err = devlink_resource_size_get(devlink, res_ids[i], &val);
 		if (!err) {
-			err = nsim_fib_set_max(nsim_dev->fib_data,
+			err = nsim_fib_set_max(net, res_ids[i], val, extack);
-					       res_ids[i], val, extack);
 			if (err)
 				return err;
 		}
 	nsim_dev->max_macs = NSIM_DEV_MAX_MACS_DEFAULT;
 	nsim_dev->test1 = NSIM_DEV_TEST1_DEFAULT;
-	nsim_dev->fib_data = nsim_fib_create();
-	if (IS_ERR(nsim_dev->fib_data)) {
-		err = PTR_ERR(nsim_dev->fib_data);
-		goto err_devlink_free;
-	}
 	err = nsim_dev_resources_register(devlink);
 	if (err)
-		goto err_fib_destroy;
+		goto err_devlink_free;
 	err = devlink_register(devlink, &nsim_bus_dev->dev);
 	if (err)
 	devlink_unregister(devlink);
 err_resources_unregister:
 	devlink_resources_unregister(devlink, NULL);
-err_fib_destroy:
-	nsim_fib_destroy(nsim_dev->fib_data);
 err_devlink_free:
 	devlink_free(devlink);
 	return ERR_PTR(err);
 				  ARRAY_SIZE(nsim_devlink_params));
 	devlink_unregister(devlink);
 	devlink_resources_unregister(devlink, NULL);
-	nsim_fib_destroy(nsim_dev->fib_data);
 	mutex_destroy(&nsim_dev->port_list_lock);
 	devlink_free(devlink);
 }

drivers/net/netdevsim/fib.c+61−41

@@ -18,6 +18,7 @@ · 17 unmodified lines
18	#include <net/ip_fib.h>	18	#include <net/ip_fib.h>
19	#include <net/ip6_fib.h>	19	#include <net/ip6_fib.h>
20	#include <net/fib_rules.h>	20	#include <net/fib_rules.h>
		21	#include <net/netns/generic.h>
21		22
22	#include "netdevsim.h"	23	#include "netdevsim.h"
23		24
@@ -32,14 +33,15 @@ struct nsim_per_fib_data { · 8 unmodified lines
32	};	33	};
33		34
34	struct nsim_fib_data {	35	struct nsim_fib_data {
35	struct notifier_block fib_nb;
36	struct nsim_per_fib_data ipv4;	36	struct nsim_per_fib_data ipv4;
37	struct nsim_per_fib_data ipv6;	37	struct nsim_per_fib_data ipv6;
38	};	38	};
39		39
40	u64 nsim_fib_get_val(struct nsim_fib_data *fib_data,	40	static unsigned int nsim_fib_net_id;
41	enum nsim_resource_id res_id, bool max)	41
		42	u64 nsim_fib_get_val(struct net *net, enum nsim_resource_id res_id, bool max)
42	{	43	{
		44	struct nsim_fib_data *fib_data = net_generic(net, nsim_fib_net_id);
43	struct nsim_fib_entry *entry;	45	struct nsim_fib_entry *entry;
44		46
45	switch (res_id) {	47	switch (res_id) {
@@ -62,10 +64,10 @@ u64 nsim_fib_get_val(struct nsim_fib_data *fib_data, · 16 unmodified lines
62	return max ? entry->max : entry->num;	64	return max ? entry->max : entry->num;
63	}	65	}
64		66
65	int nsim_fib_set_max(struct nsim_fib_data *fib_data,	67	int nsim_fib_set_max(struct net *net, enum nsim_resource_id res_id, u64 val,
66	enum nsim_resource_id res_id, u64 val,
67	struct netlink_ext_ack *extack)	68	struct netlink_ext_ack *extack)
68	{	69	{
		70	struct nsim_fib_data *fib_data = net_generic(net, nsim_fib_net_id);
69	struct nsim_fib_entry *entry;	71	struct nsim_fib_entry *entry;
70	int err = 0;	72	int err = 0;
71		73
@@ -118,9 +120,9 @@ static int nsim_fib_rule_account(struct nsim_fib_entry *entry, bool add, · 46 unmodified lines
118	return err;	120	return err;
119	}	121	}
120		122
121	static int nsim_fib_rule_event(struct nsim_fib_data *data,	123	static int nsim_fib_rule_event(struct fib_notifier_info *info, bool add)
122	struct fib_notifier_info *info, bool add)
123	{	124	{
		125	struct nsim_fib_data *data = net_generic(info->net, nsim_fib_net_id);
124	struct netlink_ext_ack *extack = info->extack;	126	struct netlink_ext_ack *extack = info->extack;
125	int err = 0;	127	int err = 0;
126		128
@@ -155,9 +157,9 @@ static int nsim_fib_account(struct nsim_fib_entry *entry, bool add, · 28 unmodified lines
155	return err;	157	return err;
156	}	158	}
157		159
158	static int nsim_fib_event(struct nsim_fib_data *data,	160	static int nsim_fib_event(struct fib_notifier_info *info, bool add)
159	struct fib_notifier_info *info, bool add)
160	{	161	{
		162	struct nsim_fib_data *data = net_generic(info->net, nsim_fib_net_id);
161	struct netlink_ext_ack *extack = info->extack;	163	struct netlink_ext_ack *extack = info->extack;
162	int err = 0;	164	int err = 0;
163		165
@@ -176,22 +178,18 @@ static int nsim_fib_event(struct nsim_fib_data *data, · 12 unmodified lines
176	static int nsim_fib_event_nb(struct notifier_block *nb, unsigned long event,	178	static int nsim_fib_event_nb(struct notifier_block *nb, unsigned long event,
177	void *ptr)	179	void *ptr)
178	{	180	{
179	struct nsim_fib_data *data = container_of(nb, struct nsim_fib_data,
180	fib_nb);
181	struct fib_notifier_info *info = ptr;	181	struct fib_notifier_info *info = ptr;
182	int err = 0;	182	int err = 0;
183		183
184	switch (event) {	184	switch (event) {
185	case FIB_EVENT_RULE_ADD: /* fall through */	185	case FIB_EVENT_RULE_ADD: /* fall through */
186	case FIB_EVENT_RULE_DEL:	186	case FIB_EVENT_RULE_DEL:
187	err = nsim_fib_rule_event(data, info,	187	err = nsim_fib_rule_event(info, event == FIB_EVENT_RULE_ADD);
188	event == FIB_EVENT_RULE_ADD);
189	break;	188	break;
190		189
191	case FIB_EVENT_ENTRY_ADD: /* fall through */	190	case FIB_EVENT_ENTRY_ADD: /* fall through */
192	case FIB_EVENT_ENTRY_DEL:	191	case FIB_EVENT_ENTRY_DEL:
193	err = nsim_fib_event(data, info,	192	err = nsim_fib_event(info, event == FIB_EVENT_ENTRY_ADD);
194	event == FIB_EVENT_ENTRY_ADD);
195	break;	193	break;
196	}	194	}
197		195
@@ -201,23 +199,30 @@ static int nsim_fib_event_nb(struct notifier_block *nb, unsigned long event, · 3 unmodified lines
201	/* inconsistent dump, trying again */	199	/* inconsistent dump, trying again */
202	static void nsim_fib_dump_inconsistent(struct notifier_block *nb)	200	static void nsim_fib_dump_inconsistent(struct notifier_block *nb)
203	{	201	{
204	struct nsim_fib_data *data = container_of(nb, struct nsim_fib_data,	202	struct nsim_fib_data *data;
205	fib_nb);	203	struct net *net;
		204
		205	rcu_read_lock();
		206	for_each_net_rcu(net) {
		207	data = net_generic(net, nsim_fib_net_id);
		208
		209	data->ipv4.fib.num = 0ULL;
		210	data->ipv4.rules.num = 0ULL;
206		211
207	data->ipv4.fib.num = 0ULL;	212	data->ipv6.fib.num = 0ULL;
208	data->ipv4.rules.num = 0ULL;	213	data->ipv6.rules.num = 0ULL;
209	data->ipv6.fib.num = 0ULL;	214	}
210	data->ipv6.rules.num = 0ULL;	215	rcu_read_unlock();
211	}	216	}
212		217
213	struct nsim_fib_data *nsim_fib_create(void)	218	static struct notifier_block nsim_fib_nb = {
214	{	219	.notifier_call = nsim_fib_event_nb,
215	struct nsim_fib_data *data;	220	};
216	int err;
217		221
218	data = kzalloc(sizeof(*data), GFP_KERNEL);	222	/* Initialize per network namespace state */
219	if (!data)	223	static int __net_init nsim_fib_netns_init(struct net *net)
220	return ERR_PTR(-ENOMEM);	224	{
		225	struct nsim_fib_data *data = net_generic(net, nsim_fib_net_id);
221		226
222	data->ipv4.fib.max = (u64)-1;	227	data->ipv4.fib.max = (u64)-1;
223	data->ipv4.rules.max = (u64)-1;	228	data->ipv4.rules.max = (u64)-1;
@@ -225,22 +230,37 @@ struct nsim_fib_data *nsim_fib_create(void) · 1 unmodified line
225	data->ipv6.fib.max = (u64)-1;	230	data->ipv6.fib.max = (u64)-1;
226	data->ipv6.rules.max = (u64)-1;	231	data->ipv6.rules.max = (u64)-1;
227		232
228	data->fib_nb.notifier_call = nsim_fib_event_nb;	233	return 0;
229	err = register_fib_notifier(&data->fib_nb, nsim_fib_dump_inconsistent);	234	}
230	if (err) {
231	pr_err("Failed to register fib notifier\n");
232	goto err_out;
233	}
234		235
235	return data;	236	static struct pernet_operations nsim_fib_net_ops = {
		237	.init = nsim_fib_netns_init,
		238	.id = &nsim_fib_net_id,
		239	.size = sizeof(struct nsim_fib_data),
		240	};
236		241
237	err_out:	242	void nsim_fib_exit(void)
238	kfree(data);	243	{
239	return ERR_PTR(err);	244	unregister_pernet_subsys(&nsim_fib_net_ops);
		245	unregister_fib_notifier(&nsim_fib_nb);
240	}	246	}
241		247
242	void nsim_fib_destroy(struct nsim_fib_data *data)	248	int nsim_fib_init(void)
243	{	249	{
244	unregister_fib_notifier(&data->fib_nb);	250	int err;
245	kfree(data);	251
		252	err = register_pernet_subsys(&nsim_fib_net_ops);
		253	if (err < 0) {
		254	pr_err("Failed to register pernet subsystem\n");
		255	goto err_out;
		256	}
		257
		258	err = register_fib_notifier(&nsim_fib_nb, nsim_fib_dump_inconsistent);
		259	if (err < 0) {
		260	pr_err("Failed to register fib notifier\n");
		261	goto err_out;
		262	}
		263
		264	err_out:
		265	return err;
246	}	266	}

drivers/net/netdevsim/netdev.c+8−1

 	if (err)
 		goto err_dev_exit;
-	err = rtnl_link_register(&nsim_link_ops);
+	err = nsim_fib_init();
 	if (err)
 		goto err_bus_exit;
+	err = rtnl_link_register(&nsim_link_ops);
+	if (err)
+		goto err_fib_exit;
 	return 0;
+err_fib_exit:
+	nsim_fib_exit();
 err_bus_exit:
 	nsim_bus_exit();
 err_dev_exit:
 static void __exit nsim_module_exit(void)
 {
 	rtnl_link_unregister(&nsim_link_ops);
+	nsim_fib_exit();
 	nsim_bus_exit();
 	nsim_dev_exit();
 }

drivers/net/netdevsim/netdevsim.h+4−6

 int nsim_dev_port_del(struct nsim_bus_dev *nsim_bus_dev,
 		      unsigned int port_index);
-struct nsim_fib_data *nsim_fib_create(void);
+int nsim_fib_init(void);
-void nsim_fib_destroy(struct nsim_fib_data *fib_data);
+void nsim_fib_exit(void);
-u64 nsim_fib_get_val(struct nsim_fib_data *fib_data,
+u64 nsim_fib_get_val(struct net *net, enum nsim_resource_id res_id, bool max);
-		     enum nsim_resource_id res_id, bool max);
+int nsim_fib_set_max(struct net *net, enum nsim_resource_id res_id, u64 val,
-int nsim_fib_set_max(struct nsim_fib_data *fib_data,
-		     enum nsim_resource_id res_id, u64 val,
 		     struct netlink_ext_ack *extack);
 #if IS_ENABLED(CONFIG_XFRM_OFFLOAD)

drivers/net/phy/at803x.c+8−24

 	 *   after HW reset: RX delay enabled and TX delay disabled
 	 *   after SW reset: RX delay enabled, while TX delay retains the
 	 *   value before reset.
-	 *
-	 * So let's first disable the RX and TX delays in PHY and enable
-	 * them based on the mode selected (this also takes care of RGMII
-	 * mode where we expect delays to be disabled)
 	 */
-	ret = at803x_disable_rx_delay(phydev);
-	if (ret < 0)
-		return ret;
-	ret = at803x_disable_tx_delay(phydev);
-	if (ret < 0)
-		return ret;
 	if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
-	    phydev->interface == PHY_INTERFACE_MODE_RGMII_RXID) {
+	    phydev->interface == PHY_INTERFACE_MODE_RGMII_RXID)
-		/* If RGMII_ID or RGMII_RXID are specified enable RX delay,
-		 * otherwise keep it disabled
-		 */
 		ret = at803x_enable_rx_delay(phydev);
-		if (ret < 0)
+	else
-			return ret;
+		ret = at803x_disable_rx_delay(phydev);
-	}
+	if (ret < 0)
+		return ret;
 	if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
-	    phydev->interface == PHY_INTERFACE_MODE_RGMII_TXID) {
+	    phydev->interface == PHY_INTERFACE_MODE_RGMII_TXID)
-		/* If RGMII_ID or RGMII_TXID are specified enable TX delay,
-		 * otherwise keep it disabled
-		 */
 		ret = at803x_enable_tx_delay(phydev);
-	}
+	else
+		ret = at803x_disable_tx_delay(phydev);
 	return ret;
 }

drivers/net/phy/phy-c45.c+14−0

@@ -219,6 +219,20 @@ int genphy_c45_read_link(struct phy_device *phydev) · 218 unmodified lines
219	int val, devad;	219	int val, devad;
220	bool link = true;	220	bool link = true;
221		221
		222	if (phydev->c45_ids.devices_in_package & MDIO_DEVS_AN) {
		223	val = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_CTRL1);
		224	if (val < 0)
		225	return val;
		226
		227	/* Autoneg is being started, therefore disregard current
		228	* link status and report link as down.
		229	*/
		230	if (val & MDIO_AN_CTRL1_RESTART) {
		231	phydev->link = 0;
		232	return 0;
		233	}
		234	}
		235
222	while (mmd_mask && link) {	236	while (mmd_mask && link) {
223	devad = __ffs(mmd_mask);	237	devad = __ffs(mmd_mask);
224	mmd_mask &= ~BIT(devad);	238	mmd_mask &= ~BIT(devad);

drivers/net/phy/phy_device.c+11−1

@@ -1741,7 +1741,17 @@ EXPORT_SYMBOL(genphy_aneg_done); · 1740 unmodified lines
1741	*/	1741	*/
1742	int genphy_update_link(struct phy_device *phydev)	1742	int genphy_update_link(struct phy_device *phydev)
1743	{	1743	{
1744	int status;	1744	int status = 0, bmcr;
		1745
		1746	bmcr = phy_read(phydev, MII_BMCR);
		1747	if (bmcr < 0)
		1748	return bmcr;
		1749
		1750	/* Autoneg is being started, therefore disregard BMSR value and
		1751	* report link as down.
		1752	*/
		1753	if (bmcr & BMCR_ANRESTART)
		1754	goto done;
1745		1755
1746	/* The link state is latched low so that momentary link	1756	/* The link state is latched low so that momentary link
1747	* drops can be detected. Do not double-read the status	1757	* drops can be detected. Do not double-read the status

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

@@ -1004,6 +1004,8 @@ static void __team_compute_features(struct team *team) · 1003 unmodified lines
1004		1004
1005	team->dev->vlan_features = vlan_features;	1005	team->dev->vlan_features = vlan_features;
1006	team->dev->hw_enc_features = enc_features \| NETIF_F_GSO_ENCAP_ALL \|	1006	team->dev->hw_enc_features = enc_features \| NETIF_F_GSO_ENCAP_ALL \|
		1007	NETIF_F_HW_VLAN_CTAG_TX \|
		1008	NETIF_F_HW_VLAN_STAG_TX \|
1007	NETIF_F_GSO_UDP_L4;	1009	NETIF_F_GSO_UDP_L4;
1008	team->dev->hard_header_len = max_hard_header_len;	1010	team->dev->hard_header_len = max_hard_header_len;
1009		1011

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

@@ -163,7 +163,8 @@ static int cx82310_bind(struct usbnet dev, struct usb_interface intf) · 162 unmodified lines
163	}	163	}
164	if (!timeout) {	164	if (!timeout) {
165	dev_err(&udev->dev, "firmware not ready in time\n");	165	dev_err(&udev->dev, "firmware not ready in time\n");
166	return -ETIMEDOUT;	166	ret = -ETIMEDOUT;
		167	goto err;
167	}	168	}
168		169
169	/* enable ethernet mode (?) */	170	/* enable ethernet mode (?) */

drivers/net/usb/kalmia.c+3−3

@@ -113,16 +113,16 @@ kalmia_init_and_get_ethernet_addr(struct usbnet dev, u8 ethernet_addr) · 112 unmodified lines
113	status = kalmia_send_init_packet(dev, usb_buf, ARRAY_SIZE(init_msg_1),	113	status = kalmia_send_init_packet(dev, usb_buf, ARRAY_SIZE(init_msg_1),
114	usb_buf, 24);	114	usb_buf, 24);
115	if (status != 0)	115	if (status != 0)
116	return status;	116	goto out;
117		117
118	memcpy(usb_buf, init_msg_2, 12);	118	memcpy(usb_buf, init_msg_2, 12);
119	status = kalmia_send_init_packet(dev, usb_buf, ARRAY_SIZE(init_msg_2),	119	status = kalmia_send_init_packet(dev, usb_buf, ARRAY_SIZE(init_msg_2),
120	usb_buf, 28);	120	usb_buf, 28);
121	if (status != 0)	121	if (status != 0)
122	return status;	122	goto out;
123		123
124	memcpy(ethernet_addr, usb_buf + 10, ETH_ALEN);	124	memcpy(ethernet_addr, usb_buf + 10, ETH_ALEN);
125		125	out:
126	kfree(usb_buf);	126	kfree(usb_buf);
127	return status;	127	return status;
128	}	128	}

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

 	ret = register_netdev(netdev);
 	if (ret != 0) {
 		netif_err(dev, probe, netdev, "couldn't register the device\n");
-		goto out3;
+		goto out4;
 	}
 	usb_set_intfdata(intf, dev);
 	ret = lan78xx_phy_init(dev);
 	if (ret < 0)
-		goto out4;
+		goto out5;
 	return 0;
-out4:
+out5:
 	unregister_netdev(netdev);
+out4:
+	usb_free_urb(dev->urb_intr);
 out3:
 	lan78xx_unbind(dev, intf);
 out2:

drivers/net/wimax/i2400m/fw.c+3−1

 			}
 			result = i2400m_barker_db_add(barker);
 			if (result < 0)
-				goto error_add;
+				goto error_parse_add;
 		}
 		kfree(options_orig);
 	}
 	return 0;
+error_parse_add:
 error_parse:
+	kfree(options_orig);
 error_add:
 	kfree(i2400m_barker_db);
 	return result;

drivers/net/xen-netback/netback.c+2−0

 			skb_shinfo(skb)->nr_frags = MAX_SKB_FRAGS;
 			nskb = xenvif_alloc_skb(0);
 			if (unlikely(nskb == NULL)) {
+				skb_shinfo(skb)->nr_frags = 0;
 				kfree_skb(skb);
 				xenvif_tx_err(queue, &txreq, extra_count, idx);
 				if (net_ratelimit())
 			if (xenvif_set_skb_gso(queue->vif, skb, gso)) {
 				/* Failure in xenvif_set_skb_gso is fatal. */
+				skb_shinfo(skb)->nr_frags = 0;
 				kfree_skb(skb);
 				kfree_skb(nskb);
 				break;

drivers/ntb/msi.c+0−5

 #include <linux/msi.h>
 #include <linux/pci.h>
-MODULE_LICENSE("Dual BSD/GPL");
-MODULE_VERSION("0.1");
-MODULE_AUTHOR("Logan Gunthorpe <logang@deltatee.com>");
-MODULE_DESCRIPTION("NTB MSI Interrupt Library");
 struct ntb_msi {
 	u64 base_addr;
 	u64 end_addr;

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

 	 */
 	if (effects & (NVME_CMD_EFFECTS_LBCC | NVME_CMD_EFFECTS_CSE_MASK)) {
 		mutex_lock(&ctrl->scan_lock);
+		mutex_lock(&ctrl->subsys->lock);
+		nvme_mpath_start_freeze(ctrl->subsys);
+		nvme_mpath_wait_freeze(ctrl->subsys);
 		nvme_start_freeze(ctrl);
 		nvme_wait_freeze(ctrl);
 	}
 		nvme_update_formats(ctrl);
 	if (effects & (NVME_CMD_EFFECTS_LBCC | NVME_CMD_EFFECTS_CSE_MASK)) {
 		nvme_unfreeze(ctrl);
+		nvme_mpath_unfreeze(ctrl->subsys);
+		mutex_unlock(&ctrl->subsys->lock);
 		mutex_unlock(&ctrl->scan_lock);
 	}
 	if (effects & NVME_CMD_EFFECTS_CCC)
 	if (ns->head->disk) {
 		nvme_update_disk_info(ns->head->disk, ns, id);
 		blk_queue_stack_limits(ns->head->disk->queue, ns->queue);
+		revalidate_disk(ns->head->disk);
 	}
 #endif
 }
 		if (ret) {
 			dev_err(ctrl->device,
 				"failed to register subsystem device.\n");
+			put_device(&subsys->dev);
 			goto out_unlock;
 		}
 		ida_init(&subsys->ns_ida);
 	nvme_put_subsystem(subsys);
 out_unlock:
 	mutex_unlock(&nvme_subsystems_lock);
-	put_device(&subsys->dev);
 	return ret;
 }
 	struct nvme_ns *ns, *next;
 	LIST_HEAD(ns_list);
+	/*
+	 * make sure to requeue I/O to all namespaces as these
+	 * might result from the scan itself and must complete
+	 * for the scan_work to make progress
+	 */
+	nvme_mpath_clear_ctrl_paths(ctrl);
 	/* prevent racing with ns scanning */
 	flush_work(&ctrl->scan_work);

drivers/nvme/host/multipath.c+70−6

@@ -12,6 +12,36 @@ module_param(multipath, bool, 0444); · 11 unmodified lines
12	MODULE_PARM_DESC(multipath,	12	MODULE_PARM_DESC(multipath,
13	"turn on native support for multiple controllers per subsystem");	13	"turn on native support for multiple controllers per subsystem");
14		14
		15	void nvme_mpath_unfreeze(struct nvme_subsystem *subsys)
		16	{
		17	struct nvme_ns_head *h;
		18
		19	lockdep_assert_held(&subsys->lock);
		20	list_for_each_entry(h, &subsys->nsheads, entry)
		21	if (h->disk)
		22	blk_mq_unfreeze_queue(h->disk->queue);
		23	}
		24
		25	void nvme_mpath_wait_freeze(struct nvme_subsystem *subsys)
		26	{
		27	struct nvme_ns_head *h;
		28
		29	lockdep_assert_held(&subsys->lock);
		30	list_for_each_entry(h, &subsys->nsheads, entry)
		31	if (h->disk)
		32	blk_mq_freeze_queue_wait(h->disk->queue);
		33	}
		34
		35	void nvme_mpath_start_freeze(struct nvme_subsystem *subsys)
		36	{
		37	struct nvme_ns_head *h;
		38
		39	lockdep_assert_held(&subsys->lock);
		40	list_for_each_entry(h, &subsys->nsheads, entry)
		41	if (h->disk)
		42	blk_freeze_queue_start(h->disk->queue);
		43	}
		44
15	/*	45	/*
16	* If multipathing is enabled we need to always use the subsystem instance	46	* If multipathing is enabled we need to always use the subsystem instance
17	* number for numbering our devices to avoid conflicts between subsystems that	47	* number for numbering our devices to avoid conflicts between subsystems that
@@ -104,18 +134,34 @@ static const char *nvme_ana_state_names[] = { · 86 unmodified lines
104	[NVME_ANA_CHANGE] = "change",	134	[NVME_ANA_CHANGE] = "change",
105	};	135	};
106		136
107	void nvme_mpath_clear_current_path(struct nvme_ns *ns)	137	bool nvme_mpath_clear_current_path(struct nvme_ns *ns)
108	{	138	{
109	struct nvme_ns_head *head = ns->head;	139	struct nvme_ns_head *head = ns->head;
		140	bool changed = false;
110	int node;	141	int node;
111		142
112	if (!head)	143	if (!head)
113	return;	144	goto out;
114		145
115	for_each_node(node) {	146	for_each_node(node) {
116	if (ns == rcu_access_pointer(head->current_path[node]))	147	if (ns == rcu_access_pointer(head->current_path[node])) {
117	rcu_assign_pointer(head->current_path[node], NULL);	148	rcu_assign_pointer(head->current_path[node], NULL);
		149	changed = true;
		150	}
118	}	151	}
		152	out:
		153	return changed;
		154	}
		155
		156	void nvme_mpath_clear_ctrl_paths(struct nvme_ctrl *ctrl)
		157	{
		158	struct nvme_ns *ns;
		159
		160	mutex_lock(&ctrl->scan_lock);
		161	list_for_each_entry(ns, &ctrl->namespaces, list)
		162	if (nvme_mpath_clear_current_path(ns))
		163	kblockd_schedule_work(&ns->head->requeue_work);
		164	mutex_unlock(&ctrl->scan_lock);
119	}	165	}
120		166
121	static bool nvme_path_is_disabled(struct nvme_ns *ns)	167	static bool nvme_path_is_disabled(struct nvme_ns *ns)
@@ -226,6 +272,24 @@ inline struct nvme_ns nvme_find_path(struct nvme_ns_head head) · 104 unmodified lines
226	return ns;	272	return ns;
227	}	273	}
228		274
		275	static bool nvme_available_path(struct nvme_ns_head *head)
		276	{
		277	struct nvme_ns *ns;
		278
		279	list_for_each_entry_rcu(ns, &head->list, siblings) {
		280	switch (ns->ctrl->state) {
		281	case NVME_CTRL_LIVE:
		282	case NVME_CTRL_RESETTING:
		283	case NVME_CTRL_CONNECTING:
		284	/* fallthru */
		285	return true;
		286	default:
		287	break;
		288	}
		289	}
		290	return false;
		291	}
		292
229	static blk_qc_t nvme_ns_head_make_request(struct request_queue *q,	293	static blk_qc_t nvme_ns_head_make_request(struct request_queue *q,
230	struct bio *bio)	294	struct bio *bio)
231	{	295	{
@@ -252,14 +316,14 @@ static blk_qc_t nvme_ns_head_make_request(struct request_queue *q, · 20 unmodified lines
252	disk_devt(ns->head->disk),	316	disk_devt(ns->head->disk),
253	bio->bi_iter.bi_sector);	317	bio->bi_iter.bi_sector);
254	ret = direct_make_request(bio);	318	ret = direct_make_request(bio);
255	} else if (!list_empty_careful(&head->list)) {	319	} else if (nvme_available_path(head)) {
256	dev_warn_ratelimited(dev, "no path available - requeuing I/O\n");	320	dev_warn_ratelimited(dev, "no usable path - requeuing I/O\n");
257		321
258	spin_lock_irq(&head->requeue_lock);	322	spin_lock_irq(&head->requeue_lock);
259	bio_list_add(&head->requeue_list, bio);	323	bio_list_add(&head->requeue_list, bio);
260	spin_unlock_irq(&head->requeue_lock);	324	spin_unlock_irq(&head->requeue_lock);
261	} else {	325	} else {
262	dev_warn_ratelimited(dev, "no path - failing I/O\n");	326	dev_warn_ratelimited(dev, "no available path - failing I/O\n");
263		327
264	bio->bi_status = BLK_STS_IOERR;	328	bio->bi_status = BLK_STS_IOERR;
265	bio_endio(bio);	329	bio_endio(bio);

drivers/nvme/host/nvme.h+19−2

 	return ctrl->ana_log_buf != NULL;
 }
+void nvme_mpath_unfreeze(struct nvme_subsystem *subsys);
+void nvme_mpath_wait_freeze(struct nvme_subsystem *subsys);
+void nvme_mpath_start_freeze(struct nvme_subsystem *subsys);
 void nvme_set_disk_name(char *disk_name, struct nvme_ns *ns,
 			struct nvme_ctrl *ctrl, int *flags);
 void nvme_failover_req(struct request *req);
 int nvme_mpath_init(struct nvme_ctrl *ctrl, struct nvme_id_ctrl *id);
 void nvme_mpath_uninit(struct nvme_ctrl *ctrl);
 void nvme_mpath_stop(struct nvme_ctrl *ctrl);
-void nvme_mpath_clear_current_path(struct nvme_ns *ns);
+bool nvme_mpath_clear_current_path(struct nvme_ns *ns);
+void nvme_mpath_clear_ctrl_paths(struct nvme_ctrl *ctrl);
 struct nvme_ns *nvme_find_path(struct nvme_ns_head *head);
 static inline void nvme_mpath_check_last_path(struct nvme_ns *ns)
 static inline void nvme_mpath_remove_disk(struct nvme_ns_head *head)
 {
 }
-static inline void nvme_mpath_clear_current_path(struct nvme_ns *ns)
+static inline bool nvme_mpath_clear_current_path(struct nvme_ns *ns)
+{
+	return false;
+}
+static inline void nvme_mpath_clear_ctrl_paths(struct nvme_ctrl *ctrl)
 {
 }
 static inline void nvme_mpath_check_last_path(struct nvme_ns *ns)
 static inline void nvme_mpath_stop(struct nvme_ctrl *ctrl)
 {
 }
+static inline void nvme_mpath_unfreeze(struct nvme_subsystem *subsys)
+{
+}
+static inline void nvme_mpath_wait_freeze(struct nvme_subsystem *subsys)
+{
+}
+static inline void nvme_mpath_start_freeze(struct nvme_subsystem *subsys)
+{
+}
 #endif /* CONFIG_NVME_MULTIPATH */
 #ifdef CONFIG_NVM

drivers/nvme/host/pci.c+12−4

 {
 	struct nvme_dev *dev = data;
-	nvme_reset_ctrl_sync(&dev->ctrl);
+	flush_work(&dev->ctrl.reset_work);
 	flush_work(&dev->ctrl.scan_work);
 	nvme_put_ctrl(&dev->ctrl);
 }
 	dev_info(dev->ctrl.device, "pci function %s\n", dev_name(&pdev->dev));
+	nvme_reset_ctrl(&dev->ctrl);
 	nvme_get_ctrl(&dev->ctrl);
 	async_schedule(nvme_async_probe, dev);
 	struct nvme_dev *ndev = pci_get_drvdata(to_pci_dev(dev));
 	struct nvme_ctrl *ctrl = &ndev->ctrl;
-	if (pm_resume_via_firmware() || !ctrl->npss ||
+	if (ndev->last_ps == U32_MAX ||
 	    nvme_set_power_state(ctrl, ndev->last_ps) != 0)
 		nvme_reset_ctrl(ctrl);
 	return 0;
 	struct nvme_ctrl *ctrl = &ndev->ctrl;
 	int ret = -EBUSY;
+	ndev->last_ps = U32_MAX;
 	/*
 	 * The platform does not remove power for a kernel managed suspend so
 	 * use host managed nvme power settings for lowest idle power if
 	 * shutdown.  But if the firmware is involved after the suspend or the
 	 * device does not support any non-default power states, shut down the
 	 * device fully.
+	 *
+	 * If ASPM is not enabled for the device, shut down the device and allow
+	 * the PCI bus layer to put it into D3 in order to take the PCIe link
+	 * down, so as to allow the platform to achieve its minimum low-power
+	 * state (which may not be possible if the link is up).
 	 */
-	if (pm_suspend_via_firmware() || !ctrl->npss) {
+	if (pm_suspend_via_firmware() || !ctrl->npss ||
+	    !pcie_aspm_enabled(pdev)) {
 		nvme_dev_disable(ndev, true);
 		return 0;
 	}
 	    ctrl->state != NVME_CTRL_ADMIN_ONLY)
 		goto unfreeze;
-	ndev->last_ps = 0;
 	ret = nvme_get_power_state(ctrl, &ndev->last_ps);
 	if (ret < 0)
 		goto unfreeze;

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

@@ -562,13 +562,17 @@ out_destroy_cm_id: · 561 unmodified lines
562	return ret;	562	return ret;
563	}	563	}
564		564
		565	static void __nvme_rdma_stop_queue(struct nvme_rdma_queue *queue)
		566	{
		567	rdma_disconnect(queue->cm_id);
		568	ib_drain_qp(queue->qp);
		569	}
		570
565	static void nvme_rdma_stop_queue(struct nvme_rdma_queue *queue)	571	static void nvme_rdma_stop_queue(struct nvme_rdma_queue *queue)
566	{	572	{
567	if (!test_and_clear_bit(NVME_RDMA_Q_LIVE, &queue->flags))	573	if (!test_and_clear_bit(NVME_RDMA_Q_LIVE, &queue->flags))
568	return;	574	return;
569		575	__nvme_rdma_stop_queue(queue);
570	rdma_disconnect(queue->cm_id);
571	ib_drain_qp(queue->qp);
572	}	576	}
573		577
574	static void nvme_rdma_free_queue(struct nvme_rdma_queue *queue)	578	static void nvme_rdma_free_queue(struct nvme_rdma_queue *queue)
@@ -607,11 +611,13 @@ static int nvme_rdma_start_queue(struct nvme_rdma_ctrl *ctrl, int idx) · 32 unmodified lines
607	else	611	else
608	ret = nvmf_connect_admin_queue(&ctrl->ctrl);	612	ret = nvmf_connect_admin_queue(&ctrl->ctrl);
609		613
610	if (!ret)	614	if (!ret) {
611	set_bit(NVME_RDMA_Q_LIVE, &queue->flags);	615	set_bit(NVME_RDMA_Q_LIVE, &queue->flags);
612	else	616	} else {
		617	__nvme_rdma_stop_queue(queue);
613	dev_info(ctrl->ctrl.device,	618	dev_info(ctrl->ctrl.device,
614	"failed to connect queue: %d ret=%d\n", idx, ret);	619	"failed to connect queue: %d ret=%d\n", idx, ret);
		620	}
615	return ret;	621	return ret;
616	}	622	}
617		623

drivers/nvme/target/configfs.c+1−0

@@ -675,6 +675,7 @@ static void nvmet_port_subsys_drop_link(struct config_item *parent, · 674 unmodified lines
675		675
676	found:	676	found:
677	list_del(&p->entry);	677	list_del(&p->entry);
		678	nvmet_port_del_ctrls(port, subsys);
678	nvmet_port_disc_changed(port, subsys);	679	nvmet_port_disc_changed(port, subsys);
679		680
680	if (list_empty(&port->subsystems))	681	if (list_empty(&port->subsystems))

drivers/nvme/target/core.c+15−0

@@ -46,6 +46,9 @@ inline u16 errno_to_nvme_status(struct nvmet_req *req, int errno) · 45 unmodified lines
46	u16 status;	46	u16 status;
47		47
48	switch (errno) {	48	switch (errno) {
		49	case 0:
		50	status = NVME_SC_SUCCESS;
		51	break;
49	case -ENOSPC:	52	case -ENOSPC:
50	req->error_loc = offsetof(struct nvme_rw_command, length);	53	req->error_loc = offsetof(struct nvme_rw_command, length);
51	status = NVME_SC_CAP_EXCEEDED \| NVME_SC_DNR;	54	status = NVME_SC_CAP_EXCEEDED \| NVME_SC_DNR;
@@ -280,6 +283,18 @@ void nvmet_unregister_transport(const struct nvmet_fabrics_ops *ops) · 228 unmodified lines
280	}	283	}
281	EXPORT_SYMBOL_GPL(nvmet_unregister_transport);	284	EXPORT_SYMBOL_GPL(nvmet_unregister_transport);
282		285
		286	void nvmet_port_del_ctrls(struct nvmet_port port, struct nvmet_subsys subsys)
		287	{
		288	struct nvmet_ctrl *ctrl;
		289
		290	mutex_lock(&subsys->lock);
		291	list_for_each_entry(ctrl, &subsys->ctrls, subsys_entry) {
		292	if (ctrl->port == port)
		293	ctrl->ops->delete_ctrl(ctrl);
		294	}
		295	mutex_unlock(&subsys->lock);
		296	}
		297
283	int nvmet_enable_port(struct nvmet_port *port)	298	int nvmet_enable_port(struct nvmet_port *port)
284	{	299	{
285	const struct nvmet_fabrics_ops *ops;	300	const struct nvmet_fabrics_ops *ops;

drivers/nvme/target/loop.c+8−0

@@ -654,6 +654,14 @@ static void nvme_loop_remove_port(struct nvmet_port *port) · 653 unmodified lines
654	mutex_lock(&nvme_loop_ports_mutex);	654	mutex_lock(&nvme_loop_ports_mutex);
655	list_del_init(&port->entry);	655	list_del_init(&port->entry);
656	mutex_unlock(&nvme_loop_ports_mutex);	656	mutex_unlock(&nvme_loop_ports_mutex);
		657
		658	/*
		659	* Ensure any ctrls that are in the process of being
		660	* deleted are in fact deleted before we return
		661	* and free the port. This is to prevent active
		662	* ctrls from using a port after it's freed.
		663	*/
		664	flush_workqueue(nvme_delete_wq);
657	}	665	}
658		666
659	static const struct nvmet_fabrics_ops nvme_loop_ops = {	667	static const struct nvmet_fabrics_ops nvme_loop_ops = {

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

@@ -418,6 +418,9 @@ void nvmet_port_send_ana_event(struct nvmet_port *port); · 417 unmodified lines
418	int nvmet_register_transport(const struct nvmet_fabrics_ops *ops);	418	int nvmet_register_transport(const struct nvmet_fabrics_ops *ops);
419	void nvmet_unregister_transport(const struct nvmet_fabrics_ops *ops);	419	void nvmet_unregister_transport(const struct nvmet_fabrics_ops *ops);
420		420
		421	void nvmet_port_del_ctrls(struct nvmet_port *port,
		422	struct nvmet_subsys *subsys);
		423
421	int nvmet_enable_port(struct nvmet_port *port);	424	int nvmet_enable_port(struct nvmet_port *port);
422	void nvmet_disable_port(struct nvmet_port *port);	425	void nvmet_disable_port(struct nvmet_port *port);
423		426

drivers/nvmem/nvmem-sysfs.c+11−4

 	if (!config->base_dev)
 		return -EINVAL;
-	if (nvmem->read_only)
+	if (nvmem->read_only) {
-		nvmem->eeprom = bin_attr_ro_root_nvmem;
+		if (config->root_only)
-	else
+			nvmem->eeprom = bin_attr_ro_root_nvmem;
-		nvmem->eeprom = bin_attr_rw_root_nvmem;
+		else
+			nvmem->eeprom = bin_attr_ro_nvmem;
+	} else {
+		if (config->root_only)
+			nvmem->eeprom = bin_attr_rw_root_nvmem;
+		else
+			nvmem->eeprom = bin_attr_rw_nvmem;
+	}
 	nvmem->eeprom.attr.name = "eeprom";
 	nvmem->eeprom.size = nvmem->size;
 #ifdef CONFIG_DEBUG_LOCK_ALLOC

drivers/of/irq.c+1−1

@@ -277,7 +277,7 @@ EXPORT_SYMBOL_GPL(of_irq_parse_raw); · 276 unmodified lines
277	* of_irq_parse_one - Resolve an interrupt for a device	277	* of_irq_parse_one - Resolve an interrupt for a device
278	* @device: the device whose interrupt is to be resolved	278	* @device: the device whose interrupt is to be resolved
279	* @index: index of the interrupt to resolve	279	* @index: index of the interrupt to resolve
280	* @out_irq: structure of_irq filled by this function	280	* @out_irq: structure of_phandle_args filled by this function
281	*	281	*
282	* This function resolves an interrupt for a node by walking the interrupt tree,	282	* This function resolves an interrupt for a node by walking the interrupt tree,
283	* finding which interrupt controller node it is attached to, and returning the	283	* finding which interrupt controller node it is attached to, and returning the

drivers/of/resolver.c+9−3

 	for_each_child_of_node(local_fixups, child) {
 		for_each_child_of_node(overlay, overlay_child)
-			if (!node_name_cmp(child, overlay_child))
+			if (!node_name_cmp(child, overlay_child)) {
+				of_node_put(overlay_child);
 				break;
+			}
-		if (!overlay_child)
+		if (!overlay_child) {
+			of_node_put(child);
 			return -EINVAL;
+		}
 		err = adjust_local_phandle_references(child, overlay_child,
 				phandle_delta);
-		if (err)
+		if (err) {
+			of_node_put(child);
 			return err;
+		}
 	}
 	return 0;

drivers/pci/pci.c+10−19

 	if (state == PCI_D0) {
 		pci_platform_power_transition(dev, PCI_D0);
 		/*
-		 * Mandatory power management transition delays are
+		 * Mandatory power management transition delays, see
-		 * handled in the PCIe portdrv resume hooks.
+		 * PCI Express Base Specification Revision 2.0 Section
+		 * 6.6.1: Conventional Reset.  Do not delay for
+		 * devices powered on/off by corresponding bridge,
+		 * because have already delayed for the bridge.
 		 */
 		if (dev->runtime_d3cold) {
+			if (dev->d3cold_delay && !dev->imm_ready)
+				msleep(dev->d3cold_delay);
 			/*
 			 * When powering on a bridge from D3cold, the
 			 * whole hierarchy may be powered on into
 	return pci_dev_wait(dev, "PM D3->D0", PCIE_RESET_READY_POLL_MS);
 }
 /**
- * pcie_wait_for_link_delay - Wait until link is active or inactive
+ * pcie_wait_for_link - Wait until link is active or inactive
  * @pdev: Bridge device
  * @active: waiting for active or inactive?
- * @delay: Delay to wait after link has become active (in ms)
  *
  * Use this to wait till link becomes active or inactive.
  */
-bool pcie_wait_for_link_delay(struct pci_dev *pdev, bool active, int delay)
+bool pcie_wait_for_link(struct pci_dev *pdev, bool active)
 {
 	int timeout = 1000;
 	bool ret;
 		timeout -= 10;
 	}
 	if (active && ret)
-		msleep(delay);
+		msleep(100);
 	else if (ret != active)
 		pci_info(pdev, "Data Link Layer Link Active not %s in 1000 msec\n",
 			active ? "set" : "cleared");
 	return ret == active;
 }
-/**
- * pcie_wait_for_link - Wait until link is active or inactive
- * @pdev: Bridge device
- * @active: waiting for active or inactive?
- *
- * Use this to wait till link becomes active or inactive.
- */
-bool pcie_wait_for_link(struct pci_dev *pdev, bool active)
-{
-	return pcie_wait_for_link_delay(pdev, active, 100);
-}
 void pci_reset_secondary_bus(struct pci_dev *dev)
 {
 	u16 ctrl;

drivers/pci/pci.h+0−1

@@ -497,7 +497,6 @@ static inline int pci_dev_specific_disable_acs_redir(struct pci_dev *dev) · 496 unmodified lines
497	void pcie_do_recovery(struct pci_dev *dev, enum pci_channel_state state,	497	void pcie_do_recovery(struct pci_dev *dev, enum pci_channel_state state,
498	u32 service);	498	u32 service);
499		499
500	bool pcie_wait_for_link_delay(struct pci_dev *pdev, bool active, int delay);
501	bool pcie_wait_for_link(struct pci_dev *pdev, bool active);	500	bool pcie_wait_for_link(struct pci_dev *pdev, bool active);
502	#ifdef CONFIG_PCIEASPM	501	#ifdef CONFIG_PCIEASPM
503	void pcie_aspm_init_link_state(struct pci_dev *pdev);	502	void pcie_aspm_init_link_state(struct pci_dev *pdev);

drivers/pci/pcie/aspm.c+20−0

@@ -1170,6 +1170,26 @@ static int pcie_aspm_get_policy(char buffer, const struct kernel_param kp) · 1169 unmodified lines
1170	module_param_call(policy, pcie_aspm_set_policy, pcie_aspm_get_policy,	1170	module_param_call(policy, pcie_aspm_set_policy, pcie_aspm_get_policy,
1171	NULL, 0644);	1171	NULL, 0644);
1172		1172
		1173	/**
		1174	* pcie_aspm_enabled - Check if PCIe ASPM has been enabled for a device.
		1175	* @pdev: Target device.
		1176	*/
		1177	bool pcie_aspm_enabled(struct pci_dev *pdev)
		1178	{
		1179	struct pci_dev *bridge = pci_upstream_bridge(pdev);
		1180	bool ret;
		1181
		1182	if (!bridge)
		1183	return false;
		1184
		1185	mutex_lock(&aspm_lock);
		1186	ret = bridge->link_state ? !!bridge->link_state->aspm_enabled : false;
		1187	mutex_unlock(&aspm_lock);
		1188
		1189	return ret;
		1190	}
		1191	EXPORT_SYMBOL_GPL(pcie_aspm_enabled);
		1192
1173	#ifdef CONFIG_PCIEASPM_DEBUG	1193	#ifdef CONFIG_PCIEASPM_DEBUG
1174	static ssize_t link_state_show(struct device *dev,	1194	static ssize_t link_state_show(struct device *dev,
1175	struct device_attribute *attr,	1195	struct device_attribute *attr,

drivers/pci/pcie/portdrv_core.c+0−66

@@ -9,7 +9,6 @@ · 8 unmodified lines
9	#include <linux/module.h>	9	#include <linux/module.h>
10	#include <linux/pci.h>	10	#include <linux/pci.h>
11	#include <linux/kernel.h>	11	#include <linux/kernel.h>
12	#include <linux/delay.h>
13	#include <linux/errno.h>	12	#include <linux/errno.h>
14	#include <linux/pm.h>	13	#include <linux/pm.h>
15	#include <linux/pm_runtime.h>	14	#include <linux/pm_runtime.h>
@@ -379,67 +378,6 @@ static int pm_iter(struct device dev, void data) · 363 unmodified lines
379	return 0;	378	return 0;
380	}	379	}
381		380
382	static int get_downstream_delay(struct pci_bus *bus)
383	{
384	struct pci_dev *pdev;
385	int min_delay = 100;
386	int max_delay = 0;
387
388	list_for_each_entry(pdev, &bus->devices, bus_list) {
389	if (!pdev->imm_ready)
390	min_delay = 0;
391	else if (pdev->d3cold_delay < min_delay)
392	min_delay = pdev->d3cold_delay;
393	if (pdev->d3cold_delay > max_delay)
394	max_delay = pdev->d3cold_delay;
395	}
396
397	return max(min_delay, max_delay);
398	}
399
400	/*
401	* wait_for_downstream_link - Wait for downstream link to establish
402	* @pdev: PCIe port whose downstream link is waited
403	*
404	* Handle delays according to PCIe 4.0 section 6.6.1 before configuration
405	* access to the downstream component is permitted.
406	*
407	* This blocks PCI core resume of the hierarchy below this port until the
408	* link is trained. Should be called before resuming port services to
409	* prevent pciehp from starting to tear-down the hierarchy too soon.
410	*/
411	static void wait_for_downstream_link(struct pci_dev *pdev)
412	{
413	int delay;
414
415	if (pci_pcie_type(pdev) != PCI_EXP_TYPE_ROOT_PORT &&
416	pci_pcie_type(pdev) != PCI_EXP_TYPE_DOWNSTREAM)
417	return;
418
419	if (pci_dev_is_disconnected(pdev))
420	return;
421
422	if (!pdev->subordinate \|\| list_empty(&pdev->subordinate->devices) \|\|
423	!pdev->bridge_d3)
424	return;
425
426	delay = get_downstream_delay(pdev->subordinate);
427	if (!delay)
428	return;
429
430	dev_dbg(&pdev->dev, "waiting downstream link for %d ms\n", delay);
431
432	/*
433	* If downstream port does not support speeds greater than 5 GT/s
434	* need to wait 100ms. For higher speeds (gen3) we need to wait
435	* first for the data link layer to become active.
436	*/
437	if (pcie_get_speed_cap(pdev) <= PCIE_SPEED_5_0GT)
438	msleep(delay);
439	else
440	pcie_wait_for_link_delay(pdev, true, delay);
441	}
442
443	/**	381	/**
444	* pcie_port_device_suspend - suspend port services associated with a PCIe port	382	* pcie_port_device_suspend - suspend port services associated with a PCIe port
445	* @dev: PCI Express port to handle	383	* @dev: PCI Express port to handle
@@ -453,8 +391,6 @@ int pcie_port_device_suspend(struct device *dev) · 7 unmodified lines
453	int pcie_port_device_resume_noirq(struct device *dev)	391	int pcie_port_device_resume_noirq(struct device *dev)
454	{	392	{
455	size_t off = offsetof(struct pcie_port_service_driver, resume_noirq);	393	size_t off = offsetof(struct pcie_port_service_driver, resume_noirq);
456
457	wait_for_downstream_link(to_pci_dev(dev));
458	return device_for_each_child(dev, &off, pm_iter);	394	return device_for_each_child(dev, &off, pm_iter);
459	}	395	}
460		396
@@ -485,8 +421,6 @@ int pcie_port_device_runtime_suspend(struct device *dev) · 24 unmodified lines
485	int pcie_port_device_runtime_resume(struct device *dev)	421	int pcie_port_device_runtime_resume(struct device *dev)
486	{	422	{
487	size_t off = offsetof(struct pcie_port_service_driver, runtime_resume);	423	size_t off = offsetof(struct pcie_port_service_driver, runtime_resume);
488
489	wait_for_downstream_link(to_pci_dev(dev));
490	return device_for_each_child(dev, &off, pm_iter);	424	return device_for_each_child(dev, &off, pm_iter);
491	}	425	}
492	#endif /* PM */	426	#endif /* PM */

drivers/pcmcia/db1xxx_ss.c+4−0

 	switch (state->Vcc) {
 	case 50:
 		++v;
+		/* fall through */
 	case 33:
 		++v;
+		/* fall through */
 	case 0:
 		break;
 	default:
 	switch (state->Vpp) {
 	case 12:
 		++p;
+		/* fall through */
 	case 33:
 	case 50:
 		++p;
+		/* fall through */
 	case 0:
 		break;
 	default:

drivers/pinctrl/aspeed/pinctrl-aspeed-g4.c+1−1

@@ -2412,7 +2412,7 @@ static const struct aspeed_pin_config aspeed_g4_configs[] = { · 2411 unmodified lines
2412	{ PIN_CONFIG_INPUT_DEBOUNCE, { C14, B14 }, SCUA8, 27 },	2412	{ PIN_CONFIG_INPUT_DEBOUNCE, { C14, B14 }, SCUA8, 27 },
2413	};	2413	};
2414		2414
2415	static int aspeed_g4_sig_expr_set(const struct aspeed_pinmux_data *ctx,	2415	static int aspeed_g4_sig_expr_set(struct aspeed_pinmux_data *ctx,
2416	const struct aspeed_sig_expr *expr,	2416	const struct aspeed_sig_expr *expr,
2417	bool enable)	2417	bool enable)
2418	{	2418	{

drivers/pinctrl/aspeed/pinctrl-aspeed-g5.c+65−27

@@ -2507,6 +2507,61 @@ static struct aspeed_pin_config aspeed_g5_configs[] = { · 2506 unmodified lines
2507	{ PIN_CONFIG_INPUT_DEBOUNCE, { A20, B19 }, SCUA8, 27 },	2507	{ PIN_CONFIG_INPUT_DEBOUNCE, { A20, B19 }, SCUA8, 27 },
2508	};	2508	};
2509		2509
		2510	static struct regmap aspeed_g5_acquire_regmap(struct aspeed_pinmux_data ctx,
		2511	int ip)
		2512	{
		2513	if (ip == ASPEED_IP_SCU) {
		2514	WARN(!ctx->maps[ip], "Missing SCU syscon!");
		2515	return ctx->maps[ip];
		2516	}
		2517
		2518	if (ip >= ASPEED_NR_PINMUX_IPS)
		2519	return ERR_PTR(-EINVAL);
		2520
		2521	if (likely(ctx->maps[ip]))
		2522	return ctx->maps[ip];
		2523
		2524	if (ip == ASPEED_IP_GFX) {
		2525	struct device_node *node;
		2526	struct regmap *map;
		2527
		2528	node = of_parse_phandle(ctx->dev->of_node,
		2529	"aspeed,external-nodes", 0);
		2530	if (node) {
		2531	map = syscon_node_to_regmap(node);
		2532	of_node_put(node);
		2533	if (IS_ERR(map))
		2534	return map;
		2535	} else
		2536	return ERR_PTR(-ENODEV);
		2537
		2538	ctx->maps[ASPEED_IP_GFX] = map;
		2539	dev_dbg(ctx->dev, "Acquired GFX regmap");
		2540	return map;
		2541	}
		2542
		2543	if (ip == ASPEED_IP_LPC) {
		2544	struct device_node *node;
		2545	struct regmap *map;
		2546
		2547	node = of_parse_phandle(ctx->dev->of_node,
		2548	"aspeed,external-nodes", 1);
		2549	if (node) {
		2550	map = syscon_node_to_regmap(node->parent);
		2551	of_node_put(node);
		2552	if (IS_ERR(map))
		2553	return map;
		2554	} else
		2555	map = ERR_PTR(-ENODEV);
		2556
		2557	ctx->maps[ASPEED_IP_LPC] = map;
		2558	dev_dbg(ctx->dev, "Acquired LPC regmap");
		2559	return map;
		2560	}
		2561
		2562	return ERR_PTR(-EINVAL);
		2563	}
		2564
2510	/**	2565	/**
2511	* Configure a pin's signal by applying an expression's descriptor state for	2566	* Configure a pin's signal by applying an expression's descriptor state for
2512	* all descriptors in the expression.	2567	* all descriptors in the expression.
@@ -2520,7 +2575,7 @@ static struct aspeed_pin_config aspeed_g5_configs[] = { · 7 unmodified lines
2520	* Return: 0 if the expression is configured as requested and a negative error	2575	* Return: 0 if the expression is configured as requested and a negative error
2521	* code otherwise	2576	* code otherwise
2522	*/	2577	*/
2523	static int aspeed_g5_sig_expr_set(const struct aspeed_pinmux_data *ctx,	2578	static int aspeed_g5_sig_expr_set(struct aspeed_pinmux_data *ctx,
2524	const struct aspeed_sig_expr *expr,	2579	const struct aspeed_sig_expr *expr,
2525	bool enable)	2580	bool enable)
2526	{	2581	{
@@ -2531,9 +2586,15 @@ static int aspeed_g5_sig_expr_set(const struct aspeed_pinmux_data *ctx, · 4 unmodified lines
2531	const struct aspeed_sig_desc *desc = &expr->descs[i];	2586	const struct aspeed_sig_desc *desc = &expr->descs[i];
2532	u32 pattern = enable ? desc->enable : desc->disable;	2587	u32 pattern = enable ? desc->enable : desc->disable;
2533	u32 val = (pattern << __ffs(desc->mask));	2588	u32 val = (pattern << __ffs(desc->mask));
		2589	struct regmap *map;
2534		2590
2535	if (!ctx->maps[desc->ip])	2591	map = aspeed_g5_acquire_regmap(ctx, desc->ip);
2536	return -ENODEV;	2592	if (IS_ERR(map)) {
		2593	dev_err(ctx->dev,
		2594	"Failed to acquire regmap for IP block %d\n",
		2595	desc->ip);
		2596	return PTR_ERR(map);
		2597	}
2537		2598
2538	/*	2599	/*
2539	* Strap registers are configured in hardware or by early-boot	2600	* Strap registers are configured in hardware or by early-boot
@@ -2641,34 +2702,11 @@ static struct pinctrl_desc aspeed_g5_pinctrl_desc = { · 101 unmodified lines
2641	static int aspeed_g5_pinctrl_probe(struct platform_device *pdev)	2702	static int aspeed_g5_pinctrl_probe(struct platform_device *pdev)
2642	{	2703	{
2643	int i;	2704	int i;
2644	struct regmap *map;
2645	struct device_node *node;
2646		2705
2647	for (i = 0; i < ARRAY_SIZE(aspeed_g5_pins); i++)	2706	for (i = 0; i < ARRAY_SIZE(aspeed_g5_pins); i++)
2648	aspeed_g5_pins[i].number = i;	2707	aspeed_g5_pins[i].number = i;
2649		2708
2650	node = of_parse_phandle(pdev->dev.of_node, "aspeed,external-nodes", 0);	2709	aspeed_g5_pinctrl_data.pinmux.dev = &pdev->dev;
2651	map = syscon_node_to_regmap(node);
2652	of_node_put(node);
2653	if (IS_ERR(map)) {
2654	dev_warn(&pdev->dev, "No GFX phandle found, some mux configurations may fail\n");
2655	map = NULL;
2656	}
2657	aspeed_g5_pinctrl_data.pinmux.maps[ASPEED_IP_GFX] = map;
2658
2659	node = of_parse_phandle(pdev->dev.of_node, "aspeed,external-nodes", 1);
2660	if (node) {
2661	map = syscon_node_to_regmap(node->parent);
2662	if (IS_ERR(map)) {
2663	dev_warn(&pdev->dev, "LHC parent is not a syscon, some mux configurations may fail\n");
2664	map = NULL;
2665	}
2666	} else {
2667	dev_warn(&pdev->dev, "No LHC phandle found, some mux configurations may fail\n");
2668	map = NULL;
2669	}
2670	of_node_put(node);
2671	aspeed_g5_pinctrl_data.pinmux.maps[ASPEED_IP_LPC] = map;
2672		2710
2673	return aspeed_pinctrl_probe(pdev, &aspeed_g5_pinctrl_desc,	2711	return aspeed_pinctrl_probe(pdev, &aspeed_g5_pinctrl_desc,
2674	&aspeed_g5_pinctrl_data);	2712	&aspeed_g5_pinctrl_data);

drivers/pinctrl/aspeed/pinctrl-aspeed.c+5−7

 	return 0;
 }
-static int aspeed_sig_expr_enable(const struct aspeed_pinmux_data *ctx,
+static int aspeed_sig_expr_enable(struct aspeed_pinmux_data *ctx,
 				  const struct aspeed_sig_expr *expr)
 {
 	int ret;
 	return 0;
 }
-static int aspeed_sig_expr_disable(const struct aspeed_pinmux_data *ctx,
+static int aspeed_sig_expr_disable(struct aspeed_pinmux_data *ctx,
 				   const struct aspeed_sig_expr *expr)
 {
 	int ret;
  *
  * Return: 0 if all expressions are disabled, otherwise a negative error code
  */
-static int aspeed_disable_sig(const struct aspeed_pinmux_data *ctx,
+static int aspeed_disable_sig(struct aspeed_pinmux_data *ctx,
 			      const struct aspeed_sig_expr **exprs)
 {
 	int ret = 0;
 {
 	int i;
 	int ret;
-	const struct aspeed_pinctrl_data *pdata =
+	struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
-		pinctrl_dev_get_drvdata(pctldev);
 	const struct aspeed_pin_group *pgroup = &pdata->pinmux.groups[group];
 	const struct aspeed_pin_function *pfunc =
 		&pdata->pinmux.functions[function];
 			       unsigned int offset)
 {
 	int ret;
-	const struct aspeed_pinctrl_data *pdata =
+	struct aspeed_pinctrl_data *pdata = pinctrl_dev_get_drvdata(pctldev);
-		pinctrl_dev_get_drvdata(pctldev);
 	const struct aspeed_pin_desc *pdesc = pdata->pins[offset].drv_data;
 	const struct aspeed_sig_expr ***prios, **funcs, *expr;

drivers/pinctrl/aspeed/pinmux-aspeed.c+1−1

@@ -5,7 +5,7 @@ · 4 unmodified lines
5		5
6	#include "pinmux-aspeed.h"	6	#include "pinmux-aspeed.h"
7		7
8	const char *const aspeed_pinmux_ips[] = {	8	static const char *const aspeed_pinmux_ips[] = {
9	[ASPEED_IP_SCU] = "SCU",	9	[ASPEED_IP_SCU] = "SCU",
10	[ASPEED_IP_GFX] = "GFX",	10	[ASPEED_IP_GFX] = "GFX",
11	[ASPEED_IP_LPC] = "LPC",	11	[ASPEED_IP_LPC] = "LPC",

drivers/pinctrl/aspeed/pinmux-aspeed.h+3−2

 struct aspeed_pinmux_data;
 struct aspeed_pinmux_ops {
-	int (*set)(const struct aspeed_pinmux_data *ctx,
+	int (*set)(struct aspeed_pinmux_data *ctx,
 		   const struct aspeed_sig_expr *expr, bool enabled);
 };
 struct aspeed_pinmux_data {
+	struct device *dev;
 	struct regmap *maps[ASPEED_NR_PINMUX_IPS];
 	const struct aspeed_pinmux_ops *ops;
 			 const struct aspeed_sig_expr *expr,
 			 bool enabled);
-static inline int aspeed_sig_expr_set(const struct aspeed_pinmux_data *ctx,
+static inline int aspeed_sig_expr_set(struct aspeed_pinmux_data *ctx,
 				      const struct aspeed_sig_expr *expr,
 				      bool enabled)
 {

drivers/pwm/core.c+5−2

 		return of_pwm_get(dev, dev->of_node, con_id);
 	/* then lookup via ACPI */
-	if (dev && is_acpi_node(dev->fwnode))
+	if (dev && is_acpi_node(dev->fwnode)) {
-		return acpi_pwm_get(dev->fwnode);
+		pwm = acpi_pwm_get(dev->fwnode);
+		if (!IS_ERR(pwm) || PTR_ERR(pwm) != -ENOENT)
+			return pwm;
+	}
 	/*
 	 * We look up the provider in the static table typically provided by

drivers/s390/net/ctcm_fsms.c+1−0

@@ -1704,6 +1704,7 @@ static void ctcmpc_chx_attnbusy(fsm_instance fsm, int event, void arg) · 1703 unmodified lines
1704	grp->changed_side = 2;	1704	grp->changed_side = 2;
1705	break;	1705	break;
1706	}	1706	}
		1707	/* Else, fall through */
1707	case MPCG_STATE_XID0IOWAIX:	1708	case MPCG_STATE_XID0IOWAIX:
1708	case MPCG_STATE_XID7INITW:	1709	case MPCG_STATE_XID7INITW:
1709	case MPCG_STATE_XID7INITX:	1710	case MPCG_STATE_XID7INITX:

drivers/s390/net/ctcm_mpc.c+3−0

 		/*fsm_newstate(grp->fsm, MPCG_STATE_XID2INITW);*/
 		if (callback)
 			grp->send_qllc_disc = 1;
+		/* Else, fall through */
 	case MPCG_STATE_XID0IOWAIT:
 		fsm_deltimer(&grp->timer);
 		grp->outstanding_xid2 = 0;
 		if ((fsm_getstate(rch->fsm) == CH_XID0_PENDING) &&
 		   (fsm_getstate(wch->fsm) == CH_XID0_PENDING))
 			break;
+		/* Else, fall through */
 	default:
 		fsm_event(grp->fsm, MPCG_EVENT_INOP, dev);
 	}
 			grp->estconnfunc = NULL;
 			break;
 		}
+		/* Else, fall through */
 	case MPCG_STATE_FLOWC:
 	case MPCG_STATE_READY:
 		grp->send_qllc_disc = 2;

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

@@ -629,6 +629,7 @@ struct qeth_seqno { · 628 unmodified lines
629	struct qeth_reply {	629	struct qeth_reply {
630	struct list_head list;	630	struct list_head list;
631	struct completion received;	631	struct completion received;
		632	spinlock_t lock;
632	int (callback)(struct qeth_card , struct qeth_reply *,	633	int (callback)(struct qeth_card , struct qeth_reply *,
633	unsigned long);	634	unsigned long);
634	u32 seqno;	635	u32 seqno;

drivers/s390/net/qeth_core_main.c+20−0

 	if (reply) {
 		refcount_set(&reply->refcnt, 1);
 		init_completion(&reply->received);
+		spin_lock_init(&reply->lock);
 	}
 	return reply;
 }
 	if (!reply->callback) {
 		rc = 0;
+		goto no_callback;
+	}
+	spin_lock_irqsave(&reply->lock, flags);
+	if (reply->rc) {
+		/* Bail out when the requestor has already left: */
+		rc = reply->rc;
 	} else {
 		if (cmd) {
 			reply->offset = (u16)((char *)cmd - (char *)iob->data);
 			rc = reply->callback(card, reply, (unsigned long)iob);
 		}
 	}
+	spin_unlock_irqrestore(&reply->lock, flags);
+no_callback:
 	if (rc <= 0)
 		qeth_notify_reply(reply, rc);
 	qeth_put_reply(reply);
 		rc = (timeout == -ERESTARTSYS) ? -EINTR : -ETIME;
 	qeth_dequeue_reply(card, reply);
+	if (reply_cb) {
+		/* Wait until the callback for a late reply has completed: */
+		spin_lock_irq(&reply->lock);
+		if (rc)
+			/* Zap any callback that's still pending: */
+			reply->rc = rc;
+		spin_unlock_irq(&reply->lock);
+	}
 	if (!rc)
 		rc = reply->rc;
 	qeth_put_reply(reply);

drivers/s390/net/qeth_l2_main.c+1−1

@@ -333,7 +333,7 @@ static int qeth_l2_process_inbound_buffer(struct qeth_card *card, · 332 unmodified lines
333	card->osn_info.data_cb(skb);	333	card->osn_info.data_cb(skb);
334	break;	334	break;
335	}	335	}
336	/* else unknown */	336	/* Else, fall through */
337	default:	337	default:
338	dev_kfree_skb_any(skb);	338	dev_kfree_skb_any(skb);
339	QETH_CARD_TEXT(card, 3, "inbunkno");	339	QETH_CARD_TEXT(card, 3, "inbunkno");

drivers/scsi/arm/fas216.c+8−0

 		msgqueue_flush(&info->scsi.msgs);
 		msgqueue_addmsg(&info->scsi.msgs, 1, MESSAGE_REJECT);
 		info->scsi.phase = PHASE_MSGOUT_EXPECT;
+		/* fall through */
 	case async:
 		dev->period = info->ifcfg.asyncperiod / 4;
 			fas216_done(info, DID_ABORT);
 			break;
 		}
+		/* else, fall through */
 	default:				/* huh?					*/
 		printk(KERN_ERR "scsi%d.%c: unexpected disconnect in phase %s\n",
 	case STATE(STAT_STATUS, PHASE_DATAOUT): /* Data Out     -> Status       */
 	case STATE(STAT_STATUS, PHASE_DATAIN):  /* Data In      -> Status       */
 		fas216_stoptransfer(info);
+		/* fall through */
 	case STATE(STAT_STATUS, PHASE_SELSTEPS):/* Sel w/ steps -> Status       */
 	case STATE(STAT_STATUS, PHASE_MSGOUT):  /* Message Out  -> Status       */
 	case STATE(STAT_STATUS, PHASE_COMMAND): /* Command      -> Status       */
 	case STATE(STAT_MESGIN, PHASE_DATAOUT): /* Data Out     -> Message In   */
 	case STATE(STAT_MESGIN, PHASE_DATAIN):  /* Data In      -> Message In   */
 		fas216_stoptransfer(info);
+		/* fall through */
 	case STATE(STAT_MESGIN, PHASE_COMMAND):	/* Command	-> Message In	*/
 	case STATE(STAT_MESGIN, PHASE_SELSTEPS):/* Sel w/ steps -> Message In   */
 	case STATE(STAT_MESGIN, PHASE_MSGOUT):  /* Message Out  -> Message In   */
 			fas216_message(info);
 			break;
 		}
+		/* else, fall through */
 	default:
 		fas216_log(info, 0, "internal phase %s for function done?"
 	switch (where_from) {
 	case TYPE_QUEUE:
 		fas216_allocate_tag(info, SCpnt);
+		/* fall through */
 	case TYPE_OTHER:
 		fas216_start_command(info, SCpnt);
 		break;

drivers/scsi/lpfc/lpfc_init.c+21−2

@@ -10776,12 +10776,31 @@ lpfc_cpu_affinity_check(struct lpfc_hba *phba, int vectors) · 10775 unmodified lines
10776	/* This loop sets up all CPUs that are affinitized with a	10776	/* This loop sets up all CPUs that are affinitized with a
10777	* irq vector assigned to the driver. All affinitized CPUs	10777	* irq vector assigned to the driver. All affinitized CPUs
10778	* will get a link to that vectors IRQ and EQ.	10778	* will get a link to that vectors IRQ and EQ.
		10779	*
		10780	* NULL affinity mask handling:
		10781	* If irq count is greater than one, log an error message.
		10782	* If the null mask is received for the first irq, find the
		10783	* first present cpu, and assign the eq index to ensure at
		10784	* least one EQ is assigned.
10779	*/	10785	*/
10780	for (idx = 0; idx < phba->cfg_irq_chann; idx++) {	10786	for (idx = 0; idx < phba->cfg_irq_chann; idx++) {
10781	/* Get a CPU mask for all CPUs affinitized to this vector */	10787	/* Get a CPU mask for all CPUs affinitized to this vector */
10782	maskp = pci_irq_get_affinity(phba->pcidev, idx);	10788	maskp = pci_irq_get_affinity(phba->pcidev, idx);
10783	if (!maskp)	10789	if (!maskp) {
10784	continue;	10790	if (phba->cfg_irq_chann > 1)
		10791	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
		10792	"3329 No affinity mask found "
		10793	"for vector %d (%d)\n",
		10794	idx, phba->cfg_irq_chann);
		10795	if (!idx) {
		10796	cpu = cpumask_first(cpu_present_mask);
		10797	cpup = &phba->sli4_hba.cpu_map[cpu];
		10798	cpup->eq = idx;
		10799	cpup->irq = pci_irq_vector(phba->pcidev, idx);
		10800	cpup->flag \|= LPFC_CPU_FIRST_IRQ;
		10801	}
		10802	break;
		10803	}
10785		10804
10786	i = 0;	10805	i = 0;
10787	/* Loop through all CPUs associated with vector idx */	10806	/* Loop through all CPUs associated with vector idx */

drivers/soundwire/Kconfig+1−6

 #
 menuconfig SOUNDWIRE
-	bool "SoundWire support"
+	tristate "SoundWire support"
 	help
 	  SoundWire is a 2-Pin interface with data and clock line ratified
 	  by the MIPI Alliance. SoundWire is used for transporting data
 comment "SoundWire Devices"
-config SOUNDWIRE_BUS
-	tristate
-	select REGMAP_SOUNDWIRE
 config SOUNDWIRE_CADENCE
 	tristate
 config SOUNDWIRE_INTEL
 	tristate "Intel SoundWire Master driver"
 	select SOUNDWIRE_CADENCE
-	select SOUNDWIRE_BUS
 	depends on X86 && ACPI && SND_SOC
 	help
 	  SoundWire Intel Master driver.

drivers/soundwire/Makefile+1−1

@@ -5,7 +5,7 @@ · 4 unmodified lines
5		5
6	#Bus Objs	6	#Bus Objs
7	soundwire-bus-objs := bus_type.o bus.o slave.o mipi_disco.o stream.o	7	soundwire-bus-objs := bus_type.o bus.o slave.o mipi_disco.o stream.o
8	obj-$(CONFIG_SOUNDWIRE_BUS) += soundwire-bus.o	8	obj-$(CONFIG_SOUNDWIRE) += soundwire-bus.o
9		9
10	#Cadence Objs	10	#Cadence Objs
11	soundwire-cadence-objs := cadence_master.o	11	soundwire-cadence-objs := cadence_master.o

drivers/soundwire/cadence_master.c+4−4

@@ -81,8 +81,8 @@ · 80 unmodified lines
81		81
82	#define CDNS_MCP_INTSET 0x4C	82	#define CDNS_MCP_INTSET 0x4C
83		83
84	#define CDNS_SDW_SLAVE_STAT 0x50	84	#define CDNS_MCP_SLAVE_STAT 0x50
85	#define CDNS_MCP_SLAVE_STAT_MASK BIT(1, 0)	85	#define CDNS_MCP_SLAVE_STAT_MASK GENMASK(1, 0)
86		86
87	#define CDNS_MCP_SLAVE_INTSTAT0 0x54	87	#define CDNS_MCP_SLAVE_INTSTAT0 0x54
88	#define CDNS_MCP_SLAVE_INTSTAT1 0x58	88	#define CDNS_MCP_SLAVE_INTSTAT1 0x58
@@ -96,8 +96,8 @@ · 7 unmodified lines
96	#define CDNS_MCP_SLAVE_INTMASK0 0x5C	96	#define CDNS_MCP_SLAVE_INTMASK0 0x5C
97	#define CDNS_MCP_SLAVE_INTMASK1 0x60	97	#define CDNS_MCP_SLAVE_INTMASK1 0x60
98		98
99	#define CDNS_MCP_SLAVE_INTMASK0_MASK GENMASK(30, 0)	99	#define CDNS_MCP_SLAVE_INTMASK0_MASK GENMASK(31, 0)
100	#define CDNS_MCP_SLAVE_INTMASK1_MASK GENMASK(16, 0)	100	#define CDNS_MCP_SLAVE_INTMASK1_MASK GENMASK(15, 0)
101		101
102	#define CDNS_MCP_PORT_INTSTAT 0x64	102	#define CDNS_MCP_PORT_INTSTAT 0x64
103	#define CDNS_MCP_PDI_STAT 0x6C	103	#define CDNS_MCP_PDI_STAT 0x6C

drivers/staging/android/ion/ion_page_pool.c+3−0

 #include <linux/list.h>
 #include <linux/slab.h>
 #include <linux/swap.h>
+#include <linux/sched/signal.h>
 #include "ion.h"
 static inline struct page *ion_page_pool_alloc_pages(struct ion_page_pool *pool)
 {
+	if (fatal_signal_pending(current))
+		return NULL;
 	return alloc_pages(pool->gfp_mask, pool->order);
 }

drivers/staging/comedi/drivers/dt3000.c+4−4

@@ -342,9 +342,9 @@ static irqreturn_t dt3k_interrupt(int irq, void *d) · 341 unmodified lines
342	static int dt3k_ns_to_timer(unsigned int timer_base, unsigned int *nanosec,	342	static int dt3k_ns_to_timer(unsigned int timer_base, unsigned int *nanosec,
343	unsigned int flags)	343	unsigned int flags)
344	{	344	{
345	int divider, base, prescale;	345	unsigned int divider, base, prescale;
346		346
347	/* This function needs improvment */	347	/* This function needs improvement */
348	/* Don't know if divider==0 works. */	348	/* Don't know if divider==0 works. */
349		349
350	for (prescale = 0; prescale < 16; prescale++) {	350	for (prescale = 0; prescale < 16; prescale++) {
@@ -358,7 +358,7 @@ static int dt3k_ns_to_timer(unsigned int timer_base, unsigned int *nanosec, · 7 unmodified lines
358	divider = (*nanosec) / base;	358	divider = (*nanosec) / base;
359	break;	359	break;
360	case CMDF_ROUND_UP:	360	case CMDF_ROUND_UP:
361	divider = (*nanosec) / base;	361	divider = DIV_ROUND_UP(*nanosec, base);
362	break;	362	break;
363	}	363	}
364	if (divider < 65536) {	364	if (divider < 65536) {
@@ -368,7 +368,7 @@ static int dt3k_ns_to_timer(unsigned int timer_base, unsigned int *nanosec, · 3 unmodified lines
368	}	368	}
369		369
370	prescale = 15;	370	prescale = 15;
371	base = timer_base * (1 << prescale);	371	base = timer_base * (prescale + 1);
372	divider = 65535;	372	divider = 65535;
373	nanosec = divider base;	373	nanosec = divider base;
374	return (prescale << 16) \| (divider);	374	return (prescale << 16) \| (divider);

drivers/staging/fbtft/fb_bd663474.c+1−1

@@ -24,7 +24,7 @@ · 23 unmodified lines
24		24
25	static int init_display(struct fbtft_par *par)	25	static int init_display(struct fbtft_par *par)
26	{	26	{
27	if (!par->gpio.cs)	27	if (par->gpio.cs)
28	gpiod_set_value(par->gpio.cs, 0); /* Activate chip */	28	gpiod_set_value(par->gpio.cs, 0); /* Activate chip */
29		29
30	par->fbtftops.reset(par);	30	par->fbtftops.reset(par);

drivers/staging/fbtft/fb_ili9163.c+1−1

@@ -77,7 +77,7 @@ static int init_display(struct fbtft_par *par) · 76 unmodified lines
77	{	77	{
78	par->fbtftops.reset(par);	78	par->fbtftops.reset(par);
79		79
80	if (!par->gpio.cs)	80	if (par->gpio.cs)
81	gpiod_set_value(par->gpio.cs, 0); /* Activate chip */	81	gpiod_set_value(par->gpio.cs, 0); /* Activate chip */
82		82
83	write_reg(par, MIPI_DCS_SOFT_RESET); /* software reset */	83	write_reg(par, MIPI_DCS_SOFT_RESET); /* software reset */

drivers/staging/fbtft/fb_ili9325.c+1−1

@@ -85,7 +85,7 @@ static int init_display(struct fbtft_par *par) · 84 unmodified lines
85	{	85	{
86	par->fbtftops.reset(par);	86	par->fbtftops.reset(par);
87		87
88	if (!par->gpio.cs)	88	if (par->gpio.cs)
89	gpiod_set_value(par->gpio.cs, 0); /* Activate chip */	89	gpiod_set_value(par->gpio.cs, 0); /* Activate chip */
90		90
91	bt &= 0x07;	91	bt &= 0x07;

drivers/staging/fbtft/fb_s6d1121.c+1−1

@@ -29,7 +29,7 @@ static int init_display(struct fbtft_par *par) · 28 unmodified lines
29	{	29	{
30	par->fbtftops.reset(par);	30	par->fbtftops.reset(par);
31		31
32	if (!par->gpio.cs)	32	if (par->gpio.cs)
33	gpiod_set_value(par->gpio.cs, 0); /* Activate chip */	33	gpiod_set_value(par->gpio.cs, 0); /* Activate chip */
34		34
35	/* Initialization sequence from Lib_UTFT */	35	/* Initialization sequence from Lib_UTFT */

drivers/staging/fbtft/fb_ssd1289.c+1−1

@@ -28,7 +28,7 @@ static int init_display(struct fbtft_par *par) · 27 unmodified lines
28	{	28	{
29	par->fbtftops.reset(par);	29	par->fbtftops.reset(par);
30		30
31	if (!par->gpio.cs)	31	if (par->gpio.cs)
32	gpiod_set_value(par->gpio.cs, 0); /* Activate chip */	32	gpiod_set_value(par->gpio.cs, 0); /* Activate chip */
33		33
34	write_reg(par, 0x00, 0x0001);	34	write_reg(par, 0x00, 0x0001);

drivers/staging/fbtft/fb_ssd1331.c+2−2

@@ -81,7 +81,7 @@ static void write_reg8_bus8(struct fbtft_par *par, int len, ...) · 80 unmodified lines
81	va_start(args, len);	81	va_start(args, len);
82		82
83	*buf = (u8)va_arg(args, unsigned int);	83	*buf = (u8)va_arg(args, unsigned int);
84	if (!par->gpio.dc)	84	if (par->gpio.dc)
85	gpiod_set_value(par->gpio.dc, 0);	85	gpiod_set_value(par->gpio.dc, 0);
86	ret = par->fbtftops.write(par, par->buf, sizeof(u8));	86	ret = par->fbtftops.write(par, par->buf, sizeof(u8));
87	if (ret < 0) {	87	if (ret < 0) {
@@ -104,7 +104,7 @@ static void write_reg8_bus8(struct fbtft_par *par, int len, ...) · 16 unmodified lines
104	return;	104	return;
105	}	105	}
106	}	106	}
107	if (!par->gpio.dc)	107	if (par->gpio.dc)
108	gpiod_set_value(par->gpio.dc, 1);	108	gpiod_set_value(par->gpio.dc, 1);
109	va_end(args);	109	va_end(args);
110	}	110	}

drivers/staging/fbtft/fb_upd161704.c+1−1

@@ -26,7 +26,7 @@ static int init_display(struct fbtft_par *par) · 25 unmodified lines
26	{	26	{
27	par->fbtftops.reset(par);	27	par->fbtftops.reset(par);
28		28
29	if (!par->gpio.cs)	29	if (par->gpio.cs)
30	gpiod_set_value(par->gpio.cs, 0); /* Activate chip */	30	gpiod_set_value(par->gpio.cs, 0); /* Activate chip */
31		31
32	/* Initialization sequence from Lib_UTFT */	32	/* Initialization sequence from Lib_UTFT */

drivers/staging/fbtft/fbtft-bus.c+1−1

@@ -135,7 +135,7 @@ int fbtft_write_vmem16_bus8(struct fbtft_par *par, size_t offset, size_t len) · 134 unmodified lines
135	remain = len / 2;	135	remain = len / 2;
136	vmem16 = (u16 *)(par->info->screen_buffer + offset);	136	vmem16 = (u16 *)(par->info->screen_buffer + offset);
137		137
138	if (!par->gpio.dc)	138	if (par->gpio.dc)
139	gpiod_set_value(par->gpio.dc, 1);	139	gpiod_set_value(par->gpio.dc, 1);
140		140
141	/* non buffered write */	141	/* non buffered write */

drivers/staging/fbtft/fbtft-core.c+22−25

 				  struct gpio_desc **gpiop)
 {
 	struct device *dev = par->info->device;
-	struct device_node *node = dev->of_node;
 	int ret = 0;
-	if (of_find_property(node, name, NULL)) {
+	*gpiop = devm_gpiod_get_index_optional(dev, name, index,
-		*gpiop = devm_gpiod_get_index(dev, dev->driver->name, index,
+					       GPIOD_OUT_HIGH);
-					      GPIOD_OUT_HIGH);
+	if (IS_ERR(*gpiop)) {
-		if (IS_ERR(*gpiop)) {
+		ret = PTR_ERR(*gpiop);
-			ret = PTR_ERR(*gpiop);
+		dev_err(dev,
-			dev_err(dev,
+			"Failed to request %s GPIO: %d\n", name, ret);
-				"Failed to request %s GPIO:%d\n", name, ret);
+		return ret;
-			return ret;
-		}
-		fbtft_par_dbg(DEBUG_REQUEST_GPIOS, par, "%s: '%s' GPIO\n",
-			      __func__, name);
 	}
+	fbtft_par_dbg(DEBUG_REQUEST_GPIOS, par, "%s: '%s' GPIO\n",
+		      __func__, name);
 	return ret;
 }
 	if (!par->info->device->of_node)
 		return -EINVAL;
-	ret = fbtft_request_one_gpio(par, "reset-gpios", 0, &par->gpio.reset);
+	ret = fbtft_request_one_gpio(par, "reset", 0, &par->gpio.reset);
 	if (ret)
 		return ret;
-	ret = fbtft_request_one_gpio(par, "dc-gpios", 0, &par->gpio.dc);
+	ret = fbtft_request_one_gpio(par, "dc", 0, &par->gpio.dc);
 	if (ret)
 		return ret;
-	ret = fbtft_request_one_gpio(par, "rd-gpios", 0, &par->gpio.rd);
+	ret = fbtft_request_one_gpio(par, "rd", 0, &par->gpio.rd);
 	if (ret)
 		return ret;
-	ret = fbtft_request_one_gpio(par, "wr-gpios", 0, &par->gpio.wr);
+	ret = fbtft_request_one_gpio(par, "wr", 0, &par->gpio.wr);
 	if (ret)
 		return ret;
-	ret = fbtft_request_one_gpio(par, "cs-gpios", 0, &par->gpio.cs);
+	ret = fbtft_request_one_gpio(par, "cs", 0, &par->gpio.cs);
 	if (ret)
 		return ret;
-	ret = fbtft_request_one_gpio(par, "latch-gpios", 0, &par->gpio.latch);
+	ret = fbtft_request_one_gpio(par, "latch", 0, &par->gpio.latch);
 	if (ret)
 		return ret;
 	for (i = 0; i < 16; i++) {
-		ret = fbtft_request_one_gpio(par, "db-gpios", i,
+		ret = fbtft_request_one_gpio(par, "db", i,
 					     &par->gpio.db[i]);
 		if (ret)
 			return ret;
-		ret = fbtft_request_one_gpio(par, "led-gpios", i,
+		ret = fbtft_request_one_gpio(par, "led", i,
 					     &par->gpio.led[i]);
 		if (ret)
 			return ret;
-		ret = fbtft_request_one_gpio(par, "aux-gpios", i,
+		ret = fbtft_request_one_gpio(par, "aux", i,
 					     &par->gpio.aux[i]);
 		if (ret)
 			return ret;
 	if (!par->gpio.reset)
 		return;
 	fbtft_par_dbg(DEBUG_RESET, par, "%s()\n", __func__);
-	gpiod_set_value_cansleep(par->gpio.reset, 0);
-	usleep_range(20, 40);
 	gpiod_set_value_cansleep(par->gpio.reset, 1);
+	usleep_range(20, 40);
+	gpiod_set_value_cansleep(par->gpio.reset, 0);
 	msleep(120);
 }
 		return -EINVAL;
 	par->fbtftops.reset(par);
-	if (!par->gpio.cs)
+	if (par->gpio.cs)
 		gpiod_set_value(par->gpio.cs, 0);  /* Activate chip */
 	while (p) {
 	}
 	par->fbtftops.reset(par);
-	if (!par->gpio.cs)
+	if (par->gpio.cs)
 		gpiod_set_value(par->gpio.cs, 0);  /* Activate chip */
 	i = 0;

drivers/staging/gasket/apex_driver.c+1−1

@@ -532,7 +532,7 @@ static ssize_t sysfs_show(struct device device, struct device_attribute attr, · 531 unmodified lines
532	break;	532	break;
533	case ATTR_KERNEL_HIB_SIMPLE_PAGE_TABLE_SIZE:	533	case ATTR_KERNEL_HIB_SIMPLE_PAGE_TABLE_SIZE:
534	ret = scnprintf(buf, PAGE_SIZE, "%u\n",	534	ret = scnprintf(buf, PAGE_SIZE, "%u\n",
535	gasket_page_table_num_entries(	535	gasket_page_table_num_simple_entries(
536	gasket_dev->page_table[0]));	536	gasket_dev->page_table[0]));
537	break;	537	break;
538	case ATTR_KERNEL_HIB_NUM_ACTIVE_PAGES:	538	case ATTR_KERNEL_HIB_NUM_ACTIVE_PAGES:

drivers/staging/unisys/visornic/visornic_main.c+2−1

@@ -1750,7 +1750,8 @@ static int visornic_poll(struct napi_struct *napi, int budget) · 1749 unmodified lines
1750	}	1750	}
1751		1751
1752	/* poll_for_irq - checks the status of the response queue	1752	/* poll_for_irq - checks the status of the response queue
1753	* @v: Void pointer to the visronic devdata struct.	1753	* @t: pointer to the 'struct timer_list' from which we can retrieve the
		1754	* the visornic devdata struct.
1754	*	1755	*
1755	* Main function of the vnic_incoming thread. Periodically check the response	1756	* Main function of the vnic_incoming thread. Periodically check the response
1756	* queue and drain it if needed.	1757	* queue and drain it if needed.

drivers/staging/wilc1000/wilc_wfi_cfgoperations.c+1−0

@@ -1969,6 +1969,7 @@ void wilc_deinit_host_int(struct net_device *net) · 1968 unmodified lines
1969		1969
1970	priv->p2p_listen_state = false;	1970	priv->p2p_listen_state = false;
1971		1971
		1972	flush_workqueue(vif->wilc->hif_workqueue);
1972	mutex_destroy(&priv->scan_req_lock);	1973	mutex_destroy(&priv->scan_req_lock);
1973	ret = wilc_deinit(vif);	1974	ret = wilc_deinit(vif);
1974		1975

drivers/tty/serial/kgdboc.c+4−0

 	/* Increment the module count when the debugger is active */
 	if (!kgdb_connected)
 		try_module_get(THIS_MODULE);
+	atomic_inc(&ignore_console_lock_warning);
 }
 static void kgdboc_post_exp_handler(void)
 {
+	atomic_dec(&ignore_console_lock_warning);
 	/* decrement the module count when the debugger detaches */
 	if (!kgdb_connected)
 		module_put(THIS_MODULE);

drivers/usb/chipidea/ci_hdrc_imx.c+12−7

 	imx_disable_unprepare_clks(dev);
 disable_hsic_regulator:
 	if (data->hsic_pad_regulator)
-		ret = regulator_disable(data->hsic_pad_regulator);
+		/* don't overwrite original ret (cf. EPROBE_DEFER) */
+		regulator_disable(data->hsic_pad_regulator);
 	if (pdata.flags & CI_HDRC_PMQOS)
 		pm_qos_remove_request(&data->pm_qos_req);
+	data->ci_pdev = NULL;
 	return ret;
 }
 		pm_runtime_disable(&pdev->dev);
 		pm_runtime_put_noidle(&pdev->dev);
 	}
-	ci_hdrc_remove_device(data->ci_pdev);
+	if (data->ci_pdev)
+		ci_hdrc_remove_device(data->ci_pdev);
 	if (data->override_phy_control)
 		usb_phy_shutdown(data->phy);
-	imx_disable_unprepare_clks(&pdev->dev);
+	if (data->ci_pdev) {
-	if (data->plat_data->flags & CI_HDRC_PMQOS)
+		imx_disable_unprepare_clks(&pdev->dev);
-		pm_qos_remove_request(&data->pm_qos_req);
+		if (data->plat_data->flags & CI_HDRC_PMQOS)
-	if (data->hsic_pad_regulator)
+			pm_qos_remove_request(&data->pm_qos_req);
-		regulator_disable(data->hsic_pad_regulator);
+		if (data->hsic_pad_regulator)
+			regulator_disable(data->hsic_pad_regulator);
+	}
 	return 0;
 }

drivers/usb/class/cdc-acm.c+7−5

 	tty_port_init(&acm->port);
 	acm->port.ops = &acm_port_ops;
-	minor = acm_alloc_minor(acm);
-	if (minor < 0)
-		goto alloc_fail1;
 	ctrlsize = usb_endpoint_maxp(epctrl);
 	readsize = usb_endpoint_maxp(epread) *
 				(quirks == SINGLE_RX_URB ? 1 : 2);
 	acm->writesize = usb_endpoint_maxp(epwrite) * 20;
 	acm->control = control_interface;
 	acm->data = data_interface;
+	usb_get_intf(acm->control); /* undone in destruct() */
+	minor = acm_alloc_minor(acm);
+	if (minor < 0)
+		goto alloc_fail1;
 	acm->minor = minor;
 	acm->dev = usb_dev;
 	if (h.usb_cdc_acm_descriptor)
 	usb_driver_claim_interface(&acm_driver, data_interface, acm);
 	usb_set_intfdata(data_interface, acm);
-	usb_get_intf(control_interface);
 	tty_dev = tty_port_register_device(&acm->port, acm_tty_driver, minor,
 			&control_interface->dev);
 	if (IS_ERR(tty_dev)) {

drivers/usb/core/buffer.c+3−7

 	char		name[16];
 	int		i, size;
-	if (!IS_ENABLED(CONFIG_HAS_DMA) ||
+	if (hcd->localmem_pool || !hcd_uses_dma(hcd))
-	    (!is_device_dma_capable(hcd->self.sysdev) &&
-	     !hcd->localmem_pool))
 		return 0;
 	for (i = 0; i < HCD_BUFFER_POOLS; i++) {
 		return gen_pool_dma_alloc(hcd->localmem_pool, size, dma);
 	/* some USB hosts just use PIO */
-	if (!IS_ENABLED(CONFIG_HAS_DMA) ||
+	if (!hcd_uses_dma(hcd)) {
-	    !is_device_dma_capable(bus->sysdev)) {
 		*dma = ~(dma_addr_t) 0;
 		return kmalloc(size, mem_flags);
 	}
 		return;
 	}
-	if (!IS_ENABLED(CONFIG_HAS_DMA) ||
+	if (!hcd_uses_dma(hcd)) {
-	    !is_device_dma_capable(bus->sysdev)) {
 		kfree(addr);
 		return;
 	}

drivers/usb/core/devio.c+0−2

@@ -1812,8 +1812,6 @@ static int proc_do_submiturb(struct usb_dev_state ps, struct usbdevfs_urb uurb · 1811 unmodified lines
1812	return 0;	1812	return 0;
1813		1813
1814	error:	1814	error:
1815	if (as && as->usbm)
1816	dec_usb_memory_use_count(as->usbm, &as->usbm->urb_use_count);
1817	kfree(isopkt);	1815	kfree(isopkt);
1818	kfree(dr);	1816	kfree(dr);
1819	if (as)	1817	if (as)

drivers/usb/core/file.c+5−5

 		intf->minor = minor;
 		break;
 	}
-	up_write(&minor_rwsem);
+	if (intf->minor < 0) {
-	if (intf->minor < 0)
+		up_write(&minor_rwsem);
 		return -EXFULL;
+	}
 	/* create a usb class device for this usb interface */
 	snprintf(name, sizeof(name), class_driver->name, minor - minor_base);
 				      MKDEV(USB_MAJOR, minor), class_driver,
 				      "%s", kbasename(name));
 	if (IS_ERR(intf->usb_dev)) {
-		down_write(&minor_rwsem);
 		usb_minors[minor] = NULL;
 		intf->minor = -1;
-		up_write(&minor_rwsem);
 		retval = PTR_ERR(intf->usb_dev);
 	}
+	up_write(&minor_rwsem);
 	return retval;
 }
 EXPORT_SYMBOL_GPL(usb_register_dev);
 		return;
 	dev_dbg(&intf->dev, "removing %d minor\n", intf->minor);
+	device_destroy(usb_class->class, MKDEV(USB_MAJOR, intf->minor));
 	down_write(&minor_rwsem);
 	usb_minors[intf->minor] = NULL;
 	up_write(&minor_rwsem);
-	device_destroy(usb_class->class, MKDEV(USB_MAJOR, intf->minor));
 	intf->usb_dev = NULL;
 	intf->minor = -1;
 	destroy_usb_class();

drivers/usb/core/hcd.c+2−125

@@ -103,11 +103,6 @@ static DEFINE_SPINLOCK(hcd_urb_unlink_lock); · 102 unmodified lines
103	/* wait queue for synchronous unlinks */	103	/* wait queue for synchronous unlinks */
104	DECLARE_WAIT_QUEUE_HEAD(usb_kill_urb_queue);	104	DECLARE_WAIT_QUEUE_HEAD(usb_kill_urb_queue);
105		105
106	static inline int is_root_hub(struct usb_device *udev)
107	{
108	return (udev->parent == NULL);
109	}
110
111	/-------------------------------------------------------------------------/	106	/-------------------------------------------------------------------------/
112		107
113	/*	108	/*
@@ -880,101 +875,6 @@ static int usb_rh_urb_dequeue(struct usb_hcd hcd, struct urb urb, int status) · 766 unmodified lines
880	}	875	}
881		876
882		877
883
884	/*
885	* Show & store the current value of authorized_default
886	*/
887	static ssize_t authorized_default_show(struct device *dev,
888	struct device_attribute attr, char buf)
889	{
890	struct usb_device *rh_usb_dev = to_usb_device(dev);
891	struct usb_bus *usb_bus = rh_usb_dev->bus;
892	struct usb_hcd *hcd;
893
894	hcd = bus_to_hcd(usb_bus);
895	return snprintf(buf, PAGE_SIZE, "%u\n", hcd->dev_policy);
896	}
897
898	static ssize_t authorized_default_store(struct device *dev,
899	struct device_attribute *attr,
900	const char *buf, size_t size)
901	{
902	ssize_t result;
903	unsigned val;
904	struct usb_device *rh_usb_dev = to_usb_device(dev);
905	struct usb_bus *usb_bus = rh_usb_dev->bus;
906	struct usb_hcd *hcd;
907
908	hcd = bus_to_hcd(usb_bus);
909	result = sscanf(buf, "%u\n", &val);
910	if (result == 1) {
911	hcd->dev_policy = val <= USB_DEVICE_AUTHORIZE_INTERNAL ?
912	val : USB_DEVICE_AUTHORIZE_ALL;
913	result = size;
914	} else {
915	result = -EINVAL;
916	}
917	return result;
918	}
919	static DEVICE_ATTR_RW(authorized_default);
920
921	/*
922	* interface_authorized_default_show - show default authorization status
923	* for USB interfaces
924	*
925	* note: interface_authorized_default is the default value
926	* for initializing the authorized attribute of interfaces
927	*/
928	static ssize_t interface_authorized_default_show(struct device *dev,
929	struct device_attribute attr, char buf)
930	{
931	struct usb_device *usb_dev = to_usb_device(dev);
932	struct usb_hcd *hcd = bus_to_hcd(usb_dev->bus);
933
934	return sprintf(buf, "%u\n", !!HCD_INTF_AUTHORIZED(hcd));
935	}
936
937	/*
938	* interface_authorized_default_store - store default authorization status
939	* for USB interfaces
940	*
941	* note: interface_authorized_default is the default value
942	* for initializing the authorized attribute of interfaces
943	*/
944	static ssize_t interface_authorized_default_store(struct device *dev,
945	struct device_attribute attr, const char buf, size_t count)
946	{
947	struct usb_device *usb_dev = to_usb_device(dev);
948	struct usb_hcd *hcd = bus_to_hcd(usb_dev->bus);
949	int rc = count;
950	bool val;
951
952	if (strtobool(buf, &val) != 0)
953	return -EINVAL;
954
955	if (val)
956	set_bit(HCD_FLAG_INTF_AUTHORIZED, &hcd->flags);
957	else
958	clear_bit(HCD_FLAG_INTF_AUTHORIZED, &hcd->flags);
959
960	return rc;
961	}
962	static DEVICE_ATTR_RW(interface_authorized_default);
963
964	/* Group all the USB bus attributes */
965	static struct attribute *usb_bus_attrs[] = {
966	&dev_attr_authorized_default.attr,
967	&dev_attr_interface_authorized_default.attr,
968	NULL,
969	};
970
971	static const struct attribute_group usb_bus_attr_group = {
972	.name = NULL, /* we want them in the same directory */
973	.attrs = usb_bus_attrs,
974	};
975
976
977
978	/-------------------------------------------------------------------------/	878	/-------------------------------------------------------------------------/
979		879
980	/**	880	/**
@@ -1512,7 +1412,7 @@ int usb_hcd_map_urb_for_dma(struct usb_hcd hcd, struct urb urb, · 531 unmodified lines
1512	if (usb_endpoint_xfer_control(&urb->ep->desc)) {	1412	if (usb_endpoint_xfer_control(&urb->ep->desc)) {
1513	if (hcd->self.uses_pio_for_control)	1413	if (hcd->self.uses_pio_for_control)
1514	return ret;	1414	return ret;
1515	if (IS_ENABLED(CONFIG_HAS_DMA) && hcd->self.uses_dma) {	1415	if (hcd_uses_dma(hcd)) {
1516	if (is_vmalloc_addr(urb->setup_packet)) {	1416	if (is_vmalloc_addr(urb->setup_packet)) {
1517	WARN_ONCE(1, "setup packet is not dma capable\n");	1417	WARN_ONCE(1, "setup packet is not dma capable\n");
1518	return -EAGAIN;	1418	return -EAGAIN;
@@ -1546,7 +1446,7 @@ int usb_hcd_map_urb_for_dma(struct usb_hcd hcd, struct urb urb, · 27 unmodified lines
1546	dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;	1446	dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
1547	if (urb->transfer_buffer_length != 0	1447	if (urb->transfer_buffer_length != 0
1548	&& !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)) {	1448	&& !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)) {
1549	if (IS_ENABLED(CONFIG_HAS_DMA) && hcd->self.uses_dma) {	1449	if (hcd_uses_dma(hcd)) {
1550	if (urb->num_sgs) {	1450	if (urb->num_sgs) {
1551	int n;	1451	int n;
1552		1452
@@ -2894,32 +2794,11 @@ int usb_add_hcd(struct usb_hcd *hcd, · 1341 unmodified lines
2894	if (retval != 0)	2794	if (retval != 0)
2895	goto err_register_root_hub;	2795	goto err_register_root_hub;
2896		2796
2897	retval = sysfs_create_group(&rhdev->dev.kobj, &usb_bus_attr_group);
2898	if (retval < 0) {
2899	printk(KERN_ERR "Cannot register USB bus sysfs attributes: %d\n",
2900	retval);
2901	goto error_create_attr_group;
2902	}
2903	if (hcd->uses_new_polling && HCD_POLL_RH(hcd))	2797	if (hcd->uses_new_polling && HCD_POLL_RH(hcd))
2904	usb_hcd_poll_rh_status(hcd);	2798	usb_hcd_poll_rh_status(hcd);
2905		2799
2906	return retval;	2800	return retval;
2907		2801
2908	error_create_attr_group:
2909	clear_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
2910	if (HC_IS_RUNNING(hcd->state))
2911	hcd->state = HC_STATE_QUIESCING;
2912	spin_lock_irq(&hcd_root_hub_lock);
2913	hcd->rh_registered = 0;
2914	spin_unlock_irq(&hcd_root_hub_lock);
2915
2916	#ifdef CONFIG_PM
2917	cancel_work_sync(&hcd->wakeup_work);
2918	#endif
2919	cancel_work_sync(&hcd->died_work);
2920	mutex_lock(&usb_bus_idr_lock);
2921	usb_disconnect(&rhdev); /* Sets rhdev to NULL */
2922	mutex_unlock(&usb_bus_idr_lock);
2923	err_register_root_hub:	2802	err_register_root_hub:
2924	hcd->rh_pollable = 0;	2803	hcd->rh_pollable = 0;
2925	clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);	2804	clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
@@ -2963,8 +2842,6 @@ void usb_remove_hcd(struct usb_hcd *hcd) · 37 unmodified lines
2963	dev_info(hcd->self.controller, "remove, state %x\n", hcd->state);	2842	dev_info(hcd->self.controller, "remove, state %x\n", hcd->state);
2964		2843
2965	usb_get_dev(rhdev);	2844	usb_get_dev(rhdev);
2966	sysfs_remove_group(&rhdev->dev.kobj, &usb_bus_attr_group);
2967
2968	clear_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);	2845	clear_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
2969	if (HC_IS_RUNNING (hcd->state))	2846	if (HC_IS_RUNNING (hcd->state))
2970	hcd->state = HC_STATE_QUIESCING;	2847	hcd->state = HC_STATE_QUIESCING;

drivers/usb/core/message.c+2−2

@@ -2218,14 +2218,14 @@ int cdc_parse_cdc_header(struct usb_cdc_parsed_header *hdr, · 2217 unmodified lines
2218	(struct usb_cdc_dmm_desc *)buffer;	2218	(struct usb_cdc_dmm_desc *)buffer;
2219	break;	2219	break;
2220	case USB_CDC_MDLM_TYPE:	2220	case USB_CDC_MDLM_TYPE:
2221	if (elength < sizeof(struct usb_cdc_mdlm_desc *))	2221	if (elength < sizeof(struct usb_cdc_mdlm_desc))
2222	goto next_desc;	2222	goto next_desc;
2223	if (desc)	2223	if (desc)
2224	return -EINVAL;	2224	return -EINVAL;
2225	desc = (struct usb_cdc_mdlm_desc *)buffer;	2225	desc = (struct usb_cdc_mdlm_desc *)buffer;
2226	break;	2226	break;
2227	case USB_CDC_MDLM_DETAIL_TYPE:	2227	case USB_CDC_MDLM_DETAIL_TYPE:
2228	if (elength < sizeof(struct usb_cdc_mdlm_detail_desc *))	2228	if (elength < sizeof(struct usb_cdc_mdlm_detail_desc))
2229	goto next_desc;	2229	goto next_desc;
2230	if (detail)	2230	if (detail)
2231	return -EINVAL;	2231	return -EINVAL;

drivers/usb/core/sysfs.c+121−0

@@ -15,6 +15,7 @@ · 14 unmodified lines
15	#include <linux/kernel.h>	15	#include <linux/kernel.h>
16	#include <linux/string.h>	16	#include <linux/string.h>
17	#include <linux/usb.h>	17	#include <linux/usb.h>
		18	#include <linux/usb/hcd.h>
18	#include <linux/usb/quirks.h>	19	#include <linux/usb/quirks.h>
19	#include <linux/of.h>	20	#include <linux/of.h>
20	#include "usb.h"	21	#include "usb.h"
@@ -922,6 +923,116 @@ static struct bin_attribute dev_bin_attr_descriptors = { · 901 unmodified lines
922	.size = 18 + 65535, /* dev descr + max-size raw descriptor */	923	.size = 18 + 65535, /* dev descr + max-size raw descriptor */
923	};	924	};
924		925
		926	/*
		927	* Show & store the current value of authorized_default
		928	*/
		929	static ssize_t authorized_default_show(struct device *dev,
		930	struct device_attribute attr, char buf)
		931	{
		932	struct usb_device *rh_usb_dev = to_usb_device(dev);
		933	struct usb_bus *usb_bus = rh_usb_dev->bus;
		934	struct usb_hcd *hcd;
		935
		936	hcd = bus_to_hcd(usb_bus);
		937	return snprintf(buf, PAGE_SIZE, "%u\n", hcd->dev_policy);
		938	}
		939
		940	static ssize_t authorized_default_store(struct device *dev,
		941	struct device_attribute *attr,
		942	const char *buf, size_t size)
		943	{
		944	ssize_t result;
		945	unsigned int val;
		946	struct usb_device *rh_usb_dev = to_usb_device(dev);
		947	struct usb_bus *usb_bus = rh_usb_dev->bus;
		948	struct usb_hcd *hcd;
		949
		950	hcd = bus_to_hcd(usb_bus);
		951	result = sscanf(buf, "%u\n", &val);
		952	if (result == 1) {
		953	hcd->dev_policy = val <= USB_DEVICE_AUTHORIZE_INTERNAL ?
		954	val : USB_DEVICE_AUTHORIZE_ALL;
		955	result = size;
		956	} else {
		957	result = -EINVAL;
		958	}
		959	return result;
		960	}
		961	static DEVICE_ATTR_RW(authorized_default);
		962
		963	/*
		964	* interface_authorized_default_show - show default authorization status
		965	* for USB interfaces
		966	*
		967	* note: interface_authorized_default is the default value
		968	* for initializing the authorized attribute of interfaces
		969	*/
		970	static ssize_t interface_authorized_default_show(struct device *dev,
		971	struct device_attribute attr, char buf)
		972	{
		973	struct usb_device *usb_dev = to_usb_device(dev);
		974	struct usb_hcd *hcd = bus_to_hcd(usb_dev->bus);
		975
		976	return sprintf(buf, "%u\n", !!HCD_INTF_AUTHORIZED(hcd));
		977	}
		978
		979	/*
		980	* interface_authorized_default_store - store default authorization status
		981	* for USB interfaces
		982	*
		983	* note: interface_authorized_default is the default value
		984	* for initializing the authorized attribute of interfaces
		985	*/
		986	static ssize_t interface_authorized_default_store(struct device *dev,
		987	struct device_attribute attr, const char buf, size_t count)
		988	{
		989	struct usb_device *usb_dev = to_usb_device(dev);
		990	struct usb_hcd *hcd = bus_to_hcd(usb_dev->bus);
		991	int rc = count;
		992	bool val;
		993
		994	if (strtobool(buf, &val) != 0)
		995	return -EINVAL;
		996
		997	if (val)
		998	set_bit(HCD_FLAG_INTF_AUTHORIZED, &hcd->flags);
		999	else
		1000	clear_bit(HCD_FLAG_INTF_AUTHORIZED, &hcd->flags);
		1001
		1002	return rc;
		1003	}
		1004	static DEVICE_ATTR_RW(interface_authorized_default);
		1005
		1006	/* Group all the USB bus attributes */
		1007	static struct attribute *usb_bus_attrs[] = {
		1008	&dev_attr_authorized_default.attr,
		1009	&dev_attr_interface_authorized_default.attr,
		1010	NULL,
		1011	};
		1012
		1013	static const struct attribute_group usb_bus_attr_group = {
		1014	.name = NULL, /* we want them in the same directory */
		1015	.attrs = usb_bus_attrs,
		1016	};
		1017
		1018
		1019	static int add_default_authorized_attributes(struct device *dev)
		1020	{
		1021	int rc = 0;
		1022
		1023	if (is_usb_device(dev))
		1024	rc = sysfs_create_group(&dev->kobj, &usb_bus_attr_group);
		1025
		1026	return rc;
		1027	}
		1028
		1029	static void remove_default_authorized_attributes(struct device *dev)
		1030	{
		1031	if (is_usb_device(dev)) {
		1032	sysfs_remove_group(&dev->kobj, &usb_bus_attr_group);
		1033	}
		1034	}
		1035
925	int usb_create_sysfs_dev_files(struct usb_device *udev)	1036	int usb_create_sysfs_dev_files(struct usb_device *udev)
926	{	1037	{
927	struct device *dev = &udev->dev;	1038	struct device *dev = &udev->dev;
@@ -938,7 +1049,14 @@ int usb_create_sysfs_dev_files(struct usb_device *udev) · 10 unmodified lines
938	retval = add_power_attributes(dev);	1049	retval = add_power_attributes(dev);
939	if (retval)	1050	if (retval)
940	goto error;	1051	goto error;
		1052
		1053	if (is_root_hub(udev)) {
		1054	retval = add_default_authorized_attributes(dev);
		1055	if (retval)
		1056	goto error;
		1057	}
941	return retval;	1058	return retval;
		1059
942	error:	1060	error:
943	usb_remove_sysfs_dev_files(udev);	1061	usb_remove_sysfs_dev_files(udev);
944	return retval;	1062	return retval;
@@ -948,6 +1066,9 @@ void usb_remove_sysfs_dev_files(struct usb_device *udev) · 3 unmodified lines
948	{	1066	{
949	struct device *dev = &udev->dev;	1067	struct device *dev = &udev->dev;
950		1068
		1069	if (is_root_hub(udev))
		1070	remove_default_authorized_attributes(dev);
		1071
951	remove_power_attributes(dev);	1072	remove_power_attributes(dev);
952	remove_persist_attributes(dev);	1073	remove_persist_attributes(dev);
953	device_remove_bin_file(dev, &dev_bin_attr_descriptors);	1074	device_remove_bin_file(dev, &dev_bin_attr_descriptors);

drivers/usb/core/usb.h+5−0

 	return dev->type == &usb_port_device_type;
 }
+static inline int is_root_hub(struct usb_device *udev)
+{
+	return (udev->parent == NULL);
+}
 /* Do the same for device drivers and interface drivers. */
 static inline int is_usb_device_driver(struct device_driver *drv)

drivers/usb/dwc2/hcd.c+1−1

@@ -4608,7 +4608,7 @@ static int _dwc2_hcd_urb_enqueue(struct usb_hcd hcd, struct urb urb, · 4607 unmodified lines
4608		4608
4609	buf = urb->transfer_buffer;	4609	buf = urb->transfer_buffer;
4610		4610
4611	if (hcd->self.uses_dma) {	4611	if (hcd_uses_dma(hcd)) {
4612	if (!buf && (urb->transfer_dma & 3)) {	4612	if (!buf && (urb->transfer_dma & 3)) {
4613	dev_err(hsotg->dev,	4613	dev_err(hsotg->dev,
4614	"%s: unaligned transfer with no transfer_buffer",	4614	"%s: unaligned transfer with no transfer_buffer",

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

@@ -1976,6 +1976,7 @@ void composite_disconnect(struct usb_gadget *gadget) · 1975 unmodified lines
1976	* disconnect callbacks?	1976	* disconnect callbacks?
1977	*/	1977	*/
1978	spin_lock_irqsave(&cdev->lock, flags);	1978	spin_lock_irqsave(&cdev->lock, flags);
		1979	cdev->suspended = 0;
1979	if (cdev->config)	1980	if (cdev->config)
1980	reset_config(cdev);	1981	reset_config(cdev);
1981	if (cdev->driver->disconnect)	1982	if (cdev->driver->disconnect)

drivers/usb/gadget/function/f_mass_storage.c+18−10

@@ -261,7 +261,7 @@ struct fsg_common; · 260 unmodified lines
261	struct fsg_common {	261	struct fsg_common {
262	struct usb_gadget *gadget;	262	struct usb_gadget *gadget;
263	struct usb_composite_dev *cdev;	263	struct usb_composite_dev *cdev;
264	struct fsg_dev fsg, new_fsg;	264	struct fsg_dev *fsg;
265	wait_queue_head_t io_wait;	265	wait_queue_head_t io_wait;
266	wait_queue_head_t fsg_wait;	266	wait_queue_head_t fsg_wait;
267		267
@@ -290,6 +290,7 @@ struct fsg_common { · 22 unmodified lines
290	unsigned int bulk_out_maxpacket;	290	unsigned int bulk_out_maxpacket;
291	enum fsg_state state; /* For exception handling */	291	enum fsg_state state; /* For exception handling */
292	unsigned int exception_req_tag;	292	unsigned int exception_req_tag;
		293	void *exception_arg;
293		294
294	enum data_direction data_dir;	295	enum data_direction data_dir;
295	u32 data_size;	296	u32 data_size;
@@ -391,7 +392,8 @@ static int fsg_set_halt(struct fsg_dev fsg, struct usb_ep ep) · 95 unmodified lines
391		392
392	/* These routines may be called in process context or in_irq */	393	/* These routines may be called in process context or in_irq */
393		394
394	static void raise_exception(struct fsg_common *common, enum fsg_state new_state)	395	static void __raise_exception(struct fsg_common *common, enum fsg_state new_state,
		396	void *arg)
395	{	397	{
396	unsigned long flags;	398	unsigned long flags;
397		399
@@ -404,6 +406,7 @@ static void raise_exception(struct fsg_common *common, enum fsg_state new_state) · 6 unmodified lines
404	if (common->state <= new_state) {	406	if (common->state <= new_state) {
405	common->exception_req_tag = common->ep0_req_tag;	407	common->exception_req_tag = common->ep0_req_tag;
406	common->state = new_state;	408	common->state = new_state;
		409	common->exception_arg = arg;
407	if (common->thread_task)	410	if (common->thread_task)
408	send_sig_info(SIGUSR1, SEND_SIG_PRIV,	411	send_sig_info(SIGUSR1, SEND_SIG_PRIV,
409	common->thread_task);	412	common->thread_task);
@@ -411,6 +414,10 @@ static void raise_exception(struct fsg_common *common, enum fsg_state new_state) · 1 unmodified line
411	spin_unlock_irqrestore(&common->lock, flags);	414	spin_unlock_irqrestore(&common->lock, flags);
412	}	415	}
413		416
		417	static void raise_exception(struct fsg_common *common, enum fsg_state new_state)
		418	{
		419	__raise_exception(common, new_state, NULL);
		420	}
414		421
415	/-------------------------------------------------------------------------/	422	/-------------------------------------------------------------------------/
416		423
@@ -2285,16 +2292,16 @@ reset: · 1868 unmodified lines
2285	static int fsg_set_alt(struct usb_function *f, unsigned intf, unsigned alt)	2292	static int fsg_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
2286	{	2293	{
2287	struct fsg_dev *fsg = fsg_from_func(f);	2294	struct fsg_dev *fsg = fsg_from_func(f);
2288	fsg->common->new_fsg = fsg;	2295
2289	raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE);	2296	__raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE, fsg);
2290	return USB_GADGET_DELAYED_STATUS;	2297	return USB_GADGET_DELAYED_STATUS;
2291	}	2298	}
2292		2299
2293	static void fsg_disable(struct usb_function *f)	2300	static void fsg_disable(struct usb_function *f)
2294	{	2301	{
2295	struct fsg_dev *fsg = fsg_from_func(f);	2302	struct fsg_dev *fsg = fsg_from_func(f);
2296	fsg->common->new_fsg = NULL;	2303
2297	raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE);	2304	__raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE, NULL);
2298	}	2305	}
2299		2306
2300		2307
@@ -2307,6 +2314,7 @@ static void handle_exception(struct fsg_common *common) · 6 unmodified lines
2307	enum fsg_state old_state;	2314	enum fsg_state old_state;
2308	struct fsg_lun *curlun;	2315	struct fsg_lun *curlun;
2309	unsigned int exception_req_tag;	2316	unsigned int exception_req_tag;
		2317	struct fsg_dev *new_fsg;
2310		2318
2311	/*	2319	/*
2312	* Clear the existing signals. Anything but SIGUSR1 is converted	2320	* Clear the existing signals. Anything but SIGUSR1 is converted
@@ -2360,6 +2368,7 @@ static void handle_exception(struct fsg_common *common) · 47 unmodified lines
2360	common->next_buffhd_to_fill = &common->buffhds[0];	2368	common->next_buffhd_to_fill = &common->buffhds[0];
2361	common->next_buffhd_to_drain = &common->buffhds[0];	2369	common->next_buffhd_to_drain = &common->buffhds[0];
2362	exception_req_tag = common->exception_req_tag;	2370	exception_req_tag = common->exception_req_tag;
		2371	new_fsg = common->exception_arg;
2363	old_state = common->state;	2372	old_state = common->state;
2364	common->state = FSG_STATE_NORMAL;	2373	common->state = FSG_STATE_NORMAL;
2365		2374
@@ -2413,8 +2422,8 @@ static void handle_exception(struct fsg_common *common) · 47 unmodified lines
2413	break;	2422	break;
2414		2423
2415	case FSG_STATE_CONFIG_CHANGE:	2424	case FSG_STATE_CONFIG_CHANGE:
2416	do_set_interface(common, common->new_fsg);	2425	do_set_interface(common, new_fsg);
2417	if (common->new_fsg)	2426	if (new_fsg)
2418	usb_composite_setup_continue(common->cdev);	2427	usb_composite_setup_continue(common->cdev);
2419	break;	2428	break;
2420		2429
@@ -2989,8 +2998,7 @@ static void fsg_unbind(struct usb_configuration c, struct usb_function f) · 568 unmodified lines
2989		2998
2990	DBG(fsg, "unbind\n");	2999	DBG(fsg, "unbind\n");
2991	if (fsg->common->fsg == fsg) {	3000	if (fsg->common->fsg == fsg) {
2992	fsg->common->new_fsg = NULL;	3001	__raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE, NULL);
2993	raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE);
2994	/* FIXME: make interruptible or killable somehow? */	3002	/* FIXME: make interruptible or killable somehow? */
2995	wait_event(common->fsg_wait, common->fsg != fsg);	3003	wait_event(common->fsg_wait, common->fsg != fsg);
2996	}	3004	}

drivers/usb/gadget/udc/renesas_usb3.c+3−2

 #include <linux/pm_runtime.h>
 #include <linux/sizes.h>
 #include <linux/slab.h>
+#include <linux/string.h>
 #include <linux/sys_soc.h>
 #include <linux/uaccess.h>
 #include <linux/usb/ch9.h>
 	if (usb3->forced_b_device)
 		return -EBUSY;
-	if (!strncmp(buf, "host", strlen("host")))
+	if (sysfs_streq(buf, "host"))
 		new_mode_is_host = true;
-	else if (!strncmp(buf, "peripheral", strlen("peripheral")))
+	else if (sysfs_streq(buf, "peripheral"))
 		new_mode_is_host = false;
 	else
 		return -EINVAL;

drivers/usb/host/fotg210-hcd.c+4−0

 			/* see what we found out */
 			temp = check_reset_complete(fotg210, wIndex, status_reg,
 					fotg210_readl(fotg210, status_reg));
+			/* restart schedule */
+			fotg210->command |= CMD_RUN;
+			fotg210_writel(fotg210, fotg210->command, &fotg210->regs->command);
 		}
 		if (!(temp & (PORT_RESUME|PORT_RESET))) {

drivers/usb/host/xhci-rcar.c+7−2

 	 * pointers. So, this driver clears the AC64 bit of xhci->hcc_params
 	 * to call dma_set_coherent_mask(dev, DMA_BIT_MASK(32)) in
 	 * xhci_gen_setup().
+	 *
+	 * And, since the firmware/internal CPU control the USBSTS.STS_HALT
+	 * and the process speed is down when the roothub port enters U3,
+	 * long delay for the handshake of STS_HALT is neeed in xhci_suspend().
 	 */
 	if (xhci_rcar_is_gen2(hcd->self.controller) ||
-			xhci_rcar_is_gen3(hcd->self.controller))
+			xhci_rcar_is_gen3(hcd->self.controller)) {
-		xhci->quirks |= XHCI_NO_64BIT_SUPPORT;
+		xhci->quirks |= XHCI_NO_64BIT_SUPPORT | XHCI_SLOW_SUSPEND;
+	}
 	if (!xhci_rcar_wait_for_pll_active(hcd))
 		return -ETIMEDOUT;

drivers/usb/host/xhci.c+10−0

@@ -3089,8 +3089,18 @@ static void xhci_endpoint_reset(struct usb_hcd *hcd, · 3088 unmodified lines
3089	return;	3089	return;
3090	udev = (struct usb_device *) host_ep->hcpriv;	3090	udev = (struct usb_device *) host_ep->hcpriv;
3091	vdev = xhci->devs[udev->slot_id];	3091	vdev = xhci->devs[udev->slot_id];
		3092
		3093	/*
		3094	* vdev may be lost due to xHC restore error and re-initialization
		3095	* during S3/S4 resume. A new vdev will be allocated later by
		3096	* xhci_discover_or_reset_device()
		3097	*/
		3098	if (!udev->slot_id \|\| !vdev)
		3099	return;
3092	ep_index = xhci_get_endpoint_index(&host_ep->desc);	3100	ep_index = xhci_get_endpoint_index(&host_ep->desc);
3093	ep = &vdev->eps[ep_index];	3101	ep = &vdev->eps[ep_index];
		3102	if (!ep)
		3103	return;
3094		3104
3095	/* Bail out if toggle is already being cleared by a endpoint reset */	3105	/* Bail out if toggle is already being cleared by a endpoint reset */
3096	if (ep->ep_state & EP_HARD_CLEAR_TOGGLE) {	3106	if (ep->ep_state & EP_HARD_CLEAR_TOGGLE) {

drivers/usb/misc/iowarrior.c+4−3

 	dev = usb_get_intfdata(interface);
 	mutex_lock(&iowarrior_open_disc_lock);
 	usb_set_intfdata(interface, NULL);
+	/* prevent device read, write and ioctl */
+	dev->present = 0;
 	minor = dev->minor;
+	mutex_unlock(&iowarrior_open_disc_lock);
+	/* give back our minor - this will call close() locks need to be dropped at this point*/
-	/* give back our minor */
 	usb_deregister_dev(interface, &iowarrior_class);
 	mutex_lock(&dev->mutex);
 	/* prevent device read, write and ioctl */
-	dev->present = 0;
 	mutex_unlock(&dev->mutex);
-	mutex_unlock(&iowarrior_open_disc_lock);
 	if (dev->opened) {
 		/* There is a process that holds a filedescriptor to the device ,

drivers/usb/misc/rio500.c+27−16

         char *obuf, *ibuf;              /* transfer buffers */
         char bulk_in_ep, bulk_out_ep;   /* Endpoint assignments */
         wait_queue_head_t wait_q;       /* for timeouts */
+	struct mutex lock;          /* general race avoidance */
 };
 static DEFINE_MUTEX(rio500_mutex);
 	/* against disconnect() */
 	mutex_lock(&rio500_mutex);
+	mutex_lock(&(rio->lock));
 	if (rio->isopen || !rio->present) {
+		mutex_unlock(&(rio->lock));
 		mutex_unlock(&rio500_mutex);
 		return -EBUSY;
 	}
 	init_waitqueue_head(&rio->wait_q);
+	mutex_unlock(&(rio->lock));
 	dev_info(&rio->rio_dev->dev, "Rio opened.\n");
 	mutex_unlock(&rio500_mutex);
 	/* against disconnect() */
 	mutex_lock(&rio500_mutex);
+	mutex_lock(&(rio->lock));
 	rio->isopen = 0;
 	if (!rio->present) {
 	} else {
 		dev_info(&rio->rio_dev->dev, "Rio closed.\n");
 	}
+	mutex_unlock(&(rio->lock));
 	mutex_unlock(&rio500_mutex);
 	return 0;
 }
 	int retries;
 	int retval=0;
-	mutex_lock(&rio500_mutex);
+	mutex_lock(&(rio->lock));
         /* Sanity check to make sure rio is connected, powered, etc */
         if (rio->present == 0 || rio->rio_dev == NULL) {
 		retval = -ENODEV;
 err_out:
-	mutex_unlock(&rio500_mutex);
+	mutex_unlock(&(rio->lock));
 	return retval;
 }
 	int errn = 0;
 	int intr;
-	intr = mutex_lock_interruptible(&rio500_mutex);
+	intr = mutex_lock_interruptible(&(rio->lock));
 	if (intr)
 		return -EINTR;
         /* Sanity check to make sure rio is connected, powered, etc */
         if (rio->present == 0 || rio->rio_dev == NULL) {
-		mutex_unlock(&rio500_mutex);
+		mutex_unlock(&(rio->lock));
 		return -ENODEV;
 	}
 				goto error;
 			}
 			if (signal_pending(current)) {
-				mutex_unlock(&rio500_mutex);
+				mutex_unlock(&(rio->lock));
 				return bytes_written ? bytes_written : -EINTR;
 			}
 		buffer += copy_size;
 	} while (count > 0);
-	mutex_unlock(&rio500_mutex);
+	mutex_unlock(&(rio->lock));
 	return bytes_written ? bytes_written : -EIO;
 error:
-	mutex_unlock(&rio500_mutex);
+	mutex_unlock(&(rio->lock));
 	return errn;
 }
 	char *ibuf;
 	int intr;
-	intr = mutex_lock_interruptible(&rio500_mutex);
+	intr = mutex_lock_interruptible(&(rio->lock));
 	if (intr)
 		return -EINTR;
 	/* Sanity check to make sure rio is connected, powered, etc */
         if (rio->present == 0 || rio->rio_dev == NULL) {
-		mutex_unlock(&rio500_mutex);
+		mutex_unlock(&(rio->lock));
 		return -ENODEV;
 	}
 	while (count > 0) {
 		if (signal_pending(current)) {
-			mutex_unlock(&rio500_mutex);
+			mutex_unlock(&(rio->lock));
 			return read_count ? read_count : -EINTR;
 		}
 		if (!rio->rio_dev) {
-			mutex_unlock(&rio500_mutex);
+			mutex_unlock(&(rio->lock));
 			return -ENODEV;
 		}
 		this_read = (count >= IBUF_SIZE) ? IBUF_SIZE : count;
 			count = this_read = partial;
 		} else if (result == -ETIMEDOUT || result == 15) {	/* FIXME: 15 ??? */
 			if (!maxretry--) {
-				mutex_unlock(&rio500_mutex);
+				mutex_unlock(&(rio->lock));
 				dev_err(&rio->rio_dev->dev,
 					"read_rio: maxretry timeout\n");
 				return -ETIME;
 			finish_wait(&rio->wait_q, &wait);
 			continue;
 		} else if (result != -EREMOTEIO) {
-			mutex_unlock(&rio500_mutex);
+			mutex_unlock(&(rio->lock));
 			dev_err(&rio->rio_dev->dev,
 				"Read Whoops - result:%d partial:%u this_read:%u\n",
 				result, partial, this_read);
 			return -EIO;
 		} else {
-			mutex_unlock(&rio500_mutex);
+			mutex_unlock(&(rio->lock));
 			return (0);
 		}
 		if (this_read) {
 			if (copy_to_user(buffer, ibuf, this_read)) {
-				mutex_unlock(&rio500_mutex);
+				mutex_unlock(&(rio->lock));
 				return -EFAULT;
 			}
 			count -= this_read;
 			buffer += this_read;
 		}
 	}
-	mutex_unlock(&rio500_mutex);
+	mutex_unlock(&(rio->lock));
 	return read_count;
 }
 	}
 	dev_dbg(&intf->dev, "ibuf address:%p\n", rio->ibuf);
+	mutex_init(&(rio->lock));
 	usb_set_intfdata (intf, rio);
 	rio->present = 1;
 bail_out:
 	if (rio) {
 		usb_deregister_dev(intf, &usb_rio_class);
+		mutex_lock(&(rio->lock));
 		if (rio->isopen) {
 			rio->isopen = 0;
 			/* better let it finish - the release will do whats needed */
 			rio->rio_dev = NULL;
+			mutex_unlock(&(rio->lock));
 			mutex_unlock(&rio500_mutex);
 			return;
 		}
 		dev_info(&intf->dev, "USB Rio disconnected.\n");
 		rio->present = 0;
+		mutex_unlock(&(rio->lock));
 	}
 	mutex_unlock(&rio500_mutex);
 }

drivers/usb/misc/yurex.c+1−1

 	dev_dbg(&dev->interface->dev, "%s\n", __func__);
-	usb_put_dev(dev->udev);
 	if (dev->cntl_urb) {
 		usb_kill_urb(dev->cntl_urb);
 		kfree(dev->cntl_req);
 				dev->int_buffer, dev->urb->transfer_dma);
 		usb_free_urb(dev->urb);
 	}
+	usb_put_dev(dev->udev);
 	kfree(dev);
 }

drivers/usb/serial/option.c+10−0

 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x7B) },
 	{ USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x7C) },
+	/* Motorola devices */
+	{ USB_DEVICE_AND_INTERFACE_INFO(0x22b8, 0x2a70, 0xff, 0xff, 0xff) },	/* mdm6600 */
+	{ USB_DEVICE_AND_INTERFACE_INFO(0x22b8, 0x2e0a, 0xff, 0xff, 0xff) },	/* mdm9600 */
+	{ USB_DEVICE_AND_INTERFACE_INFO(0x22b8, 0x4281, 0x0a, 0x00, 0xfc) },	/* mdm ram dl */
+	{ USB_DEVICE_AND_INTERFACE_INFO(0x22b8, 0x900e, 0xff, 0xff, 0xff) },	/* mdm qc dl */
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V640) },
 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V620) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1428, 0xff, 0xff, 0xff),  /* Telewell TW-LTE 4G v2 */
 	  .driver_info = RSVD(2) },
 	{ USB_DEVICE_INTERFACE_CLASS(ZTE_VENDOR_ID, 0x1476, 0xff) },	/* GosunCn ZTE WeLink ME3630 (ECM/NCM mode) */
+	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1481, 0xff, 0x00, 0x00) }, /* ZTE MF871A */
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1533, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1534, 0xff, 0xff, 0xff) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1535, 0xff, 0xff, 0xff) },
 	  .driver_info = RSVD(4) },
 	{ USB_DEVICE_INTERFACE_CLASS(0x2001, 0x7e35, 0xff),			/* D-Link DWM-222 */
 	  .driver_info = RSVD(4) },
+	{ USB_DEVICE_INTERFACE_CLASS(0x2001, 0x7e3d, 0xff),			/* D-Link DWM-222 A2 */
+	  .driver_info = RSVD(4) },
 	{ USB_DEVICE_AND_INTERFACE_INFO(0x07d1, 0x3e01, 0xff, 0xff, 0xff) },	/* D-Link DWM-152/C1 */
 	{ USB_DEVICE_AND_INTERFACE_INFO(0x07d1, 0x3e02, 0xff, 0xff, 0xff) },	/* D-Link DWM-156/C1 */
 	{ USB_DEVICE_AND_INTERFACE_INFO(0x07d1, 0x7e11, 0xff, 0xff, 0xff) },	/* D-Link DWM-156/A3 */
 	{ USB_DEVICE_INTERFACE_CLASS(0x2020, 0x2031, 0xff),			/* Olicard 600 */
 	  .driver_info = RSVD(4) },
+	{ USB_DEVICE_INTERFACE_CLASS(0x2020, 0x2060, 0xff),			/* BroadMobi BM818 */
+	  .driver_info = RSVD(4) },
 	{ USB_DEVICE_INTERFACE_CLASS(0x2020, 0x4000, 0xff) },			/* OLICARD300 - MT6225 */
 	{ USB_DEVICE(INOVIA_VENDOR_ID, INOVIA_SEW858) },
 	{ USB_DEVICE(VIATELECOM_VENDOR_ID, VIATELECOM_PRODUCT_CDS7) },

drivers/usb/typec/tcpm/tcpm.c+41−17

@@ -379,7 +379,8 @@ static enum tcpm_state tcpm_default_state(struct tcpm_port *port) · 378 unmodified lines
379	return SNK_UNATTACHED;	379	return SNK_UNATTACHED;
380	else if (port->try_role == TYPEC_SOURCE)	380	else if (port->try_role == TYPEC_SOURCE)
381	return SRC_UNATTACHED;	381	return SRC_UNATTACHED;
382	else if (port->tcpc->config->default_role == TYPEC_SINK)	382	else if (port->tcpc->config &&
		383	port->tcpc->config->default_role == TYPEC_SINK)
383	return SNK_UNATTACHED;	384	return SNK_UNATTACHED;
384	/* Fall through to return SRC_UNATTACHED */	385	/* Fall through to return SRC_UNATTACHED */
385	} else if (port->port_type == TYPEC_PORT_SNK) {	386	} else if (port->port_type == TYPEC_PORT_SNK) {
@@ -586,7 +587,20 @@ static void tcpm_debugfs_init(struct tcpm_port *port) · 200 unmodified lines
586		587
587	static void tcpm_debugfs_exit(struct tcpm_port *port)	588	static void tcpm_debugfs_exit(struct tcpm_port *port)
588	{	589	{
		590	int i;
		591
		592	mutex_lock(&port->logbuffer_lock);
		593	for (i = 0; i < LOG_BUFFER_ENTRIES; i++) {
		594	kfree(port->logbuffer[i]);
		595	port->logbuffer[i] = NULL;
		596	}
		597	mutex_unlock(&port->logbuffer_lock);
		598
589	debugfs_remove(port->dentry);	599	debugfs_remove(port->dentry);
		600	if (list_empty(&rootdir->d_subdirs)) {
		601	debugfs_remove(rootdir);
		602	rootdir = NULL;
		603	}
590	}	604	}
591		605
592	#else	606	#else
@@ -1095,7 +1109,8 @@ static int tcpm_pd_svdm(struct tcpm_port port, const __le32 payload, int cnt, · 502 unmodified lines
1095	break;	1109	break;
1096	case CMD_ATTENTION:	1110	case CMD_ATTENTION:
1097	/* Attention command does not have response */	1111	/* Attention command does not have response */
1098	typec_altmode_attention(adev, p[1]);	1112	if (adev)
		1113	typec_altmode_attention(adev, p[1]);
1099	return 0;	1114	return 0;
1100	default:	1115	default:
1101	break;	1116	break;
@@ -1147,20 +1162,26 @@ static int tcpm_pd_svdm(struct tcpm_port port, const __le32 payload, int cnt, · 45 unmodified lines
1147	}	1162	}
1148	break;	1163	break;
1149	case CMD_ENTER_MODE:	1164	case CMD_ENTER_MODE:
1150	typec_altmode_update_active(pdev, true);	1165	if (adev && pdev) {
1151		1166	typec_altmode_update_active(pdev, true);
1152	if (typec_altmode_vdm(adev, p[0], &p[1], cnt)) {	1167
1153	response[0] = VDO(adev->svid, 1, CMD_EXIT_MODE);	1168	if (typec_altmode_vdm(adev, p[0], &p[1], cnt)) {
1154	response[0] \|= VDO_OPOS(adev->mode);	1169	response[0] = VDO(adev->svid, 1,
1155	return 1;	1170	CMD_EXIT_MODE);
		1171	response[0] \|= VDO_OPOS(adev->mode);
		1172	return 1;
		1173	}
1156	}	1174	}
1157	return 0;	1175	return 0;
1158	case CMD_EXIT_MODE:	1176	case CMD_EXIT_MODE:
1159	typec_altmode_update_active(pdev, false);	1177	if (adev && pdev) {
		1178	typec_altmode_update_active(pdev, false);
1160		1179
1161	/* Back to USB Operation */	1180	/* Back to USB Operation */
1162	WARN_ON(typec_altmode_notify(adev, TYPEC_STATE_USB,	1181	WARN_ON(typec_altmode_notify(adev,
1163	NULL));	1182	TYPEC_STATE_USB,
		1183	NULL));
		1184	}
1164	break;	1185	break;
1165	default:	1186	default:
1166	break;	1187	break;
@@ -1170,8 +1191,10 @@ static int tcpm_pd_svdm(struct tcpm_port port, const __le32 payload, int cnt, · 3 unmodified lines
1170	switch (cmd) {	1191	switch (cmd) {
1171	case CMD_ENTER_MODE:	1192	case CMD_ENTER_MODE:
1172	/* Back to USB Operation */	1193	/* Back to USB Operation */
1173	WARN_ON(typec_altmode_notify(adev, TYPEC_STATE_USB,	1194	if (adev)
1174	NULL));	1195	WARN_ON(typec_altmode_notify(adev,
		1196	TYPEC_STATE_USB,
		1197	NULL));
1175	break;	1198	break;
1176	default:	1199	default:
1177	break;	1200	break;
@@ -1182,7 +1205,8 @@ static int tcpm_pd_svdm(struct tcpm_port port, const __le32 payload, int cnt, · 4 unmodified lines
1182	}	1205	}
1183		1206
1184	/* Informing the alternate mode drivers about everything */	1207	/* Informing the alternate mode drivers about everything */
1185	typec_altmode_vdm(adev, p[0], &p[1], cnt);	1208	if (adev)
		1209	typec_altmode_vdm(adev, p[0], &p[1], cnt);
1186		1210
1187	return rlen;	1211	return rlen;
1188	}	1212	}
@@ -4114,7 +4138,7 @@ static int tcpm_try_role(const struct typec_capability *cap, int role) · 2925 unmodified lines
4114	mutex_lock(&port->lock);	4138	mutex_lock(&port->lock);
4115	if (tcpc->try_role)	4139	if (tcpc->try_role)
4116	ret = tcpc->try_role(tcpc, role);	4140	ret = tcpc->try_role(tcpc, role);
4117	if (!ret && !tcpc->config->try_role_hw)	4141	if (!ret && (!tcpc->config \|\| !tcpc->config->try_role_hw))
4118	port->try_role = role;	4142	port->try_role = role;
4119	port->try_src_count = 0;	4143	port->try_src_count = 0;
4120	port->try_snk_count = 0;	4144	port->try_snk_count = 0;
@@ -4701,7 +4725,7 @@ static int tcpm_copy_caps(struct tcpm_port *port, · 580 unmodified lines
4701	port->typec_caps.prefer_role = tcfg->default_role;	4725	port->typec_caps.prefer_role = tcfg->default_role;
4702	port->typec_caps.type = tcfg->type;	4726	port->typec_caps.type = tcfg->type;
4703	port->typec_caps.data = tcfg->data;	4727	port->typec_caps.data = tcfg->data;
4704	port->self_powered = port->tcpc->config->self_powered;	4728	port->self_powered = tcfg->self_powered;
4705		4729
4706	return 0;	4730	return 0;
4707	}	4731	}

drivers/usb/typec/ucsi/ucsi_ccg.c+1−1

@@ -1018,7 +1018,7 @@ release_fw: · 1017 unmodified lines
1018	******************************************************************************/	1018	******************************************************************************/
1019	static int ccg_fw_update(struct ucsi_ccg *uc, enum enum_flash_mode flash_mode)	1019	static int ccg_fw_update(struct ucsi_ccg *uc, enum enum_flash_mode flash_mode)
1020	{	1020	{
1021	int err;	1021	int err = 0;
1022		1022
1023	while (flash_mode != FLASH_NOT_NEEDED) {	1023	while (flash_mode != FLASH_NOT_NEEDED) {
1024	err = do_flash(uc, flash_mode);	1024	err = do_flash(uc, flash_mode);

drivers/video/fbdev/omap/omapfb_main.c+8−0

 		return 0;
 	case 12:
 		var->bits_per_pixel = 16;
+		/* fall through */
 	case 16:
 		if (plane->fbdev->panel->bpp == 12)
 			plane->color_mode = OMAPFB_COLOR_RGB444;
 	case OMAPFB_ACTIVE:
 		for (i = 0; i < fbdev->mem_desc.region_cnt; i++)
 			unregister_framebuffer(fbdev->fb_info[i]);
+		/* fall through */
 	case 7:
 		omapfb_unregister_sysfs(fbdev);
+		/* fall through */
 	case 6:
 		if (fbdev->panel->disable)
 			fbdev->panel->disable(fbdev->panel);
+		/* fall through */
 	case 5:
 		omapfb_set_update_mode(fbdev, OMAPFB_UPDATE_DISABLED);
+		/* fall through */
 	case 4:
 		planes_cleanup(fbdev);
+		/* fall through */
 	case 3:
 		ctrl_cleanup(fbdev);
+		/* fall through */
 	case 2:
 		if (fbdev->panel->cleanup)
 			fbdev->panel->cleanup(fbdev->panel);
+		/* fall through */
 	case 1:
 		dev_set_drvdata(fbdev->dev, NULL);
 		kfree(fbdev);

drivers/watchdog/ar7_wdt.c+1−0

@@ -235,6 +235,7 @@ static long ar7_wdt_ioctl(struct file *file, · 234 unmodified lines
235	ar7_wdt_update_margin(new_margin);	235	ar7_wdt_update_margin(new_margin);
236	ar7_wdt_kick(1);	236	ar7_wdt_kick(1);
237	spin_unlock(&wdt_lock);	237	spin_unlock(&wdt_lock);
		238	/* Fall through */
238		239
239	case WDIOC_GETTIMEOUT:	240	case WDIOC_GETTIMEOUT:
240	if (put_user(margin, (int *)arg))	241	if (put_user(margin, (int *)arg))

drivers/watchdog/pcwd.c+1−1

@@ -651,7 +651,7 @@ static long pcwd_ioctl(struct file *file, unsigned int cmd, unsigned long arg) · 650 unmodified lines
651	return -EINVAL;	651	return -EINVAL;
652		652
653	pcwd_keepalive();	653	pcwd_keepalive();
654	/* Fall */	654	/* Fall through */
655		655
656	case WDIOC_GETTIMEOUT:	656	case WDIOC_GETTIMEOUT:
657	return put_user(heartbeat, argp);	657	return put_user(heartbeat, argp);

drivers/watchdog/riowd.c+1−1

@@ -134,7 +134,7 @@ static long riowd_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) · 133 unmodified lines
134	return -EINVAL;	134	return -EINVAL;
135	riowd_timeout = (new_margin + 59) / 60;	135	riowd_timeout = (new_margin + 59) / 60;
136	riowd_writereg(p, riowd_timeout, WDTO_INDEX);	136	riowd_writereg(p, riowd_timeout, WDTO_INDEX);
137	/* Fall */	137	/* Fall through */
138		138
139	case WDIOC_GETTIMEOUT:	139	case WDIOC_GETTIMEOUT:
140	return put_user(riowd_timeout * 60, (int __user *)argp);	140	return put_user(riowd_timeout * 60, (int __user *)argp);

drivers/watchdog/sb_wdog.c+1−0

@@ -202,6 +202,7 @@ static long sbwdog_ioctl(struct file *file, unsigned int cmd, · 201 unmodified lines
202	timeout = time;	202	timeout = time;
203	sbwdog_set(user_dog, timeout);	203	sbwdog_set(user_dog, timeout);
204	sbwdog_pet(user_dog);	204	sbwdog_pet(user_dog);
		205	/* Fall through */
205		206
206	case WDIOC_GETTIMEOUT:	207	case WDIOC_GETTIMEOUT:
207	/*	208	/*

drivers/watchdog/scx200_wdt.c+1−0

@@ -186,6 +186,7 @@ static long scx200_wdt_ioctl(struct file *file, unsigned int cmd, · 185 unmodified lines
186	margin = new_margin;	186	margin = new_margin;
187	scx200_wdt_update_margin();	187	scx200_wdt_update_margin();
188	scx200_wdt_ping();	188	scx200_wdt_ping();
		189	/* Fall through */
189	case WDIOC_GETTIMEOUT:	190	case WDIOC_GETTIMEOUT:
190	if (put_user(margin, p))	191	if (put_user(margin, p))
191	return -EFAULT;	192	return -EFAULT;

drivers/watchdog/wdt.c+1−1

@@ -389,7 +389,7 @@ static long wdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg) · 388 unmodified lines
389	if (wdt_set_heartbeat(new_heartbeat))	389	if (wdt_set_heartbeat(new_heartbeat))
390	return -EINVAL;	390	return -EINVAL;
391	wdt_ping();	391	wdt_ping();
392	/* Fall */	392	/* Fall through */
393	case WDIOC_GETTIMEOUT:	393	case WDIOC_GETTIMEOUT:
394	return put_user(heartbeat, p);	394	return put_user(heartbeat, p);
395	default:	395	default:

drivers/watchdog/wdt977.c+1−1

@@ -398,7 +398,7 @@ static long wdt977_ioctl(struct file *file, unsigned int cmd, · 397 unmodified lines
398	return -EINVAL;	398	return -EINVAL;
399		399
400	wdt977_keepalive();	400	wdt977_keepalive();
401	/* Fall */	401	/* Fall through */
402		402
403	case WDIOC_GETTIMEOUT:	403	case WDIOC_GETTIMEOUT:
404	return put_user(timeout, uarg.i);	404	return put_user(timeout, uarg.i);

fs/afs/cmservice.c+3−7

 	struct afs_call *call = container_of(work, struct afs_call, work);
 	struct afs_uuid *r = call->request;
-	struct {
-		__be32	match;
-	} reply;
 	_enter("");
 	if (memcmp(r, &call->net->uuid, sizeof(call->net->uuid)) == 0)
-		reply.match = htonl(0);
+		afs_send_empty_reply(call);
 	else
-		reply.match = htonl(1);
+		rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
+					1, 1, "K-1");
-	afs_send_simple_reply(call, &reply, sizeof(reply));
 	afs_put_call(call);
 	_leave("");
 }

fs/afs/dir.c+73−16

  * iterate through the data blob that lists the contents of an AFS directory
  */
 static int afs_dir_iterate(struct inode *dir, struct dir_context *ctx,
-			   struct key *key)
+			   struct key *key, afs_dataversion_t *_dir_version)
 {
 	struct afs_vnode *dvnode = AFS_FS_I(dir);
 	struct afs_xdr_dir_page *dbuf;
 	req = afs_read_dir(dvnode, key);
 	if (IS_ERR(req))
 		return PTR_ERR(req);
+	*_dir_version = req->data_version;
 	/* round the file position up to the next entry boundary */
 	ctx->pos += sizeof(union afs_xdr_dirent) - 1;
  */
 static int afs_readdir(struct file *file, struct dir_context *ctx)
 {
-	return afs_dir_iterate(file_inode(file), ctx, afs_file_key(file));
+	afs_dataversion_t dir_version;
+	return afs_dir_iterate(file_inode(file), ctx, afs_file_key(file),
+			       &dir_version);
 }
 /*
  * - just returns the FID the dentry name maps to if found
  */
 static int afs_do_lookup_one(struct inode *dir, struct dentry *dentry,
-			     struct afs_fid *fid, struct key *key)
+			     struct afs_fid *fid, struct key *key,
+			     afs_dataversion_t *_dir_version)
 {
 	struct afs_super_info *as = dir->i_sb->s_fs_info;
 	struct afs_lookup_one_cookie cookie = {
 	_enter("{%lu},%p{%pd},", dir->i_ino, dentry, dentry);
 	/* search the directory */
-	ret = afs_dir_iterate(dir, &cookie.ctx, key);
+	ret = afs_dir_iterate(dir, &cookie.ctx, key, _dir_version);
 	if (ret < 0) {
 		_leave(" = %d [iter]", ret);
 		return ret;
 	struct afs_server *server;
 	struct afs_vnode *dvnode = AFS_FS_I(dir), *vnode;
 	struct inode *inode = NULL, *ti;
+	afs_dataversion_t data_version = READ_ONCE(dvnode->status.data_version);
 	int ret, i;
 	_enter("{%lu},%p{%pd},", dir->i_ino, dentry, dentry);
 		cookie->fids[i].vid = as->volume->vid;
 	/* search the directory */
-	ret = afs_dir_iterate(dir, &cookie->ctx, key);
+	ret = afs_dir_iterate(dir, &cookie->ctx, key, &data_version);
 	if (ret < 0) {
 		inode = ERR_PTR(ret);
 		goto out;
 	}
+	dentry->d_fsdata = (void *)(unsigned long)data_version;
 	inode = ERR_PTR(-ENOENT);
 	if (!cookie->found)
 		goto out;
 	struct dentry *parent;
 	struct inode *inode;
 	struct key *key;
-	long dir_version, de_version;
+	afs_dataversion_t dir_version;
+	long de_version;
 	int ret;
 	if (flags & LOOKUP_RCU)
 	 * on a 32-bit system, we only have 32 bits in the dentry to store the
 	 * version.
 	 */
-	dir_version = (long)dir->status.data_version;
+	dir_version = dir->status.data_version;
 	de_version = (long)dentry->d_fsdata;
-	if (de_version == dir_version)
+	if (de_version == (long)dir_version)
-		goto out_valid;
+		goto out_valid_noupdate;
-	dir_version = (long)dir->invalid_before;
+	dir_version = dir->invalid_before;
-	if (de_version - dir_version >= 0)
+	if (de_version - (long)dir_version >= 0)
 		goto out_valid;
 	_debug("dir modified");
 	afs_stat_v(dir, n_reval);
 	/* search the directory for this vnode */
-	ret = afs_do_lookup_one(&dir->vfs_inode, dentry, &fid, key);
+	ret = afs_do_lookup_one(&dir->vfs_inode, dentry, &fid, key, &dir_version);
 	switch (ret) {
 	case 0:
 		/* the filename maps to something */
 	}
 out_valid:
-	dentry->d_fsdata = (void *)dir_version;
+	dentry->d_fsdata = (void *)(unsigned long)dir_version;
+out_valid_noupdate:
 	dput(parent);
 	key_put(key);
 	_leave(" = 1 [valid]");
 	iget_data->cb_s_break = fc->cbi->server->cb_s_break;
 }
+/*
+ * Note that a dentry got changed.  We need to set d_fsdata to the data version
+ * number derived from the result of the operation.  It doesn't matter if
+ * d_fsdata goes backwards as we'll just revalidate.
+ */
+static void afs_update_dentry_version(struct afs_fs_cursor *fc,
+				      struct dentry *dentry,
+				      struct afs_status_cb *scb)
+{
+	if (fc->ac.error == 0)
+		dentry->d_fsdata =
+			(void *)(unsigned long)scb->status.data_version;
+}
 /*
  * create a directory on an AFS filesystem
  */
 		afs_check_for_remote_deletion(&fc, dvnode);
 		afs_vnode_commit_status(&fc, dvnode, fc.cb_break,
 					&data_version, &scb[0]);
+		afs_update_dentry_version(&fc, dentry, &scb[0]);
 		afs_vnode_new_inode(&fc, dentry, &iget_data, &scb[1]);
 		ret = afs_end_vnode_operation(&fc);
 		if (ret < 0)
 		afs_vnode_commit_status(&fc, dvnode, fc.cb_break,
 					&data_version, scb);
+		afs_update_dentry_version(&fc, dentry, scb);
 		ret = afs_end_vnode_operation(&fc);
 		if (ret == 0) {
 			afs_dir_remove_subdir(dentry);
 					&data_version, &scb[0]);
 		afs_vnode_commit_status(&fc, vnode, fc.cb_break_2,
 					&data_version_2, &scb[1]);
+		afs_update_dentry_version(&fc, dentry, &scb[0]);
 		ret = afs_end_vnode_operation(&fc);
 		if (ret == 0 && !(scb[1].have_status || scb[1].have_error))
 			ret = afs_dir_remove_link(dvnode, dentry, key);
 		afs_check_for_remote_deletion(&fc, dvnode);
 		afs_vnode_commit_status(&fc, dvnode, fc.cb_break,
 					&data_version, &scb[0]);
+		afs_update_dentry_version(&fc, dentry, &scb[0]);
 		afs_vnode_new_inode(&fc, dentry, &iget_data, &scb[1]);
 		ret = afs_end_vnode_operation(&fc);
 		if (ret < 0)
 		afs_vnode_commit_status(&fc, vnode, fc.cb_break_2,
 					NULL, &scb[1]);
 		ihold(&vnode->vfs_inode);
+		afs_update_dentry_version(&fc, dentry, &scb[0]);
 		d_instantiate(dentry, &vnode->vfs_inode);
 		mutex_unlock(&vnode->io_lock);
 		afs_check_for_remote_deletion(&fc, dvnode);
 		afs_vnode_commit_status(&fc, dvnode, fc.cb_break,
 					&data_version, &scb[0]);
+		afs_update_dentry_version(&fc, dentry, &scb[0]);
 		afs_vnode_new_inode(&fc, dentry, &iget_data, &scb[1]);
 		ret = afs_end_vnode_operation(&fc);
 		if (ret < 0)
 		}
 	}
+	/* This bit is potentially nasty as there's a potential race with
+	 * afs_d_revalidate{,_rcu}().  We have to change d_fsdata on the dentry
+	 * to reflect it's new parent's new data_version after the op, but
+	 * d_revalidate may see old_dentry between the op having taken place
+	 * and the version being updated.
+	 *
+	 * So drop the old_dentry for now to make other threads go through
+	 * lookup instead - which we hold a lock against.
+	 */
+	d_drop(old_dentry);
 	ret = -ERESTARTSYS;
 	if (afs_begin_vnode_operation(&fc, orig_dvnode, key, true)) {
 		afs_dataversion_t orig_data_version;
 		if (orig_dvnode != new_dvnode) {
 			if (mutex_lock_interruptible_nested(&new_dvnode->io_lock, 1) < 0) {
 				afs_end_vnode_operation(&fc);
-				goto error_rehash;
+				goto error_rehash_old;
 			}
-			new_data_version = new_dvnode->status.data_version;
+			new_data_version = new_dvnode->status.data_version + 1;
 		} else {
 			new_data_version = orig_data_version;
 			new_scb = &scb[0];
 		}
 		ret = afs_end_vnode_operation(&fc);
 		if (ret < 0)
-			goto error_rehash;
+			goto error_rehash_old;
 	}
 	if (ret == 0) {
 				drop_nlink(new_inode);
 			spin_unlock(&new_inode->i_lock);
 		}
+		/* Now we can update d_fsdata on the dentries to reflect their
+		 * new parent's data_version.
+		 *
+		 * Note that if we ever implement RENAME_EXCHANGE, we'll have
+		 * to update both dentries with opposing dir versions.
+		 */
+		if (new_dvnode != orig_dvnode) {
+			afs_update_dentry_version(&fc, old_dentry, &scb[1]);
+			afs_update_dentry_version(&fc, new_dentry, &scb[1]);
+		} else {
+			afs_update_dentry_version(&fc, old_dentry, &scb[0]);
+			afs_update_dentry_version(&fc, new_dentry, &scb[0]);
+		}
 		d_move(old_dentry, new_dentry);
 		goto error_tmp;
 	}
+error_rehash_old:
+	d_rehash(new_dentry);
 error_rehash:
 	if (rehash)
 		d_rehash(rehash);

fs/afs/file.c+7−5

@@ -191,11 +191,13 @@ void afs_put_read(struct afs_read *req) · 190 unmodified lines
191	int i;	191	int i;
192		192
193	if (refcount_dec_and_test(&req->usage)) {	193	if (refcount_dec_and_test(&req->usage)) {
194	for (i = 0; i < req->nr_pages; i++)	194	if (req->pages) {
195	if (req->pages[i])	195	for (i = 0; i < req->nr_pages; i++)
196	put_page(req->pages[i]);	196	if (req->pages[i])
197	if (req->pages != req->array)	197	put_page(req->pages[i]);
198	kfree(req->pages);	198	if (req->pages != req->array)
		199	kfree(req->pages);
		200	}
199	kfree(req);	201	kfree(req);
200	}	202	}
201	}	203	}

fs/afs/vlclient.c+6−5

 		struct afs_uuid__xdr *xdr;
 		struct afs_uuid *uuid;
 		int j;
+		int n = entry->nr_servers;
 		tmp = ntohl(uvldb->serverFlags[i]);
 		if (tmp & AFS_VLSF_DONTUSE ||
 		    (new_only && !(tmp & AFS_VLSF_NEWREPSITE)))
 			continue;
 		if (tmp & AFS_VLSF_RWVOL) {
-			entry->fs_mask[i] |= AFS_VOL_VTM_RW;
+			entry->fs_mask[n] |= AFS_VOL_VTM_RW;
 			if (vlflags & AFS_VLF_BACKEXISTS)
-				entry->fs_mask[i] |= AFS_VOL_VTM_BAK;
+				entry->fs_mask[n] |= AFS_VOL_VTM_BAK;
 		}
 		if (tmp & AFS_VLSF_ROVOL)
-			entry->fs_mask[i] |= AFS_VOL_VTM_RO;
+			entry->fs_mask[n] |= AFS_VOL_VTM_RO;
-		if (!entry->fs_mask[i])
+		if (!entry->fs_mask[n])
 			continue;
 		xdr = &uvldb->serverNumber[i];
-		uuid = (struct afs_uuid *)&entry->fs_server[i];
+		uuid = (struct afs_uuid *)&entry->fs_server[n];
 		uuid->time_low			= xdr->time_low;
 		uuid->time_mid			= htons(ntohl(xdr->time_mid));
 		uuid->time_hi_and_version	= htons(ntohl(xdr->time_hi_and_version));

fs/block_dev.c+12−52

 	struct bio *bio;
 	bool is_poll = (iocb->ki_flags & IOCB_HIPRI) != 0;
 	bool is_read = (iov_iter_rw(iter) == READ), is_sync;
-	bool nowait = (iocb->ki_flags & IOCB_NOWAIT) != 0;
 	loff_t pos = iocb->ki_pos;
 	blk_qc_t qc = BLK_QC_T_NONE;
-	gfp_t gfp;
+	int ret = 0;
-	ssize_t ret;
 	if ((pos | iov_iter_alignment(iter)) &
 	    (bdev_logical_block_size(bdev) - 1))
 		return -EINVAL;
-	if (nowait)
+	bio = bio_alloc_bioset(GFP_KERNEL, nr_pages, &blkdev_dio_pool);
-		gfp = GFP_NOWAIT;
-	else
-		gfp = GFP_KERNEL;
-	bio = bio_alloc_bioset(gfp, nr_pages, &blkdev_dio_pool);
-	if (!bio)
-		return -EAGAIN;
 	dio = container_of(bio, struct blkdev_dio, bio);
 	dio->is_sync = is_sync = is_sync_kiocb(iocb);
 	if (!is_poll)
 		blk_start_plug(&plug);
-	ret = 0;
 	for (;;) {
-		int err;
 		bio_set_dev(bio, bdev);
 		bio->bi_iter.bi_sector = pos >> 9;
 		bio->bi_write_hint = iocb->ki_hint;
 		bio->bi_end_io = blkdev_bio_end_io;
 		bio->bi_ioprio = iocb->ki_ioprio;
-		err = bio_iov_iter_get_pages(bio, iter);
+		ret = bio_iov_iter_get_pages(bio, iter);
-		if (unlikely(err)) {
+		if (unlikely(ret)) {
-			if (!ret)
-				ret = err;
 			bio->bi_status = BLK_STS_IOERR;
 			bio_endio(bio);
 			break;
 			task_io_account_write(bio->bi_iter.bi_size);
 		}
-		/*
-		 * Tell underlying layer to not block for resource shortage.
-		 * And if we would have blocked, return error inline instead
-		 * of through the bio->bi_end_io() callback.
-		 */
-		if (nowait)
-			bio->bi_opf |= (REQ_NOWAIT | REQ_NOWAIT_INLINE);
 		dio->size += bio->bi_iter.bi_size;
 		pos += bio->bi_iter.bi_size;
 			}
 			qc = submit_bio(bio);
-			if (qc == BLK_QC_T_EAGAIN) {
-				if (!ret)
-					ret = -EAGAIN;
-				goto error;
-			}
-			ret = dio->size;
 			if (polled)
 				WRITE_ONCE(iocb->ki_cookie, qc);
 			atomic_inc(&dio->ref);
 		}
-		qc = submit_bio(bio);
+		submit_bio(bio);
-		if (qc == BLK_QC_T_EAGAIN) {
+		bio = bio_alloc(GFP_KERNEL, nr_pages);
-			if (!ret)
-				ret = -EAGAIN;
-			goto error;
-		}
-		ret = dio->size;
-		bio = bio_alloc(gfp, nr_pages);
-		if (!bio) {
-			if (!ret)
-				ret = -EAGAIN;
-			goto error;
-		}
 	}
 	if (!is_poll)
 	}
 	__set_current_state(TASK_RUNNING);
-out:
 	if (!ret)
 		ret = blk_status_to_errno(dio->bio.bi_status);
+	if (likely(!ret))
+		ret = dio->size;
 	bio_put(&dio->bio);
 	return ret;
-error:
-	if (!is_poll)
-		blk_finish_plug(&plug);
-	goto out;
 }
 static ssize_t
 		/* finish claiming */
 		mutex_lock(&bdev->bd_mutex);
-		bd_finish_claiming(bdev, whole, holder);
+		if (!res)
+			bd_finish_claiming(bdev, whole, holder);
+		else
+			bd_abort_claiming(bdev, whole, holder);
 		/*
 		 * Block event polling for write claims if requested.  Any
 		 * write holder makes the write_holder state stick until

fs/btrfs/ctree.h+0−4

 struct raid_kobject {
 	u64 flags;
 	struct kobject kobj;
-	struct list_head list;
 };
 /*
 	u32 thread_pool_size;
 	struct kobject *space_info_kobj;
-	struct list_head pending_raid_kobjs;
-	spinlock_t pending_raid_kobjs_lock; /* uncontended */
 	u64 total_pinned;
 int btrfs_make_block_group(struct btrfs_trans_handle *trans,
 			   u64 bytes_used, u64 type, u64 chunk_offset,
 			   u64 size);
-void btrfs_add_raid_kobjects(struct btrfs_fs_info *fs_info);
 struct btrfs_trans_handle *btrfs_start_trans_remove_block_group(
 				struct btrfs_fs_info *fs_info,
 				const u64 chunk_offset);

fs/btrfs/disk-io.c+0−2

 	INIT_LIST_HEAD(&fs_info->delayed_iputs);
 	INIT_LIST_HEAD(&fs_info->delalloc_roots);
 	INIT_LIST_HEAD(&fs_info->caching_block_groups);
-	INIT_LIST_HEAD(&fs_info->pending_raid_kobjs);
-	spin_lock_init(&fs_info->pending_raid_kobjs_lock);
 	spin_lock_init(&fs_info->delalloc_root_lock);
 	spin_lock_init(&fs_info->trans_lock);
 	spin_lock_init(&fs_info->fs_roots_radix_lock);

fs/btrfs/extent-tree.c+35−36

@@ -4,6 +4,7 @@ · 3 unmodified lines
4	*/	4	*/
5		5
6	#include <linux/sched.h>	6	#include <linux/sched.h>
		7	#include <linux/sched/mm.h>
7	#include <linux/sched/signal.h>	8	#include <linux/sched/signal.h>
8	#include <linux/pagemap.h>	9	#include <linux/pagemap.h>
9	#include <linux/writeback.h>	10	#include <linux/writeback.h>
@@ -7888,33 +7889,6 @@ int btrfs_free_block_groups(struct btrfs_fs_info *info) · 7878 unmodified lines
7888	return 0;	7889	return 0;
7889	}	7890	}
7890		7891
7891	/* link_block_group will queue up kobjects to add when we're reclaim-safe */
7892	void btrfs_add_raid_kobjects(struct btrfs_fs_info *fs_info)
7893	{
7894	struct btrfs_space_info *space_info;
7895	struct raid_kobject *rkobj;
7896	LIST_HEAD(list);
7897	int ret = 0;
7898
7899	spin_lock(&fs_info->pending_raid_kobjs_lock);
7900	list_splice_init(&fs_info->pending_raid_kobjs, &list);
7901	spin_unlock(&fs_info->pending_raid_kobjs_lock);
7902
7903	list_for_each_entry(rkobj, &list, list) {
7904	space_info = btrfs_find_space_info(fs_info, rkobj->flags);
7905
7906	ret = kobject_add(&rkobj->kobj, &space_info->kobj,
7907	"%s", btrfs_bg_type_to_raid_name(rkobj->flags));
7908	if (ret) {
7909	kobject_put(&rkobj->kobj);
7910	break;
7911	}
7912	}
7913	if (ret)
7914	btrfs_warn(fs_info,
7915	"failed to add kobject for block cache, ignoring");
7916	}
7917
7918	static void link_block_group(struct btrfs_block_group_cache *cache)	7892	static void link_block_group(struct btrfs_block_group_cache *cache)
7919	{	7893	{
7920	struct btrfs_space_info *space_info = cache->space_info;	7894	struct btrfs_space_info *space_info = cache->space_info;
@@ -7929,18 +7903,36 @@ static void link_block_group(struct btrfs_block_group_cache *cache) · 8 unmodified lines
7929	up_write(&space_info->groups_sem);	7903	up_write(&space_info->groups_sem);
7930		7904
7931	if (first) {	7905	if (first) {
7932	struct raid_kobject rkobj = kzalloc(sizeof(rkobj), GFP_NOFS);	7906	struct raid_kobject *rkobj;
		7907	unsigned int nofs_flag;
		7908	int ret;
		7909
		7910	/*
		7911	* Setup a NOFS context because kobject_add(), deep in its call
		7912	* chain, does GFP_KERNEL allocations, and we are often called
		7913	* in a context where if reclaim is triggered we can deadlock
		7914	* (we are either holding a transaction handle or some lock
		7915	* required for a transaction commit).
		7916	*/
		7917	nofs_flag = memalloc_nofs_save();
		7918	rkobj = kzalloc(sizeof(*rkobj), GFP_KERNEL);
7933	if (!rkobj) {	7919	if (!rkobj) {
		7920	memalloc_nofs_restore(nofs_flag);
7934	btrfs_warn(cache->fs_info,	7921	btrfs_warn(cache->fs_info,
7935	"couldn't alloc memory for raid level kobject");	7922	"couldn't alloc memory for raid level kobject");
7936	return;	7923	return;
7937	}	7924	}
7938	rkobj->flags = cache->flags;	7925	rkobj->flags = cache->flags;
7939	kobject_init(&rkobj->kobj, &btrfs_raid_ktype);	7926	kobject_init(&rkobj->kobj, &btrfs_raid_ktype);
7940		7927	ret = kobject_add(&rkobj->kobj, &space_info->kobj, "%s",
7941	spin_lock(&fs_info->pending_raid_kobjs_lock);	7928	btrfs_bg_type_to_raid_name(rkobj->flags));
7942	list_add_tail(&rkobj->list, &fs_info->pending_raid_kobjs);	7929	memalloc_nofs_restore(nofs_flag);
7943	spin_unlock(&fs_info->pending_raid_kobjs_lock);	7930	if (ret) {
		7931	kobject_put(&rkobj->kobj);
		7932	btrfs_warn(fs_info,
		7933	"failed to add kobject for block cache, ignoring");
		7934	return;
		7935	}
7944	space_info->block_group_kobjs[index] = &rkobj->kobj;	7936	space_info->block_group_kobjs[index] = &rkobj->kobj;
7945	}	7937	}
7946	}	7938	}
@@ -8206,7 +8198,6 @@ int btrfs_read_block_groups(struct btrfs_fs_info *info) · 259 unmodified lines
8206	inc_block_group_ro(cache, 1);	8198	inc_block_group_ro(cache, 1);
8207	}	8199	}
8208		8200
8209	btrfs_add_raid_kobjects(info);
8210	btrfs_init_global_block_rsv(info);	8201	btrfs_init_global_block_rsv(info);
8211	ret = check_chunk_block_group_mappings(info);	8202	ret = check_chunk_block_group_mappings(info);
8212	error:	8203	error:
@@ -8975,6 +8966,7 @@ int btrfs_trim_fs(struct btrfs_fs_info fs_info, struct fstrim_range range) · 762 unmodified lines
8975	struct btrfs_device *device;	8966	struct btrfs_device *device;
8976	struct list_head *devices;	8967	struct list_head *devices;
8977	u64 group_trimmed;	8968	u64 group_trimmed;
		8969	u64 range_end = U64_MAX;
8978	u64 start;	8970	u64 start;
8979	u64 end;	8971	u64 end;
8980	u64 trimmed = 0;	8972	u64 trimmed = 0;
@@ -8984,16 +8976,23 @@ int btrfs_trim_fs(struct btrfs_fs_info fs_info, struct fstrim_range range) · 3 unmodified lines
8984	int dev_ret = 0;	8976	int dev_ret = 0;
8985	int ret = 0;	8977	int ret = 0;
8986		8978
		8979	/*
		8980	* Check range overflow if range->len is set.
		8981	* The default range->len is U64_MAX.
		8982	*/
		8983	if (range->len != U64_MAX &&
		8984	check_add_overflow(range->start, range->len, &range_end))
		8985	return -EINVAL;
		8986
8987	cache = btrfs_lookup_first_block_group(fs_info, range->start);	8987	cache = btrfs_lookup_first_block_group(fs_info, range->start);
8988	for (; cache; cache = next_block_group(cache)) {	8988	for (; cache; cache = next_block_group(cache)) {
8989	if (cache->key.objectid >= (range->start + range->len)) {	8989	if (cache->key.objectid >= range_end) {
8990	btrfs_put_block_group(cache);	8990	btrfs_put_block_group(cache);
8991	break;	8991	break;
8992	}	8992	}
8993		8993
8994	start = max(range->start, cache->key.objectid);	8994	start = max(range->start, cache->key.objectid);
8995	end = min(range->start + range->len,	8995	end = min(range_end, cache->key.objectid + cache->key.offset);
8996	cache->key.objectid + cache->key.offset);
8997		8996
8998	if (end - start >= range->minlen) {	8997	if (end - start >= range->minlen) {
8999	if (!block_group_cache_done(cache)) {	8998	if (!block_group_cache_done(cache)) {

fs/btrfs/volumes.c+0−13

@@ -3087,16 +3087,6 @@ static int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset) · 3086 unmodified lines
3087	if (ret)	3087	if (ret)
3088	return ret;	3088	return ret;
3089		3089
3090	/*
3091	* We add the kobjects here (and after forcing data chunk creation)
3092	* since relocation is the only place we'll create chunks of a new
3093	* type at runtime. The only place where we'll remove the last
3094	* chunk of a type is the call immediately below this one. Even
3095	* so, we're protected against races with the cleaner thread since
3096	* we're covered by the delete_unused_bgs_mutex.
3097	*/
3098	btrfs_add_raid_kobjects(fs_info);
3099
3100	trans = btrfs_start_trans_remove_block_group(root->fs_info,	3090	trans = btrfs_start_trans_remove_block_group(root->fs_info,
3101	chunk_offset);	3091	chunk_offset);
3102	if (IS_ERR(trans)) {	3092	if (IS_ERR(trans)) {
@@ -3223,9 +3213,6 @@ static int btrfs_may_alloc_data_chunk(struct btrfs_fs_info *fs_info, · 120 unmodified lines
3223	btrfs_end_transaction(trans);	3213	btrfs_end_transaction(trans);
3224	if (ret < 0)	3214	if (ret < 0)
3225	return ret;	3215	return ret;
3226
3227	btrfs_add_raid_kobjects(fs_info);
3228
3229	return 1;	3216	return 1;
3230	}	3217	}
3231	}	3218	}

fs/cifs/connect.c+1−0

@@ -1113,6 +1113,7 @@ cifs_demultiplex_thread(void *p) · 1112 unmodified lines
1113	mempool_resize(cifs_req_poolp, length + cifs_min_rcv);	1113	mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
1114		1114
1115	set_freezable();	1115	set_freezable();
		1116	allow_signal(SIGKILL);
1116	while (server->tcpStatus != CifsExiting) {	1117	while (server->tcpStatus != CifsExiting) {
1117	if (try_to_freeze())	1118	if (try_to_freeze())
1118	continue;	1119	continue;

fs/cifs/smb2ops.c+26−13

 static inline void smb2_sg_set_buf(struct scatterlist *sg, const void *buf,
 				   unsigned int buflen)
 {
-	sg_set_page(sg, virt_to_page(buf), buflen, offset_in_page(buf));
+	void *addr;
+	/*
+	 * VMAP_STACK (at least) puts stack into the vmalloc address space
+	 */
+	if (is_vmalloc_addr(buf))
+		addr = vmalloc_to_page(buf);
+	else
+		addr = virt_to_page(buf);
+	sg_set_page(sg, addr, buflen, offset_in_page(buf));
 }
 /* Assumes the first rqst has a transform header as the first iov.
 {
 	int ret, length;
 	char *buf = server->smallbuf;
-	char *tmpbuf;
 	struct smb2_sync_hdr *shdr;
 	unsigned int pdu_length = server->pdu_size;
 	unsigned int buf_size;
 		return length;
 	next_is_large = server->large_buf;
- one_more:
+one_more:
 	shdr = (struct smb2_sync_hdr *)buf;
 	if (shdr->NextCommand) {
-		if (next_is_large) {
+		if (next_is_large)
-			tmpbuf = server->bigbuf;
 			next_buffer = (char *)cifs_buf_get();
-		} else {
+		else
-			tmpbuf = server->smallbuf;
 			next_buffer = (char *)cifs_small_buf_get();
-		}
 		memcpy(next_buffer,
-		       tmpbuf + le32_to_cpu(shdr->NextCommand),
+		       buf + le32_to_cpu(shdr->NextCommand),
 		       pdu_length - le32_to_cpu(shdr->NextCommand));
 	}
 		pdu_length -= le32_to_cpu(shdr->NextCommand);
 		server->large_buf = next_is_large;
 		if (next_is_large)
-			server->bigbuf = next_buffer;
+			server->bigbuf = buf = next_buffer;
 		else
-			server->smallbuf = next_buffer;
+			server->smallbuf = buf = next_buffer;
-		buf += le32_to_cpu(shdr->NextCommand);
 		goto one_more;
+	} else if (ret != 0) {
+		/*
+		 * ret != 0 here means that we didn't get to handle_mid() thus
+		 * server->smallbuf and server->bigbuf are still valid. We need
+		 * to free next_buffer because it is not going to be used
+		 * anywhere.
+		 */
+		if (next_is_large)
+			free_rsp_buf(CIFS_LARGE_BUFFER, next_buffer);
+		else
+			free_rsp_buf(CIFS_SMALL_BUFFER, next_buffer);
 	}
 	return ret;

fs/cifs/smb2pdu.c+6−1

 	if (tcon == NULL)
 		return 0;
-	if (smb2_command == SMB2_TREE_CONNECT)
+	if (smb2_command == SMB2_TREE_CONNECT || smb2_command == SMB2_IOCTL)
 		return 0;
 	if (tcon->tidStatus == CifsExiting) {
 	else
 		req->SecurityMode = 0;
+#ifdef CONFIG_CIFS_DFS_UPCALL
+	req->Capabilities = cpu_to_le32(SMB2_GLOBAL_CAP_DFS);
+#else
 	req->Capabilities = 0;
+#endif /* DFS_UPCALL */
 	req->Channel = 0; /* MBZ */
 	sess_data->iov[0].iov_base = (char *)req;

fs/dax.c+1−1

@@ -600,7 +600,7 @@ struct page dax_layout_busy_page(struct address_space mapping) · 599 unmodified lines
600	* guaranteed to either see new references or prevent new	600	* guaranteed to either see new references or prevent new
601	* references from being established.	601	* references from being established.
602	*/	602	*/
603	unmap_mapping_range(mapping, 0, 0, 1);	603	unmap_mapping_range(mapping, 0, 0, 0);
604		604
605	xas_lock_irq(&xas);	605	xas_lock_irq(&xas);
606	xas_for_each(&xas, entry, ULONG_MAX) {	606	xas_for_each(&xas, entry, ULONG_MAX) {

fs/gfs2/bmap.c+101−63

@@ -390,6 +390,19 @@ static int fillup_metapath(struct gfs2_inode ip, struct metapath mp, int h) · 389 unmodified lines
390	return mp->mp_aheight - x - 1;	390	return mp->mp_aheight - x - 1;
391	}	391	}
392		392
		393	static sector_t metapath_to_block(struct gfs2_sbd sdp, struct metapath mp)
		394	{
		395	sector_t factor = 1, block = 0;
		396	int hgt;
		397
		398	for (hgt = mp->mp_fheight - 1; hgt >= 0; hgt--) {
		399	if (hgt < mp->mp_aheight)
		400	block += mp->mp_list[hgt] * factor;
		401	factor *= sdp->sd_inptrs;
		402	}
		403	return block;
		404	}
		405
393	static void release_metapath(struct metapath *mp)	406	static void release_metapath(struct metapath *mp)
394	{	407	{
395	int i;	408	int i;
@@ -430,60 +443,84 @@ static inline unsigned int gfs2_extent_length(struct buffer_head bh, __be64 pt · 34 unmodified lines
430	return ptr - first;	443	return ptr - first;
431	}	444	}
432		445
433	typedef const __be64 (gfs2_metadata_walker)(	446	enum walker_status { WALK_STOP, WALK_FOLLOW, WALK_CONTINUE };
434	struct metapath *mp,
435	const __be64 start, const __be64 end,
436	u64 factor, void *data);
437		447
438	#define WALK_STOP ((__be64 *)0)	448	/*
439	#define WALK_NEXT ((__be64 *)1)	449	* gfs2_metadata_walker - walk an indirect block
		450	* @mp: Metapath to indirect block
		451	* @ptrs: Number of pointers to look at
		452	*
		453	* When returning WALK_FOLLOW, the walker must update @mp to point at the right
		454	* indirect block to follow.
		455	*/
		456	typedef enum walker_status (gfs2_metadata_walker)(struct metapath mp,
		457	unsigned int ptrs);
440		458
441	static int gfs2_walk_metadata(struct inode *inode, sector_t lblock,	459	/*
442	u64 len, struct metapath *mp, gfs2_metadata_walker walker,	460	* gfs2_walk_metadata - walk a tree of indirect blocks
443	void *data)	461	* @inode: The inode
		462	* @mp: Starting point of walk
		463	* @max_len: Maximum number of blocks to walk
		464	* @walker: Called during the walk
		465	*
		466	* Returns 1 if the walk was stopped by @walker, 0 if we went past @max_len or
		467	* past the end of metadata, and a negative error code otherwise.
		468	*/
		469
		470	static int gfs2_walk_metadata(struct inode inode, struct metapath mp,
		471	u64 max_len, gfs2_metadata_walker walker)
444	{	472	{
445	struct metapath clone;
446	struct gfs2_inode *ip = GFS2_I(inode);	473	struct gfs2_inode *ip = GFS2_I(inode);
447	struct gfs2_sbd *sdp = GFS2_SB(inode);	474	struct gfs2_sbd *sdp = GFS2_SB(inode);
448	const __be64 start, end, *ptr;
449	u64 factor = 1;	475	u64 factor = 1;
450	unsigned int hgt;	476	unsigned int hgt;
451	int ret = 0;	477	int ret;
452		478
453	for (hgt = ip->i_height - 1; hgt >= mp->mp_aheight; hgt--)	479	/*
		480	* The walk starts in the lowest allocated indirect block, which may be
		481	* before the position indicated by @mp. Adjust @max_len accordingly
		482	* to avoid a short walk.
		483	*/
		484	for (hgt = mp->mp_fheight - 1; hgt >= mp->mp_aheight; hgt--) {
		485	max_len += mp->mp_list[hgt] * factor;
		486	mp->mp_list[hgt] = 0;
454	factor *= sdp->sd_inptrs;	487	factor *= sdp->sd_inptrs;
		488	}
455		489
456	for (;;) {	490	for (;;) {
457	u64 step;	491	u16 start = mp->mp_list[hgt];
		492	enum walker_status status;
		493	unsigned int ptrs;
		494	u64 len;
458		495
459	/* Walk indirect block. */	496	/* Walk indirect block. */
460	start = metapointer(hgt, mp);	497	ptrs = (hgt >= 1 ? sdp->sd_inptrs : sdp->sd_diptrs) - start;
461	end = metaend(hgt, mp);	498	len = ptrs * factor;
462		499	if (len > max_len)
463	step = (end - start) * factor;	500	ptrs = DIV_ROUND_UP_ULL(max_len, factor);
464	if (step > len)	501	status = walker(mp, ptrs);
465	end = start + DIV_ROUND_UP_ULL(len, factor);	502	switch (status) {
466		503	case WALK_STOP:
467	ptr = walker(mp, start, end, factor, data);	504	return 1;
468	if (ptr == WALK_STOP)	505	case WALK_FOLLOW:
		506	BUG_ON(mp->mp_aheight == mp->mp_fheight);
		507	ptrs = mp->mp_list[hgt] - start;
		508	len = ptrs * factor;
469	break;	509	break;
470	if (step >= len)	510	case WALK_CONTINUE:
471	break;	511	break;
472	len -= step;
473	if (ptr != WALK_NEXT) {
474	BUG_ON(!*ptr);
475	mp->mp_list[hgt] += ptr - start;
476	goto fill_up_metapath;
477	}	512	}
		513	if (len >= max_len)
		514	break;
		515	max_len -= len;
		516	if (status == WALK_FOLLOW)
		517	goto fill_up_metapath;
478		518
479	lower_metapath:	519	lower_metapath:
480	/* Decrease height of metapath. */	520	/* Decrease height of metapath. */
481	if (mp != &clone) {
482	clone_metapath(&clone, mp);
483	mp = &clone;
484	}
485	brelse(mp->mp_bh[hgt]);	521	brelse(mp->mp_bh[hgt]);
486	mp->mp_bh[hgt] = NULL;	522	mp->mp_bh[hgt] = NULL;
		523	mp->mp_list[hgt] = 0;
487	if (!hgt)	524	if (!hgt)
488	break;	525	break;
489	hgt--;	526	hgt--;
@@ -491,10 +528,7 @@ lower_metapath: · 1 unmodified line
491		528
492	/* Advance in metadata tree. */	529	/* Advance in metadata tree. */
493	(mp->mp_list[hgt])++;	530	(mp->mp_list[hgt])++;
494	start = metapointer(hgt, mp);	531	if (mp->mp_list[hgt] >= sdp->sd_inptrs) {
495	end = metaend(hgt, mp);
496	if (start >= end) {
497	mp->mp_list[hgt] = 0;
498	if (!hgt)	532	if (!hgt)
499	break;	533	break;
500	goto lower_metapath;	534	goto lower_metapath;
@@ -502,44 +536,36 @@ lower_metapath: · 1 unmodified line
502		536
503	fill_up_metapath:	537	fill_up_metapath:
504	/* Increase height of metapath. */	538	/* Increase height of metapath. */
505	if (mp != &clone) {
506	clone_metapath(&clone, mp);
507	mp = &clone;
508	}
509	ret = fillup_metapath(ip, mp, ip->i_height - 1);	539	ret = fillup_metapath(ip, mp, ip->i_height - 1);
510	if (ret < 0)	540	if (ret < 0)
511	break;	541	return ret;
512	hgt += ret;	542	hgt += ret;
513	for (; ret; ret--)	543	for (; ret; ret--)
514	do_div(factor, sdp->sd_inptrs);	544	do_div(factor, sdp->sd_inptrs);
515	mp->mp_aheight = hgt + 1;	545	mp->mp_aheight = hgt + 1;
516	}	546	}
517	if (mp == &clone)	547	return 0;
518	release_metapath(mp);
519	return ret;
520	}	548	}
521		549
522	struct gfs2_hole_walker_args {	550	static enum walker_status gfs2_hole_walker(struct metapath *mp,
523	u64 blocks;	551	unsigned int ptrs)
524	};
525
526	static const __be64 gfs2_hole_walker(struct metapath mp,
527	const __be64 start, const __be64 end,
528	u64 factor, void *data)
529	{	552	{
530	struct gfs2_hole_walker_args *args = data;	553	const __be64 start, ptr, *end;
531	const __be64 *ptr;	554	unsigned int hgt;
		555
		556	hgt = mp->mp_aheight - 1;
		557	start = metapointer(hgt, mp);
		558	end = start + ptrs;
532		559
533	for (ptr = start; ptr < end; ptr++) {	560	for (ptr = start; ptr < end; ptr++) {
534	if (*ptr) {	561	if (*ptr) {
535	args->blocks += (ptr - start) * factor;	562	mp->mp_list[hgt] += ptr - start;
536	if (mp->mp_aheight == mp->mp_fheight)	563	if (mp->mp_aheight == mp->mp_fheight)
537	return WALK_STOP;	564	return WALK_STOP;
538	return ptr; /* increase height */	565	return WALK_FOLLOW;
539	}	566	}
540	}	567	}
541	args->blocks += (end - start) * factor;	568	return WALK_CONTINUE;
542	return WALK_NEXT;
543	}	569	}
544		570
545	/**	571	/**
@@ -557,12 +583,24 @@ static const __be64 gfs2_hole_walker(struct metapath mp, · 11 unmodified lines
557	static int gfs2_hole_size(struct inode *inode, sector_t lblock, u64 len,	583	static int gfs2_hole_size(struct inode *inode, sector_t lblock, u64 len,
558	struct metapath mp, struct iomap iomap)	584	struct metapath mp, struct iomap iomap)
559	{	585	{
560	struct gfs2_hole_walker_args args = { };	586	struct metapath clone;
561	int ret = 0;	587	u64 hole_size;
		588	int ret;
562		589
563	ret = gfs2_walk_metadata(inode, lblock, len, mp, gfs2_hole_walker, &args);	590	clone_metapath(&clone, mp);
564	if (!ret)	591	ret = gfs2_walk_metadata(inode, &clone, len, gfs2_hole_walker);
565	iomap->length = args.blocks << inode->i_blkbits;	592	if (ret < 0)
		593	goto out;
		594
		595	if (ret == 1)
		596	hole_size = metapath_to_block(GFS2_SB(inode), &clone) - lblock;
		597	else
		598	hole_size = len;
		599	iomap->length = hole_size << inode->i_blkbits;
		600	ret = 0;
		601
		602	out:
		603	release_metapath(&clone);
566	return ret;	604	return ret;
567	}	605	}
568		606

fs/io_uring.c+10−10

 			iter->bvec = bvec + seg_skip;
 			iter->nr_segs -= seg_skip;
-			iter->count -= (seg_skip << PAGE_SHIFT);
+			iter->count -= bvec->bv_len + offset;
 			iter->iov_offset = offset & ~PAGE_MASK;
-			if (iter->iov_offset)
-				iter->count -= iter->iov_offset;
 		}
 	}
 {
 	int ret;
+	ret = io_req_defer(ctx, req, s->sqe);
+	if (ret) {
+		if (ret != -EIOCBQUEUED) {
+			io_free_req(req);
+			io_cqring_add_event(ctx, s->sqe->user_data, ret);
+		}
+		return 0;
+	}
 	ret = __io_submit_sqe(ctx, req, s, true);
 	if (ret == -EAGAIN && !(req->flags & REQ_F_NOWAIT)) {
 		struct io_uring_sqe *sqe_copy;
 		return;
 	}
-	ret = io_req_defer(ctx, req, s->sqe);
-	if (ret) {
-		if (ret != -EIOCBQUEUED)
-			goto err_req;
-		return;
-	}
 	/*
 	 * If we already have a head request, queue this one for async
 	 * submittal once the head completes. If we don't have a head but

fs/nfs/delegation.c+18−7

 		/* Block nfs4_proc_unlck */
 		mutex_lock(&sp->so_delegreturn_mutex);
 		seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
-		err = nfs4_open_delegation_recall(ctx, state, stateid, type);
+		err = nfs4_open_delegation_recall(ctx, state, stateid);
 		if (!err)
 			err = nfs_delegation_claim_locks(state, stateid);
 		if (!err && read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
 	nfs4_schedule_state_manager(clp);
 }
+static void
+nfs_delegation_test_free_expired(struct inode *inode,
+		nfs4_stateid *stateid,
+		const struct cred *cred)
+{
+	struct nfs_server *server = NFS_SERVER(inode);
+	const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops;
+	int status;
+	if (!cred)
+		return;
+	status = ops->test_and_free_expired(server, stateid, cred);
+	if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID)
+		nfs_remove_bad_delegation(inode, stateid);
+}
 /**
  * nfs_reap_expired_delegations - reap expired delegations
  * @clp: nfs_client to process
  */
 void nfs_reap_expired_delegations(struct nfs_client *clp)
 {
-	const struct nfs4_minor_version_ops *ops = clp->cl_mvops;
 	struct nfs_delegation *delegation;
 	struct nfs_server *server;
 	struct inode *inode;
 			nfs4_stateid_copy(&stateid, &delegation->stateid);
 			clear_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags);
 			rcu_read_unlock();
-			if (cred != NULL &&
+			nfs_delegation_test_free_expired(inode, &stateid, cred);
-			    ops->test_and_free_expired(server, &stateid, cred) < 0) {
-				nfs_revoke_delegation(inode, &stateid);
-				nfs_inode_find_state_and_recover(inode, &stateid);
-			}
 			put_cred(cred);
 			if (nfs4_server_rebooted(clp)) {
 				nfs_inode_mark_test_expired_delegation(server,inode);

fs/nfs/delegation.h+1−1

@@ -63,7 +63,7 @@ void nfs_reap_expired_delegations(struct nfs_client *clp); · 62 unmodified lines
63		63
64	/* NFSv4 delegation-related procedures */	64	/* NFSv4 delegation-related procedures */
65	int nfs4_proc_delegreturn(struct inode inode, const struct cred cred, const nfs4_stateid *stateid, int issync);	65	int nfs4_proc_delegreturn(struct inode inode, const struct cred cred, const nfs4_stateid *stateid, int issync);
66	int nfs4_open_delegation_recall(struct nfs_open_context ctx, struct nfs4_state state, const nfs4_stateid *stateid, fmode_t type);	66	int nfs4_open_delegation_recall(struct nfs_open_context ctx, struct nfs4_state state, const nfs4_stateid *stateid);
67	int nfs4_lock_delegation_recall(struct file_lock fl, struct nfs4_state state, const nfs4_stateid *stateid);	67	int nfs4_lock_delegation_recall(struct file_lock fl, struct nfs4_state state, const nfs4_stateid *stateid);
68	bool nfs4_copy_delegation_stateid(struct inode inode, fmode_t flags, nfs4_stateid dst, const struct cred **cred);	68	bool nfs4_copy_delegation_stateid(struct inode inode, fmode_t flags, nfs4_stateid dst, const struct cred **cred);
69	bool nfs4_refresh_delegation_stateid(nfs4_stateid dst, struct inode inode);	69	bool nfs4_refresh_delegation_stateid(nfs4_stateid dst, struct inode inode);

fs/nfs/fscache.c+6−1

 	struct rb_node **p, *parent;
 	int diff;
+	nfss->fscache_key = NULL;
+	nfss->fscache = NULL;
+	if (!(nfss->options & NFS_OPTION_FSCACHE))
+		return;
 	if (!uniq) {
 		uniq = "";
 		ulen = 1;
 void nfs_fscache_init_inode(struct inode *inode)
 {
 	struct nfs_fscache_inode_auxdata auxdata;
+	struct nfs_server *nfss = NFS_SERVER(inode);
 	struct nfs_inode *nfsi = NFS_I(inode);
 	nfsi->fscache = NULL;
-	if (!S_ISREG(inode->i_mode))
+	if (!(nfss->fscache && S_ISREG(inode->i_mode)))
 		return;
 	memset(&auxdata, 0, sizeof(auxdata));

fs/nfs/fscache.h+1−1

@@ -182,7 +182,7 @@ static inline void nfs_fscache_wait_on_invalidate(struct inode *inode) · 181 unmodified lines
182	*/	182	*/
183	static inline const char nfs_server_fscache_state(struct nfs_server server)	183	static inline const char nfs_server_fscache_state(struct nfs_server server)
184	{	184	{
185	if (server->fscache && (server->options & NFS_OPTION_FSCACHE))	185	if (server->fscache)
186	return "yes";	186	return "yes";
187	return "no ";	187	return "no ";
188	}	188	}

fs/nfs/nfs4_fs.h+2−1

@@ -465,7 +465,8 @@ static inline void nfs4_schedule_session_recovery(struct nfs4_session *session, · 464 unmodified lines
465		465
466	extern struct nfs4_state_owner nfs4_get_state_owner(struct nfs_server , const struct cred *, gfp_t);	466	extern struct nfs4_state_owner nfs4_get_state_owner(struct nfs_server , const struct cred *, gfp_t);
467	extern void nfs4_put_state_owner(struct nfs4_state_owner *);	467	extern void nfs4_put_state_owner(struct nfs4_state_owner *);
468	extern void nfs4_purge_state_owners(struct nfs_server *);	468	extern void nfs4_purge_state_owners(struct nfs_server , struct list_head );
		469	extern void nfs4_free_state_owners(struct list_head *head);
469	extern struct nfs4_state * nfs4_get_open_state(struct inode , struct nfs4_state_owner );	470	extern struct nfs4_state * nfs4_get_open_state(struct inode , struct nfs4_state_owner );
470	extern void nfs4_put_open_state(struct nfs4_state *);	471	extern void nfs4_put_open_state(struct nfs4_state *);
471	extern void nfs4_close_state(struct nfs4_state *, fmode_t);	472	extern void nfs4_close_state(struct nfs4_state *, fmode_t);

fs/nfs/nfs4client.c+4−1

 static void nfs4_destroy_server(struct nfs_server *server)
 {
+	LIST_HEAD(freeme);
 	nfs_server_return_all_delegations(server);
 	unset_pnfs_layoutdriver(server);
-	nfs4_purge_state_owners(server);
+	nfs4_purge_state_owners(server, &freeme);
+	nfs4_free_state_owners(&freeme);
 }
 /*

fs/nfs/nfs4proc.c+62−47

 	write_sequnlock(&state->seqlock);
 }
+static void nfs_state_clear_open_state_flags(struct nfs4_state *state)
+{
+	clear_bit(NFS_O_RDWR_STATE, &state->flags);
+	clear_bit(NFS_O_WRONLY_STATE, &state->flags);
+	clear_bit(NFS_O_RDONLY_STATE, &state->flags);
+	clear_bit(NFS_OPEN_STATE, &state->flags);
+}
 static void nfs_state_set_delegation(struct nfs4_state *state,
 		const nfs4_stateid *deleg_stateid,
 		fmode_t fmode)
 	if (data->o_res.delegation_type != 0)
 		nfs4_opendata_check_deleg(data, state);
 update:
-	update_open_stateid(state, &data->o_res.stateid, NULL,
+	if (!update_open_stateid(state, &data->o_res.stateid,
-			    data->o_arg.fmode);
+				NULL, data->o_arg.fmode))
+		return ERR_PTR(-EAGAIN);
 	refcount_inc(&state->count);
 	return state;
 	if (data->o_res.delegation_type != 0)
 		nfs4_opendata_check_deleg(data, state);
-	update_open_stateid(state, &data->o_res.stateid, NULL,
+	if (!update_open_stateid(state, &data->o_res.stateid,
-			data->o_arg.fmode);
+				NULL, data->o_arg.fmode)) {
+		nfs4_put_open_state(state);
+		state = ERR_PTR(-EAGAIN);
+	}
 out:
 	nfs_release_seqid(data->o_arg.seqid);
 	return state;
 {
 	int ret;
-	/* Don't trigger recovery in nfs_test_and_clear_all_open_stateid */
-	clear_bit(NFS_O_RDWR_STATE, &state->flags);
-	clear_bit(NFS_O_WRONLY_STATE, &state->flags);
-	clear_bit(NFS_O_RDONLY_STATE, &state->flags);
 	/* memory barrier prior to reading state->n_* */
-	clear_bit(NFS_DELEGATED_STATE, &state->flags);
-	clear_bit(NFS_OPEN_STATE, &state->flags);
 	smp_rmb();
 	ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE);
 	if (ret != 0)
 	ctx = nfs4_state_find_open_context(state);
 	if (IS_ERR(ctx))
 		return -EAGAIN;
+	clear_bit(NFS_DELEGATED_STATE, &state->flags);
+	nfs_state_clear_open_state_flags(state);
 	ret = nfs4_do_open_reclaim(ctx, state);
 	put_nfs_open_context(ctx);
 	return ret;
 		case -ENOENT:
 		case -EAGAIN:
 		case -ESTALE:
+		case -ETIMEDOUT:
 			break;
 		case -NFS4ERR_BADSESSION:
 		case -NFS4ERR_BADSLOT:
 		case -NFS4ERR_BAD_HIGH_SLOT:
 		case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
 		case -NFS4ERR_DEADSESSION:
-			set_bit(NFS_DELEGATED_STATE, &state->flags);
 			nfs4_schedule_session_recovery(server->nfs_client->cl_session, err);
 			return -EAGAIN;
 		case -NFS4ERR_STALE_CLIENTID:
 		case -NFS4ERR_STALE_STATEID:
-			set_bit(NFS_DELEGATED_STATE, &state->flags);
 			/* Don't recall a delegation if it was lost */
 			nfs4_schedule_lease_recovery(server->nfs_client);
 			return -EAGAIN;
 			return -EAGAIN;
 		case -NFS4ERR_DELAY:
 		case -NFS4ERR_GRACE:
-			set_bit(NFS_DELEGATED_STATE, &state->flags);
 			ssleep(1);
 			return -EAGAIN;
 		case -ENOMEM:
 }
 int nfs4_open_delegation_recall(struct nfs_open_context *ctx,
-		struct nfs4_state *state, const nfs4_stateid *stateid,
+		struct nfs4_state *state, const nfs4_stateid *stateid)
-		fmode_t type)
 {
 	struct nfs_server *server = NFS_SERVER(state->inode);
 	struct nfs4_opendata *opendata;
 	if (IS_ERR(opendata))
 		return PTR_ERR(opendata);
 	nfs4_stateid_copy(&opendata->o_arg.u.delegation, stateid);
-	nfs_state_clear_delegation(state);
+	if (!test_bit(NFS_O_RDWR_STATE, &state->flags)) {
-	switch (type & (FMODE_READ|FMODE_WRITE)) {
-	case FMODE_READ|FMODE_WRITE:
-	case FMODE_WRITE:
 		err = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE);
 		if (err)
-			break;
+			goto out;
+	}
+	if (!test_bit(NFS_O_WRONLY_STATE, &state->flags)) {
 		err = nfs4_open_recover_helper(opendata, FMODE_WRITE);
 		if (err)
-			break;
+			goto out;
-		/* Fall through */
+	}
-	case FMODE_READ:
+	if (!test_bit(NFS_O_RDONLY_STATE, &state->flags)) {
 		err = nfs4_open_recover_helper(opendata, FMODE_READ);
+		if (err)
+			goto out;
 	}
+	nfs_state_clear_delegation(state);
+out:
 	nfs4_opendata_put(opendata);
 	return nfs4_handle_delegation_recall_error(server, state, stateid, NULL, err);
 }
 	if (!ctx) {
 		nfs4_init_sequence(&o_arg->seq_args, &o_res->seq_res, 1, 1);
 		data->is_recover = true;
+		task_setup_data.flags |= RPC_TASK_TIMEOUT;
 	} else {
 		nfs4_init_sequence(&o_arg->seq_args, &o_res->seq_res, 1, 0);
 		pnfs_lgopen_prepare(data, ctx);
 {
 	/* NFSv4.0 doesn't allow for delegation recovery on open expire */
 	nfs40_clear_delegation_stateid(state);
+	nfs_state_clear_open_state_flags(state);
 	return nfs4_open_expired(sp, state);
 }
 	return -NFS4ERR_EXPIRED;
 }
-static void nfs41_check_delegation_stateid(struct nfs4_state *state)
+static int nfs41_check_delegation_stateid(struct nfs4_state *state)
 {
 	struct nfs_server *server = NFS_SERVER(state->inode);
 	nfs4_stateid stateid;
 	struct nfs_delegation *delegation;
 	const struct cred *cred = NULL;
-	int status;
+	int status, ret = NFS_OK;
 	/* Get the delegation credential for use by test/free_stateid */
 	rcu_read_lock();
 	if (delegation == NULL) {
 		rcu_read_unlock();
 		nfs_state_clear_delegation(state);
-		return;
+		return NFS_OK;
 	}
 	nfs4_stateid_copy(&stateid, &delegation->stateid);
-	if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
-		rcu_read_unlock();
-		nfs_state_clear_delegation(state);
-		return;
-	}
 	if (!test_and_clear_bit(NFS_DELEGATION_TEST_EXPIRED,
 				&delegation->flags)) {
 		rcu_read_unlock();
-		return;
+		return NFS_OK;
 	}
 	if (delegation->cred)
 	trace_nfs4_test_delegation_stateid(state, NULL, status);
 	if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID)
 		nfs_finish_clear_delegation_stateid(state, &stateid);
+	else
+		ret = status;
-	if (delegation->cred)
+	put_cred(cred);
-		put_cred(cred);
+	return ret;
+}
+static void nfs41_delegation_recover_stateid(struct nfs4_state *state)
+{
+	nfs4_stateid tmp;
+	if (test_bit(NFS_DELEGATED_STATE, &state->flags) &&
+	    nfs4_copy_delegation_stateid(state->inode, state->state,
+				&tmp, NULL) &&
+	    nfs4_stateid_match_other(&state->stateid, &tmp))
+		nfs_state_set_delegation(state, &tmp, state->state);
+	else
+		nfs_state_clear_delegation(state);
 }
 /**
 	const struct cred *cred = state->owner->so_cred;
 	int status;
-	if (test_bit(NFS_OPEN_STATE, &state->flags) == 0) {
+	if (test_bit(NFS_OPEN_STATE, &state->flags) == 0)
-		if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)  {
-			if (nfs4_have_delegation(state->inode, state->state))
-				return NFS_OK;
-			return -NFS4ERR_OPENMODE;
-		}
 		return -NFS4ERR_BAD_STATEID;
-	}
 	status = nfs41_test_and_free_expired_stateid(server, stateid, cred);
 	trace_nfs4_test_open_stateid(state, NULL, status);
 	if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID) {
-		clear_bit(NFS_O_RDONLY_STATE, &state->flags);
+		nfs_state_clear_open_state_flags(state);
-		clear_bit(NFS_O_WRONLY_STATE, &state->flags);
-		clear_bit(NFS_O_RDWR_STATE, &state->flags);
-		clear_bit(NFS_OPEN_STATE, &state->flags);
 		stateid->type = NFS4_INVALID_STATEID_TYPE;
 		return status;
 	}
 {
 	int status;
-	nfs41_check_delegation_stateid(state);
+	status = nfs41_check_delegation_stateid(state);
+	if (status != NFS_OK)
+		return status;
+	nfs41_delegation_recover_stateid(state);
 	status = nfs41_check_expired_locks(state);
 	if (status != NFS_OK)
 		return status;
 	if (nfs4_copy_delegation_stateid(inode, FMODE_WRITE, &arg->stateid, &delegation_cred)) {
 		/* Use that stateid */
-	} else if (ctx != NULL) {
+	} else if (ctx != NULL && ctx->state) {
 		struct nfs_lock_context *l_ctx;
 		if (!nfs4_valid_open_stateid(ctx->state))
 			return -EBADF;

fs/nfs/nfs4state.c+39−10

 /**
  * nfs4_purge_state_owners - Release all cached state owners
  * @server: nfs_server with cached state owners to release
+ * @head: resulting list of state owners
  *
  * Called at umount time.  Remaining state owners will be on
  * the LRU with ref count of zero.
+ * Note that the state owners are not freed, but are added
+ * to the list @head, which can later be used as an argument
+ * to nfs4_free_state_owners.
  */
-void nfs4_purge_state_owners(struct nfs_server *server)
+void nfs4_purge_state_owners(struct nfs_server *server, struct list_head *head)
 {
 	struct nfs_client *clp = server->nfs_client;
 	struct nfs4_state_owner *sp, *tmp;
-	LIST_HEAD(doomed);
 	spin_lock(&clp->cl_lock);
 	list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) {
-		list_move(&sp->so_lru, &doomed);
+		list_move(&sp->so_lru, head);
 		nfs4_remove_state_owner_locked(sp);
 	}
 	spin_unlock(&clp->cl_lock);
+}
-	list_for_each_entry_safe(sp, tmp, &doomed, so_lru) {
+/**
+ * nfs4_purge_state_owners - Release all cached state owners
+ * @head: resulting list of state owners
+ *
+ * Frees a list of state owners that was generated by
+ * nfs4_purge_state_owners
+ */
+void nfs4_free_state_owners(struct list_head *head)
+{
+	struct nfs4_state_owner *sp, *tmp;
+	list_for_each_entry_safe(sp, tmp, head, so_lru) {
 		list_del(&sp->so_lru);
 		nfs4_free_state_owner(sp);
 	}
 		nfs4_schedule_state_manager(clp);
 }
-static void nfs4_state_mark_open_context_bad(struct nfs4_state *state)
+static void nfs4_state_mark_open_context_bad(struct nfs4_state *state, int err)
 {
 	struct inode *inode = state->inode;
 	struct nfs_inode *nfsi = NFS_I(inode);
 		if (ctx->state != state)
 			continue;
 		set_bit(NFS_CONTEXT_BAD, &ctx->flags);
+		pr_warn("NFSv4: state recovery failed for open file %pd2, "
+				"error = %d\n", ctx->dentry, err);
 	}
 	rcu_read_unlock();
 }
 static void nfs4_state_mark_recovery_failed(struct nfs4_state *state, int error)
 {
 	set_bit(NFS_STATE_RECOVERY_FAILED, &state->flags);
-	nfs4_state_mark_open_context_bad(state);
+	nfs4_state_mark_open_context_bad(state, error);
 }
 		switch (status) {
 		case 0:
 			break;
+		case -ETIMEDOUT:
 		case -ESTALE:
 		case -NFS4ERR_ADMIN_REVOKED:
 		case -NFS4ERR_STALE_STATEID:
 static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs4_state_recovery_ops *ops)
 {
 	struct nfs4_state *state;
+	unsigned int loop = 0;
 	int status = 0;
 	/* Note: we rely on the sp->so_states list being ordered
 		switch (status) {
 		default:
-			if (status >= 0)
+			if (status >= 0) {
+				loop = 0;
 				break;
+			}
 			printk(KERN_ERR "NFS: %s: unhandled error %d\n", __func__, status);
 			/* Fall through */
 		case -ENOENT:
 			break;
 		case -EAGAIN:
 			ssleep(1);
+			if (loop++ < 10) {
+				set_bit(ops->state_flag_bit, &state->flags);
+				break;
+			}
 			/* Fall through */
 		case -NFS4ERR_ADMIN_REVOKED:
 		case -NFS4ERR_STALE_STATEID:
 		case -NFS4ERR_EXPIRED:
 		case -NFS4ERR_NO_GRACE:
 			nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
+			/* Fall through */
 		case -NFS4ERR_STALE_CLIENTID:
 		case -NFS4ERR_BADSESSION:
 		case -NFS4ERR_BADSLOT:
 		case -NFS4ERR_BAD_HIGH_SLOT:
 		case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
+		case -ETIMEDOUT:
 			goto out_err;
 		}
 		nfs4_put_open_state(state);
 	struct nfs4_state_owner *sp;
 	struct nfs_server *server;
 	struct rb_node *pos;
+	LIST_HEAD(freeme);
 	int status = 0;
 restart:
 	rcu_read_lock();
 	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
-		nfs4_purge_state_owners(server);
+		nfs4_purge_state_owners(server, &freeme);
 		spin_lock(&clp->cl_lock);
 		for (pos = rb_first(&server->state_owners);
 		     pos != NULL;
 		spin_unlock(&clp->cl_lock);
 	}
 	rcu_read_unlock();
+	nfs4_free_state_owners(&freeme);
 	return 0;
 }
 		return -EPERM;
 	case -EACCES:
 	case -NFS4ERR_DELAY:
-	case -ETIMEDOUT:
 	case -EAGAIN:
 		ssleep(1);
 		break;
 		}
 		/* Now recover expired state... */
-		if (test_and_clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) {
+		if (test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) {
 			section = "reclaim nograce";
 			status = nfs4_do_reclaim(clp,
 				clp->cl_mvops->nograce_recovery_ops);
 				continue;
 			if (status < 0)
 				goto out_error;
+			clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state);
 		}
 		nfs4_end_drain_session(clp);

fs/nfs/pnfs.c+1−6

 		goto out_unlock;
 	}
-	if (!nfs4_valid_open_stateid(ctx->state)) {
-		trace_pnfs_update_layout(ino, pos, count, iomode, lo, lseg,
-				PNFS_UPDATE_LAYOUT_INVALID_OPEN);
-		goto out_unlock;
-	}
 	/*
 	 * Choose a stateid for the LAYOUTGET. If we don't have a layout
 	 * stateid, or it has been invalidated, then we must use the open
 					iomode == IOMODE_RW ? FMODE_WRITE : FMODE_READ,
 					NULL, &stateid, NULL);
 		if (status != 0) {
+			lseg = ERR_PTR(status);
 			trace_pnfs_update_layout(ino, pos, count,
 					iomode, lo, lseg,
 					PNFS_UPDATE_LAYOUT_INVALID_OPEN);

fs/nfs/super.c+1−0

@@ -2260,6 +2260,7 @@ nfs_compare_remount_data(struct nfs_server *nfss, · 2259 unmodified lines
2260	data->acdirmin != nfss->acdirmin / HZ \|\|	2260	data->acdirmin != nfss->acdirmin / HZ \|\|
2261	data->acdirmax != nfss->acdirmax / HZ \|\|	2261	data->acdirmax != nfss->acdirmax / HZ \|\|
2262	data->timeo != (10U * nfss->client->cl_timeout->to_initval / HZ) \|\|	2262	data->timeo != (10U * nfss->client->cl_timeout->to_initval / HZ) \|\|
		2263	(data->options & NFS_OPTION_FSCACHE) != (nfss->options & NFS_OPTION_FSCACHE) \|\|
2263	data->nfs_server.port != nfss->port \|\|	2264	data->nfs_server.port != nfss->port \|\|
2264	data->nfs_server.addrlen != nfss->nfs_client->cl_addrlen \|\|	2265	data->nfs_server.addrlen != nfss->nfs_client->cl_addrlen \|\|
2265	!rpc_cmp_addr((struct sockaddr *)&data->nfs_server.address,	2266	!rpc_cmp_addr((struct sockaddr *)&data->nfs_server.address,

fs/seq_file.c+1−1

 		}
 		if (seq_has_overflowed(m))
 			goto Eoverflow;
+		p = m->op->next(m, p, &m->index);
 		if (pos + m->count > offset) {
 			m->from = offset - pos;
 			m->count -= m->from;
 		}
 		pos += m->count;
 		m->count = 0;
-		p = m->op->next(m, p, &m->index);
 		if (pos == offset)
 			break;
 	}

fs/xfs/libxfs/xfs_bmap.c+21−8

 	XFS_STATS_INC(mp, xs_blk_mapr);
 	ifp = XFS_IFORK_PTR(ip, whichfork);
+	if (!ifp) {
+		/* No CoW fork?  Return a hole. */
+		if (whichfork == XFS_COW_FORK) {
+			mval->br_startoff = bno;
+			mval->br_startblock = HOLESTARTBLOCK;
+			mval->br_blockcount = len;
+			mval->br_state = XFS_EXT_NORM;
+			*nmap = 1;
+			return 0;
+		}
-	/* No CoW fork?  Return a hole. */
+		/*
-	if (whichfork == XFS_COW_FORK && !ifp) {
+		 * A missing attr ifork implies that the inode says we're in
-		mval->br_startoff = bno;
+		 * extents or btree format but failed to pass the inode fork
-		mval->br_startblock = HOLESTARTBLOCK;
+		 * verifier while trying to load it.  Treat that as a file
-		mval->br_blockcount = len;
+		 * corruption too.
-		mval->br_state = XFS_EXT_NORM;
+		 */
-		*nmap = 1;
+#ifdef DEBUG
-		return 0;
+		xfs_alert(mp, "%s: inode %llu missing fork %d",
+				__func__, ip->i_ino, whichfork);
+#endif /* DEBUG */
+		return -EFSCORRUPTED;
 	}
 	if (!(ifp->if_flags & XFS_IFEXTENTS)) {

fs/xfs/libxfs/xfs_da_btree.c+12−7

 	ASSERT(state->path.active == 0);
 	oldblk = &state->path.blk[0];
 	error = xfs_da3_root_split(state, oldblk, addblk);
-	if (error) {
+	if (error)
-		addblk->bp = NULL;
+		goto out;
-		return error;	/* GROT: dir is inconsistent */
-	}
 	/*
 	 * Update pointers to the node which used to be block 0 and just got
 	 */
 	node = oldblk->bp->b_addr;
 	if (node->hdr.info.forw) {
-		ASSERT(be32_to_cpu(node->hdr.info.forw) == addblk->blkno);
+		if (be32_to_cpu(node->hdr.info.forw) != addblk->blkno) {
+			error = -EFSCORRUPTED;
+			goto out;
+		}
 		node = addblk->bp->b_addr;
 		node->hdr.info.back = cpu_to_be32(oldblk->blkno);
 		xfs_trans_log_buf(state->args->trans, addblk->bp,
 	}
 	node = oldblk->bp->b_addr;
 	if (node->hdr.info.back) {
-		ASSERT(be32_to_cpu(node->hdr.info.back) == addblk->blkno);
+		if (be32_to_cpu(node->hdr.info.back) != addblk->blkno) {
+			error = -EFSCORRUPTED;
+			goto out;
+		}
 		node = addblk->bp->b_addr;
 		node->hdr.info.forw = cpu_to_be32(oldblk->blkno);
 		xfs_trans_log_buf(state->args->trans, addblk->bp,
 				  XFS_DA_LOGRANGE(node, &node->hdr.info,
 				  sizeof(node->hdr.info)));
 	}
+out:
 	addblk->bp = NULL;
-	return 0;
+	return error;
 }
 /*

fs/xfs/libxfs/xfs_dir2_node.c+2−1

@@ -741,7 +741,8 @@ xfs_dir2_leafn_lookup_for_entry( · 740 unmodified lines
741	ents = dp->d_ops->leaf_ents_p(leaf);	741	ents = dp->d_ops->leaf_ents_p(leaf);
742		742
743	xfs_dir3_leaf_check(dp, bp);	743	xfs_dir3_leaf_check(dp, bp);
744	ASSERT(leafhdr.count > 0);	744	if (leafhdr.count <= 0)
		745	return -EFSCORRUPTED;
745		746
746	/*	747	/*
747	* Look up the hash value in the leaf entries.	748	* Look up the hash value in the leaf entries.

fs/xfs/xfs_log.c+1−4

@@ -429,10 +429,7 @@ xfs_log_reserve( · 428 unmodified lines
429		429
430	ASSERT(*ticp == NULL);	430	ASSERT(*ticp == NULL);
431	tic = xlog_ticket_alloc(log, unit_bytes, cnt, client, permanent,	431	tic = xlog_ticket_alloc(log, unit_bytes, cnt, client, permanent,
432	KM_SLEEP \| KM_MAYFAIL);	432	KM_SLEEP);
433	if (!tic)
434	return -ENOMEM;
435
436	*ticp = tic;	433	*ticp = tic;
437		434
438	xlog_grant_push_ail(log, tic->t_cnt ? tic->t_unit_res * tic->t_cnt	435	xlog_grant_push_ail(log, tic->t_cnt ? tic->t_unit_res * tic->t_cnt

include/asm-generic/5level-fixup.h+18−3

@@ -19,9 +19,24 @@ · 18 unmodified lines
19		19
20	#define p4d_alloc(mm, pgd, address) (pgd)	20	#define p4d_alloc(mm, pgd, address) (pgd)
21	#define p4d_offset(pgd, start) (pgd)	21	#define p4d_offset(pgd, start) (pgd)
22	#define p4d_none(p4d) 0	22
23	#define p4d_bad(p4d) 0	23	#ifndef __ASSEMBLY__
24	#define p4d_present(p4d) 1	24	static inline int p4d_none(p4d_t p4d)
		25	{
		26	return 0;
		27	}
		28
		29	static inline int p4d_bad(p4d_t p4d)
		30	{
		31	return 0;
		32	}
		33
		34	static inline int p4d_present(p4d_t p4d)
		35	{
		36	return 1;
		37	}
		38	#endif
		39
25	#define p4d_ERROR(p4d) do { } while (0)	40	#define p4d_ERROR(p4d) do { } while (0)
26	#define p4d_clear(p4d) pgd_clear(p4d)	41	#define p4d_clear(p4d) pgd_clear(p4d)
27	#define p4d_val(p4d) pgd_val(p4d)	42	#define p4d_val(p4d) pgd_val(p4d)

include/kvm/arm_pmu.h+2−0

 u64 kvm_pmu_get_counter_value(struct kvm_vcpu *vcpu, u64 select_idx);
 void kvm_pmu_set_counter_value(struct kvm_vcpu *vcpu, u64 select_idx, u64 val);
 u64 kvm_pmu_valid_counter_mask(struct kvm_vcpu *vcpu);
+void kvm_pmu_vcpu_init(struct kvm_vcpu *vcpu);
 void kvm_pmu_vcpu_reset(struct kvm_vcpu *vcpu);
 void kvm_pmu_vcpu_destroy(struct kvm_vcpu *vcpu);
 void kvm_pmu_disable_counter_mask(struct kvm_vcpu *vcpu, u64 val);
 {
 	return 0;
 }
+static inline void kvm_pmu_vcpu_init(struct kvm_vcpu *vcpu) {}
 static inline void kvm_pmu_vcpu_reset(struct kvm_vcpu *vcpu) {}
 static inline void kvm_pmu_vcpu_destroy(struct kvm_vcpu *vcpu) {}
 static inline void kvm_pmu_disable_counter_mask(struct kvm_vcpu *vcpu, u64 val) {}

include/kvm/arm_vgic.h+1−0

@@ -350,6 +350,7 @@ int kvm_vgic_vcpu_pending_irq(struct kvm_vcpu *vcpu); · 349 unmodified lines
350		350
351	void kvm_vgic_load(struct kvm_vcpu *vcpu);	351	void kvm_vgic_load(struct kvm_vcpu *vcpu);
352	void kvm_vgic_put(struct kvm_vcpu *vcpu);	352	void kvm_vgic_put(struct kvm_vcpu *vcpu);
		353	void kvm_vgic_vmcr_sync(struct kvm_vcpu *vcpu);
353		354
354	#define irqchip_in_kernel(k) (!!((k)->arch.vgic.in_kernel))	355	#define irqchip_in_kernel(k) (!!((k)->arch.vgic.in_kernel))
355	#define vgic_initialized(k) ((k)->arch.vgic.initialized)	356	#define vgic_initialized(k) ((k)->arch.vgic.initialized)

include/linux/blk_types.h+1−4

 	__REQ_RAHEAD,		/* read ahead, can fail anytime */
 	__REQ_BACKGROUND,	/* background IO */
 	__REQ_NOWAIT,           /* Don't wait if request will block */
-	__REQ_NOWAIT_INLINE,	/* Return would-block error inline */
 	/*
 	 * When a shared kthread needs to issue a bio for a cgroup, doing
 	 * so synchronously can lead to priority inversions as the kthread
 #define REQ_RAHEAD		(1ULL << __REQ_RAHEAD)
 #define REQ_BACKGROUND		(1ULL << __REQ_BACKGROUND)
 #define REQ_NOWAIT		(1ULL << __REQ_NOWAIT)
-#define REQ_NOWAIT_INLINE	(1ULL << __REQ_NOWAIT_INLINE)
 #define REQ_CGROUP_PUNT		(1ULL << __REQ_CGROUP_PUNT)
 #define REQ_NOUNMAP		(1ULL << __REQ_NOUNMAP)
 typedef unsigned int blk_qc_t;
 #define BLK_QC_T_NONE		-1U
-#define BLK_QC_T_EAGAIN		-2U
 #define BLK_QC_T_SHIFT		16
 #define BLK_QC_T_INTERNAL	(1U << 31)
 static inline bool blk_qc_t_valid(blk_qc_t cookie)
 {
-	return cookie != BLK_QC_T_NONE && cookie != BLK_QC_T_EAGAIN;
+	return cookie != BLK_QC_T_NONE;
 }
 static inline unsigned int blk_qc_t_to_queue_num(blk_qc_t cookie)

include/linux/ccp.h+2−0

@@ -170,6 +170,8 @@ struct ccp_aes_engine { · 169 unmodified lines
170	enum ccp_aes_mode mode;	170	enum ccp_aes_mode mode;
171	enum ccp_aes_action action;	171	enum ccp_aes_action action;
172		172
		173	u32 authsize;
		174
173	struct scatterlist *key;	175	struct scatterlist *key;
174	u32 key_len; /* In bytes */	176	u32 key_len; /* In bytes */
175		177

include/linux/dma-noncoherent.h+9−4

 		dma_addr_t dma_addr, unsigned long attrs);
 long arch_dma_coherent_to_pfn(struct device *dev, void *cpu_addr,
 		dma_addr_t dma_addr);
-#ifdef CONFIG_ARCH_HAS_DMA_MMAP_PGPROT
 pgprot_t arch_dma_mmap_pgprot(struct device *dev, pgprot_t prot,
 		unsigned long attrs);
+#ifdef CONFIG_MMU
+pgprot_t dma_pgprot(struct device *dev, pgprot_t prot, unsigned long attrs);
 #else
-# define arch_dma_mmap_pgprot(dev, prot, attrs)	pgprot_noncached(prot)
+static inline pgprot_t dma_pgprot(struct device *dev, pgprot_t prot,
-#endif
+		unsigned long attrs)
+{
+	return prot;	/* no protection bits supported without page tables */
+}
+#endif /* CONFIG_MMU */
 #ifdef CONFIG_DMA_NONCOHERENT_CACHE_SYNC
 void arch_dma_cache_sync(struct device *dev, void *vaddr, size_t size,

include/linux/gfp.h+4−8

 }
 extern struct page *alloc_pages_vma(gfp_t gfp_mask, int order,
 			struct vm_area_struct *vma, unsigned long addr,
-			int node, bool hugepage);
+			int node);
-#define alloc_hugepage_vma(gfp_mask, vma, addr, order) \
-	alloc_pages_vma(gfp_mask, order, vma, addr, numa_node_id(), true)
 #else
 #define alloc_pages(gfp_mask, order) \
 		alloc_pages_node(numa_node_id(), gfp_mask, order)
-#define alloc_pages_vma(gfp_mask, order, vma, addr, node, false)\
+#define alloc_pages_vma(gfp_mask, order, vma, addr, node)\
-	alloc_pages(gfp_mask, order)
-#define alloc_hugepage_vma(gfp_mask, vma, addr, order) \
 	alloc_pages(gfp_mask, order)
 #endif
 #define alloc_page(gfp_mask) alloc_pages(gfp_mask, 0)
 #define alloc_page_vma(gfp_mask, vma, addr)			\
-	alloc_pages_vma(gfp_mask, 0, vma, addr, numa_node_id(), false)
+	alloc_pages_vma(gfp_mask, 0, vma, addr, numa_node_id())
 #define alloc_page_vma_node(gfp_mask, vma, addr, node)		\
-	alloc_pages_vma(gfp_mask, 0, vma, addr, node, false)
+	alloc_pages_vma(gfp_mask, 0, vma, addr, node)
 extern unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order);
 extern unsigned long get_zeroed_page(gfp_t gfp_mask);

include/linux/key.h+4−4

@@ -94,11 +94,11 @@ struct keyring_index_key { · 93 unmodified lines
94	union {	94	union {
95	struct {	95	struct {
96	#ifdef __LITTLE_ENDIAN /* Put desc_len at the LSB of x */	96	#ifdef __LITTLE_ENDIAN /* Put desc_len at the LSB of x */
97	u8 desc_len;	97	u16 desc_len;
98	char desc[sizeof(long) - 1]; /* First few chars of description */	98	char desc[sizeof(long) - 2]; /* First few chars of description */
99	#else	99	#else
100	char desc[sizeof(long) - 1]; /* First few chars of description */	100	char desc[sizeof(long) - 2]; /* First few chars of description */
101	u8 desc_len;	101	u16 desc_len;
102	#endif	102	#endif
103	};	103	};
104	unsigned long x;	104	unsigned long x;

include/linux/kvm_host.h+4−2

 void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu);
 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu);
-bool kvm_arch_has_vcpu_debugfs(void);
+#ifdef __KVM_HAVE_ARCH_VCPU_DEBUGFS
-int kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu);
+void kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu);
+#endif
 int kvm_arch_hardware_enable(void);
 void kvm_arch_hardware_disable(void);
 int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu);
 bool kvm_arch_vcpu_in_kernel(struct kvm_vcpu *vcpu);
 int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu);
+bool kvm_arch_dy_runnable(struct kvm_vcpu *vcpu);
 #ifndef __KVM_HAVE_ARCH_VM_ALLOC
 /*

include/linux/memcontrol.h+19−0

@@ -668,6 +668,7 @@ static inline unsigned long lruvec_page_state_local(struct lruvec *lruvec, · 667 unmodified lines
668		668
669	void __mod_lruvec_state(struct lruvec *lruvec, enum node_stat_item idx,	669	void __mod_lruvec_state(struct lruvec *lruvec, enum node_stat_item idx,
670	int val);	670	int val);
		671	void __mod_lruvec_slab_state(void *p, enum node_stat_item idx, int val);
671		672
672	static inline void mod_lruvec_state(struct lruvec *lruvec,	673	static inline void mod_lruvec_state(struct lruvec *lruvec,
673	enum node_stat_item idx, int val)	674	enum node_stat_item idx, int val)
@@ -1072,6 +1073,14 @@ static inline void mod_lruvec_page_state(struct page *page, · 398 unmodified lines
1072	mod_node_page_state(page_pgdat(page), idx, val);	1073	mod_node_page_state(page_pgdat(page), idx, val);
1073	}	1074	}
1074		1075
		1076	static inline void __mod_lruvec_slab_state(void *p, enum node_stat_item idx,
		1077	int val)
		1078	{
		1079	struct page *page = virt_to_head_page(p);
		1080
		1081	__mod_node_page_state(page_pgdat(page), idx, val);
		1082	}
		1083
1075	static inline	1084	static inline
1076	unsigned long mem_cgroup_soft_limit_reclaim(pg_data_t *pgdat, int order,	1085	unsigned long mem_cgroup_soft_limit_reclaim(pg_data_t *pgdat, int order,
1077	gfp_t gfp_mask,	1086	gfp_t gfp_mask,
@@ -1159,6 +1168,16 @@ static inline void __dec_lruvec_page_state(struct page *page, · 81 unmodified lines
1159	__mod_lruvec_page_state(page, idx, -1);	1168	__mod_lruvec_page_state(page, idx, -1);
1160	}	1169	}
1161		1170
		1171	static inline void __inc_lruvec_slab_state(void *p, enum node_stat_item idx)
		1172	{
		1173	__mod_lruvec_slab_state(p, idx, 1);
		1174	}
		1175
		1176	static inline void __dec_lruvec_slab_state(void *p, enum node_stat_item idx)
		1177	{
		1178	__mod_lruvec_slab_state(p, idx, -1);
		1179	}
		1180
1162	/* idx can be of type enum memcg_stat_item or node_stat_item */	1181	/* idx can be of type enum memcg_stat_item or node_stat_item */
1163	static inline void inc_memcg_state(struct mem_cgroup *memcg,	1182	static inline void inc_memcg_state(struct mem_cgroup *memcg,
1164	int idx)	1183	int idx)

include/linux/mempolicy.h+2−0

@@ -139,6 +139,8 @@ struct mempolicy mpol_shared_policy_lookup(struct shared_policy sp, · 138 unmodified lines
139	struct mempolicy get_task_policy(struct task_struct p);	139	struct mempolicy get_task_policy(struct task_struct p);
140	struct mempolicy __get_vma_policy(struct vm_area_struct vma,	140	struct mempolicy __get_vma_policy(struct vm_area_struct vma,
141	unsigned long addr);	141	unsigned long addr);
		142	struct mempolicy get_vma_policy(struct vm_area_struct vma,
		143	unsigned long addr);
142	bool vma_policy_mof(struct vm_area_struct *vma);	144	bool vma_policy_mof(struct vm_area_struct *vma);
143		145
144	extern void numa_default_policy(void);	146	extern void numa_default_policy(void);

include/linux/mlx5/device.h+2−2

@@ -446,11 +446,11 @@ enum { · 445 unmodified lines
446	};	446	};
447		447
448	enum {	448	enum {
449	MLX5_OPC_MOD_TLS_TIS_STATIC_PARAMS = 0x20,	449	MLX5_OPC_MOD_TLS_TIS_STATIC_PARAMS = 0x1,
450	};	450	};
451		451
452	enum {	452	enum {
453	MLX5_OPC_MOD_TLS_TIS_PROGRESS_PARAMS = 0x20,	453	MLX5_OPC_MOD_TLS_TIS_PROGRESS_PARAMS = 0x1,
454	};	454	};
455		455
456	enum {	456	enum {

include/linux/mlx5/mlx5_ifc.h+2−3

@@ -10078,9 +10078,8 @@ struct mlx5_ifc_tls_static_params_bits { · 10077 unmodified lines
10078	};	10078	};
10079		10079
10080	struct mlx5_ifc_tls_progress_params_bits {	10080	struct mlx5_ifc_tls_progress_params_bits {
10081	u8 valid[0x1];	10081	u8 reserved_at_0[0x8];
10082	u8 reserved_at_1[0x7];	10082	u8 tisn[0x18];
10083	u8 pd[0x18];
10084		10083
10085	u8 next_record_tcp_sn[0x20];	10084	u8 next_record_tcp_sn[0x20];
10086		10085

include/linux/mm_types.h+10−1

@@ -159,7 +159,16 @@ struct page { · 158 unmodified lines
159	/** @pgmap: Points to the hosting device page map. */	159	/** @pgmap: Points to the hosting device page map. */
160	struct dev_pagemap *pgmap;	160	struct dev_pagemap *pgmap;
161	void *zone_device_data;	161	void *zone_device_data;
162	unsigned long _zd_pad_1; /* uses mapping */	162	/*
		163	* ZONE_DEVICE private pages are counted as being
		164	* mapped so the next 3 words hold the mapping, index,
		165	* and private fields from the source anonymous or
		166	* page cache page while the page is migrated to device
		167	* private memory.
		168	* ZONE_DEVICE MEMORY_DEVICE_FS_DAX pages also
		169	* use the mapping, index, and private fields when
		170	* pmem backed DAX files are mapped.
		171	*/
163	};	172	};
164		173
165	/** @rcu_head: You can use this to free a page by RCU. */	174	/** @rcu_head: You can use this to free a page by RCU. */

include/linux/pci.h+2−0

 #ifdef CONFIG_PCIEASPM
 bool pcie_aspm_support_enabled(void);
+bool pcie_aspm_enabled(struct pci_dev *pdev);
 #else
 static inline bool pcie_aspm_support_enabled(void) { return false; }
+static inline bool pcie_aspm_enabled(struct pci_dev *pdev) { return false; }
 #endif
 #ifdef CONFIG_PCIEAER

include/linux/skbuff.h+8−0

@@ -1362,6 +1362,14 @@ static inline void skb_copy_hash(struct sk_buff to, const struct sk_buff from) · 1361 unmodified lines
1362	to->l4_hash = from->l4_hash;	1362	to->l4_hash = from->l4_hash;
1363	};	1363	};
1364		1364
		1365	static inline void skb_copy_decrypted(struct sk_buff *to,
		1366	const struct sk_buff *from)
		1367	{
		1368	#ifdef CONFIG_TLS_DEVICE
		1369	to->decrypted = from->decrypted;
		1370	#endif
		1371	}
		1372
1365	#ifdef NET_SKBUFF_DATA_USES_OFFSET	1373	#ifdef NET_SKBUFF_DATA_USES_OFFSET
1366	static inline unsigned char skb_end_pointer(const struct sk_buff skb)	1374	static inline unsigned char skb_end_pointer(const struct sk_buff skb)
1367	{	1375	{

include/linux/socket.h+3−0

 #define MSG_BATCH	0x40000 /* sendmmsg(): more messages coming */
 #define MSG_EOF         MSG_FIN
 #define MSG_NO_SHARED_FRAGS 0x80000 /* sendpage() internal : page frags are not shared */
+#define MSG_SENDPAGE_DECRYPTED	0x100000 /* sendpage() internal : page may carry
+					  * plain text and require encryption
+					  */
 #define MSG_ZEROCOPY	0x4000000	/* Use user data in kernel path */
 #define MSG_FASTOPEN	0x20000000	/* Send data in TCP SYN */

include/linux/usb.h+1−1

@@ -1457,7 +1457,7 @@ typedef void (usb_complete_t)(struct urb ); · 1456 unmodified lines
1457	* field rather than determining a dma address themselves.	1457	* field rather than determining a dma address themselves.
1458	*	1458	*
1459	* Note that transfer_buffer must still be set if the controller	1459	* Note that transfer_buffer must still be set if the controller
1460	* does not support DMA (as indicated by bus.uses_dma) and when talking	1460	* does not support DMA (as indicated by hcd_uses_dma()) and when talking
1461	* to root hub. If you have to trasfer between highmem zone and the device	1461	* to root hub. If you have to trasfer between highmem zone and the device
1462	* on such controller, create a bounce buffer or bail out with an error.	1462	* on such controller, create a bounce buffer or bail out with an error.
1463	* If transfer_buffer cannot be set (is in highmem) and the controller is DMA	1463	* If transfer_buffer cannot be set (is in highmem) and the controller is DMA

include/linux/usb/hcd.h+3−0

@@ -422,6 +422,9 @@ static inline bool hcd_periodic_completion_in_progress(struct usb_hcd *hcd, · 421 unmodified lines
422	return hcd->high_prio_bh.completing_ep == ep;	422	return hcd->high_prio_bh.completing_ep == ep;
423	}	423	}
424		424
		425	#define hcd_uses_dma(hcd) \
		426	(IS_ENABLED(CONFIG_HAS_DMA) && (hcd)->self.uses_dma)
		427
425	extern int usb_hcd_link_urb_to_ep(struct usb_hcd hcd, struct urb urb);	428	extern int usb_hcd_link_urb_to_ep(struct usb_hcd hcd, struct urb urb);
426	extern int usb_hcd_check_unlink_urb(struct usb_hcd hcd, struct urb urb,	429	extern int usb_hcd_check_unlink_urb(struct usb_hcd hcd, struct urb urb,
427	int status);	430	int status);

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

@@ -278,6 +278,7 @@ struct hci_dev { · 277 unmodified lines
278	__u16 conn_info_min_age;	278	__u16 conn_info_min_age;
279	__u16 conn_info_max_age;	279	__u16 conn_info_max_age;
280	__u16 auth_payload_timeout;	280	__u16 auth_payload_timeout;
		281	__u8 min_enc_key_size;
281	__u8 ssp_debug_mode;	282	__u8 ssp_debug_mode;
282	__u8 hw_error_code;	283	__u8 hw_error_code;
283	__u32 clock;	284	__u32 clock;

include/net/inet_frag.h+1−1

@@ -171,7 +171,7 @@ int inet_frag_queue_insert(struct inet_frag_queue q, struct sk_buff skb, · 170 unmodified lines
171	void inet_frag_reasm_prepare(struct inet_frag_queue q, struct sk_buff *skb,	171	void inet_frag_reasm_prepare(struct inet_frag_queue q, struct sk_buff *skb,
172	struct sk_buff *parent);	172	struct sk_buff *parent);
173	void inet_frag_reasm_finish(struct inet_frag_queue q, struct sk_buff head,	173	void inet_frag_reasm_finish(struct inet_frag_queue q, struct sk_buff head,
174	void *reasm_data);	174	void *reasm_data, bool try_coalesce);
175	struct sk_buff inet_frag_pull_head(struct inet_frag_queue q);	175	struct sk_buff inet_frag_pull_head(struct inet_frag_queue q);
176		176
177	#endif	177	#endif

include/net/net_namespace.h+0−1

@@ -61,7 +61,6 @@ struct net { · 60 unmodified lines
61	spinlock_t rules_mod_lock;	61	spinlock_t rules_mod_lock;
62		62
63	u32 hash_mix;	63	u32 hash_mix;
64	atomic64_t cookie_gen;
65		64
66	struct list_head list; /* list of network namespaces */	65	struct list_head list; /* list of network namespaces */
67	struct list_head exit_list; /* To linked to call pernet exit	66	struct list_head exit_list; /* To linked to call pernet exit

include/net/netfilter/nf_tables.h+7−2

 	unsigned char			*udata;
 	/* runtime data below here */
 	const struct nft_set_ops	*ops ____cacheline_aligned;
-	u16				flags:13,
+	u16				flags:14,
-					bound:1,
 					genmask:2;
 	u8				klen;
 	u8				dlen;
 struct nft_trans_set {
 	struct nft_set			*set;
 	u32				set_id;
+	bool				bound;
 };
 #define nft_trans_set(trans)	\
 	(((struct nft_trans_set *)trans->data)->set)
 #define nft_trans_set_id(trans)	\
 	(((struct nft_trans_set *)trans->data)->set_id)
+#define nft_trans_set_bound(trans)	\
+	(((struct nft_trans_set *)trans->data)->bound)
 struct nft_trans_chain {
 	bool				update;
 struct nft_trans_elem {
 	struct nft_set			*set;
 	struct nft_set_elem		elem;
+	bool				bound;
 };
 #define nft_trans_elem_set(trans)	\
 	(((struct nft_trans_elem *)trans->data)->set)
 #define nft_trans_elem(trans)	\
 	(((struct nft_trans_elem *)trans->data)->elem)
+#define nft_trans_elem_set_bound(trans)	\
+	(((struct nft_trans_elem *)trans->data)->bound)
 struct nft_trans_obj {
 	struct nft_object		*obj;

include/net/netfilter/nf_tables_offload.h+2−0

@@ -78,4 +78,6 @@ void nft_indr_block_get_and_ing_cmd(struct net_device *dev, · 77 unmodified lines
78	(__reg)->key = __key; \	78	(__reg)->key = __key; \
79	memset(&(__reg)->mask, 0xff, (__reg)->len);	79	memset(&(__reg)->mask, 0xff, (__reg)->len);
80		80
		81	int nft_chain_offload_priority(struct nft_base_chain *basechain);
		82
81	#endif	83	#endif

include/net/netlink.h+2−3

 			      const struct nla_policy *policy,
 			      struct netlink_ext_ack *extack)
 {
-	return __nla_parse(tb, maxtype, nlmsg_attrdata(nlh, hdrlen),
+	return __nlmsg_parse(nlh, hdrlen, tb, maxtype, policy,
-			   nlmsg_attrlen(nlh, hdrlen), policy,
+			     NL_VALIDATE_STRICT, extack);
-			   NL_VALIDATE_STRICT, extack);
 }
 /**

include/net/pkt_cls.h+1−1

@@ -611,7 +611,7 @@ tc_cls_common_offload_init(struct flow_cls_common_offload *cls_common, · 610 unmodified lines
611	{	611	{
612	cls_common->chain_index = tp->chain->index;	612	cls_common->chain_index = tp->chain->index;
613	cls_common->protocol = tp->protocol;	613	cls_common->protocol = tp->protocol;
614	cls_common->prio = tp->prio;	614	cls_common->prio = tp->prio >> 16;
615	if (tc_skip_sw(flags) \|\| flags & TCA_CLS_FLAGS_VERBOSE)	615	if (tc_skip_sw(flags) \|\| flags & TCA_CLS_FLAGS_VERBOSE)
616	cls_common->extack = extack;	616	cls_common->extack = extack;
617	}	617	}

include/net/sock.h+9−1

 /* Checks if this SKB belongs to an HW offloaded socket
  * and whether any SW fallbacks are required based on dev.
+ * Check decrypted mark in case skb_orphan() cleared socket.
  */
 static inline struct sk_buff *sk_validate_xmit_skb(struct sk_buff *skb,
 						   struct net_device *dev)
 #ifdef CONFIG_SOCK_VALIDATE_XMIT
 	struct sock *sk = skb->sk;
-	if (sk && sk_fullsock(sk) && sk->sk_validate_xmit_skb)
+	if (sk && sk_fullsock(sk) && sk->sk_validate_xmit_skb) {
 		skb = sk->sk_validate_xmit_skb(sk, dev, skb);
+#ifdef CONFIG_TLS_DEVICE
+	} else if (unlikely(skb->decrypted)) {
+		pr_warn_ratelimited("unencrypted skb with no associated socket - dropping\n");
+		kfree_skb(skb);
+		skb = NULL;
+#endif
+	}
 #endif
 	return skb;

include/sound/simple_card_utils.h+4−0

 {
 	struct device *dev = simple_priv_to_dev(priv);
+	/* dai might be NULL */
+	if (!dai)
+		return;
 	if (dai->name)
 		dev_dbg(dev, "%s dai name = %s\n",
 			name, dai->name);

include/trace/events/rxrpc.h+3−3

@@ -498,10 +498,10 @@ rxrpc_tx_points; · 497 unmodified lines
498	#define E_(a, b) { a, b }	498	#define E_(a, b) { a, b }
499		499
500	TRACE_EVENT(rxrpc_local,	500	TRACE_EVENT(rxrpc_local,
501	TP_PROTO(struct rxrpc_local *local, enum rxrpc_local_trace op,	501	TP_PROTO(unsigned int local_debug_id, enum rxrpc_local_trace op,
502	int usage, const void *where),	502	int usage, const void *where),
503		503
504	TP_ARGS(local, op, usage, where),	504	TP_ARGS(local_debug_id, op, usage, where),
505		505
506	TP_STRUCT__entry(	506	TP_STRUCT__entry(
507	__field(unsigned int, local )	507	__field(unsigned int, local )
@@ -511,7 +511,7 @@ TRACE_EVENT(rxrpc_local, · 3 unmodified lines
511	),	511	),
512		512
513	TP_fast_assign(	513	TP_fast_assign(
514	__entry->local = local->debug_id;	514	__entry->local = local_debug_id;
515	__entry->op = op;	515	__entry->op = op;
516	__entry->usage = usage;	516	__entry->usage = usage;
517	__entry->where = where;	517	__entry->where = where;

include/uapi/linux/bpf.h+2−2

@@ -1467,8 +1467,8 @@ union bpf_attr { · 1466 unmodified lines
1467	* If no cookie has been set yet, generate a new cookie. Once	1467	* If no cookie has been set yet, generate a new cookie. Once
1468	* generated, the socket cookie remains stable for the life of the	1468	* generated, the socket cookie remains stable for the life of the
1469	* socket. This helper can be useful for monitoring per socket	1469	* socket. This helper can be useful for monitoring per socket
1470	* networking traffic statistics as it provides a unique socket	1470	* networking traffic statistics as it provides a global socket
1471	* identifier per namespace.	1471	* identifier that can be assumed unique.
1472	* Return	1472	* Return
1473	* A 8-byte long non-decreasing number on success, or 0 if the	1473	* A 8-byte long non-decreasing number on success, or 0 if the
1474	* socket field is missing inside skb.	1474	* socket field is missing inside skb.

include/uapi/linux/kfd_ioctl.h+1−19

@@ -410,21 +410,6 @@ struct kfd_ioctl_unmap_memory_from_gpu_args { · 409 unmodified lines
410	__u32 n_success; /* to/from KFD */	410	__u32 n_success; /* to/from KFD */
411	};	411	};
412		412
413	/* Allocate GWS for specific queue
414	*
415	* @gpu_id: device identifier
416	* @queue_id: queue's id that GWS is allocated for
417	* @num_gws: how many GWS to allocate
418	* @first_gws: index of the first GWS allocated.
419	* only support contiguous GWS allocation
420	*/
421	struct kfd_ioctl_alloc_queue_gws_args {
422	__u32 gpu_id; /* to KFD */
423	__u32 queue_id; /* to KFD */
424	__u32 num_gws; /* to KFD */
425	__u32 first_gws; /* from KFD */
426	};
427
428	struct kfd_ioctl_get_dmabuf_info_args {	413	struct kfd_ioctl_get_dmabuf_info_args {
429	__u64 size; /* from KFD */	414	__u64 size; /* from KFD */
430	__u64 metadata_ptr; /* to KFD */	415	__u64 metadata_ptr; /* to KFD */
@@ -544,10 +529,7 @@ enum kfd_mmio_remap { · 113 unmodified lines
544	#define AMDKFD_IOC_IMPORT_DMABUF \	529	#define AMDKFD_IOC_IMPORT_DMABUF \
545	AMDKFD_IOWR(0x1D, struct kfd_ioctl_import_dmabuf_args)	530	AMDKFD_IOWR(0x1D, struct kfd_ioctl_import_dmabuf_args)
546		531
547	#define AMDKFD_IOC_ALLOC_QUEUE_GWS \
548	AMDKFD_IOWR(0x1E, struct kfd_ioctl_alloc_queue_gws_args)
549
550	#define AMDKFD_COMMAND_START 0x01	532	#define AMDKFD_COMMAND_START 0x01
551	#define AMDKFD_COMMAND_END 0x1F	533	#define AMDKFD_COMMAND_END 0x1E
552		534
553	#endif	535	#endif

include/uapi/rdma/siw-abi.h+2−1

@@ -180,6 +180,7 @@ struct siw_cqe { · 179 unmodified lines
180	* to control CQ arming.	180	* to control CQ arming.
181	*/	181	*/
182	struct siw_cq_ctrl {	182	struct siw_cq_ctrl {
183	__aligned_u64 notify;	183	__u32 flags;
		184	__u32 pad;
184	};	185	};
185	#endif	186	#endif

include/uapi/sound/sof/fw.h+9−7

 #ifndef __INCLUDE_UAPI_SOF_FW_H__
 #define __INCLUDE_UAPI_SOF_FW_H__
+#include <linux/types.h>
 #define SND_SOF_FW_SIG_SIZE	4
 #define SND_SOF_FW_ABI		1
 #define SND_SOF_FW_SIG		"Reef"
 struct snd_sof_blk_hdr {
 	enum snd_sof_fw_blk_type type;
-	uint32_t size;		/* bytes minus this header */
+	__u32 size;		/* bytes minus this header */
-	uint32_t offset;	/* offset from base */
+	__u32 offset;		/* offset from base */
 } __packed;
 /*
 struct snd_sof_mod_hdr {
 	enum snd_sof_fw_mod_type type;
-	uint32_t size;		/* bytes minus this header */
+	__u32 size;		/* bytes minus this header */
-	uint32_t num_blocks;	/* number of blocks */
+	__u32 num_blocks;	/* number of blocks */
 } __packed;
 /*
  */
 struct snd_sof_fw_header {
 	unsigned char sig[SND_SOF_FW_SIG_SIZE]; /* "Reef" */
-	uint32_t file_size;	/* size of file minus this header */
+	__u32 file_size;	/* size of file minus this header */
-	uint32_t num_modules;	/* number of modules */
+	__u32 num_modules;	/* number of modules */
-	uint32_t abi;		/* version of header format */
+	__u32 abi;		/* version of header format */
 } __packed;
 #endif

include/uapi/sound/sof/header.h+8−6

 #ifndef __INCLUDE_UAPI_SOUND_SOF_USER_HEADER_H__
 #define __INCLUDE_UAPI_SOUND_SOF_USER_HEADER_H__
+#include <linux/types.h>
 /*
  * Header for all non IPC ABI data.
  *
  * Used by any bespoke component data structures or binary blobs.
  */
 struct sof_abi_hdr {
-	uint32_t magic;		/**< 'S', 'O', 'F', '\0' */
+	__u32 magic;		/**< 'S', 'O', 'F', '\0' */
-	uint32_t type;		/**< component specific type */
+	__u32 type;		/**< component specific type */
-	uint32_t size;		/**< size in bytes of data excl. this struct */
+	__u32 size;		/**< size in bytes of data excl. this struct */
-	uint32_t abi;		/**< SOF ABI version */
+	__u32 abi;		/**< SOF ABI version */
-	uint32_t reserved[4];	/**< reserved for future use */
+	__u32 reserved[4];	/**< reserved for future use */
-	uint32_t data[0];	/**< Component data - opaque to core */
+	__u32 data[0];		/**< Component data - opaque to core */
 }  __packed;
 #endif

kernel/configs.c+1−15

@@ -1,3 +1,4 @@
		1	// SPDX-License-Identifier: GPL-2.0-or-later
1	/*	2	/*
2	* kernel/configs.c	3	* kernel/configs.c
3	* Echo the kernel .config file used to build the kernel	4	* Echo the kernel .config file used to build the kernel
@@ -6,21 +7,6 @@ · 2 unmodified lines
6	* Copyright (C) 2002 Randy Dunlap <rdunlap@xenotime.net>	7	* Copyright (C) 2002 Randy Dunlap <rdunlap@xenotime.net>
7	* Copyright (C) 2002 Al Stone <ahs3@fc.hp.com>	8	* Copyright (C) 2002 Al Stone <ahs3@fc.hp.com>
8	* Copyright (C) 2002 Hewlett-Packard Company	9	* Copyright (C) 2002 Hewlett-Packard Company
9	*
10	* This program is free software; you can redistribute it and/or modify
11	* it under the terms of the GNU General Public License as published by
12	* the Free Software Foundation; either version 2 of the License, or (at
13	* your option) any later version.
14	*
15	* This program is distributed in the hope that it will be useful, but
16	* WITHOUT ANY WARRANTY; without even the implied warranty of
17	* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
18	* NON INFRINGEMENT. See the GNU General Public License for more
19	* details.
20	*
21	* You should have received a copy of the GNU General Public License
22	* along with this program; if not, write to the Free Software
23	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24	*/	10	*/
25		11
26	#include <linux/kernel.h>	12	#include <linux/kernel.h>

kernel/dma/direct.c+5−5

 {
 	u64 max_dma = phys_to_dma_direct(dev, (max_pfn - 1) << PAGE_SHIFT);
-	if (dev->bus_dma_mask && dev->bus_dma_mask < max_dma)
-		max_dma = dev->bus_dma_mask;
 	return (1ULL << (fls64(max_dma) - 1)) * 2 - 1;
 }
 	if (!page)
 		return NULL;
-	if (attrs & DMA_ATTR_NO_KERNEL_MAPPING) {
+	if ((attrs & DMA_ATTR_NO_KERNEL_MAPPING) &&
+	    !force_dma_unencrypted(dev)) {
 		/* remove any dirty cache lines on the kernel alias */
 		if (!PageHighMem(page))
 			arch_dma_prep_coherent(page, size);
+		*dma_handle = phys_to_dma(dev, page_to_phys(page));
 		/* return the page pointer as the opaque cookie */
 		return page;
 	}
 {
 	unsigned int page_order = get_order(size);
-	if (attrs & DMA_ATTR_NO_KERNEL_MAPPING) {
+	if ((attrs & DMA_ATTR_NO_KERNEL_MAPPING) &&
+	    !force_dma_unencrypted(dev)) {
 		/* cpu_addr is a struct page cookie, not a kernel address */
 		__dma_direct_free_pages(dev, size, cpu_addr);
 		return;

kernel/dma/mapping.c+18−1

@@ -150,6 +150,23 @@ int dma_get_sgtable_attrs(struct device dev, struct sg_table sgt, · 149 unmodified lines
150	}	150	}
151	EXPORT_SYMBOL(dma_get_sgtable_attrs);	151	EXPORT_SYMBOL(dma_get_sgtable_attrs);
152		152
		153	#ifdef CONFIG_MMU
		154	/*
		155	* Return the page attributes used for mapping dma_alloc_* memory, either in
		156	* kernel space if remapping is needed, or to userspace through dma_mmap_*.
		157	*/
		158	pgprot_t dma_pgprot(struct device *dev, pgprot_t prot, unsigned long attrs)
		159	{
		160	if (dev_is_dma_coherent(dev) \|\|
		161	(IS_ENABLED(CONFIG_DMA_NONCOHERENT_CACHE_SYNC) &&
		162	(attrs & DMA_ATTR_NON_CONSISTENT)))
		163	return prot;
		164	if (IS_ENABLED(CONFIG_ARCH_HAS_DMA_MMAP_PGPROT))
		165	return arch_dma_mmap_pgprot(dev, prot, attrs);
		166	return pgprot_noncached(prot);
		167	}
		168	#endif /* CONFIG_MMU */
		169
153	/*	170	/*
154	* Create userspace mapping for the DMA-coherent memory.	171	* Create userspace mapping for the DMA-coherent memory.
155	*/	172	*/
@@ -164,7 +181,7 @@ int dma_common_mmap(struct device dev, struct vm_area_struct vma, · 8 unmodified lines
164	unsigned long pfn;	181	unsigned long pfn;
165	int ret = -ENXIO;	182	int ret = -ENXIO;
166		183
167	vma->vm_page_prot = arch_dma_mmap_pgprot(dev, vma->vm_page_prot, attrs);	184	vma->vm_page_prot = dma_pgprot(dev, vma->vm_page_prot, attrs);
168		185
169	if (dma_mmap_from_dev_coherent(dev, vma, cpu_addr, size, &ret))	186	if (dma_mmap_from_dev_coherent(dev, vma, cpu_addr, size, &ret))
170	return ret;	187	return ret;

kernel/dma/remap.c+1−1

@@ -218,7 +218,7 @@ void arch_dma_alloc(struct device dev, size_t size, dma_addr_t *dma_handle, · 217 unmodified lines
218		218
219	/* create a coherent mapping */	219	/* create a coherent mapping */
220	ret = dma_common_contiguous_remap(page, size, VM_USERMAP,	220	ret = dma_common_contiguous_remap(page, size, VM_USERMAP,
221	arch_dma_mmap_pgprot(dev, PAGE_KERNEL, attrs),	221	dma_pgprot(dev, PAGE_KERNEL, attrs),
222	__builtin_return_address(0));	222	__builtin_return_address(0));
223	if (!ret) {	223	if (!ret) {
224	__dma_direct_free_pages(dev, size, page);	224	__dma_direct_free_pages(dev, size, page);

kernel/irq/affinity.c+2−4

 	 * Determine the number of vectors which need interrupt affinities
 	 * assigned. If the pre/post request exhausts the available vectors
 	 * then nothing to do here except for invoking the calc_sets()
-	 * callback so the device driver can adjust to the situation. If there
+	 * callback so the device driver can adjust to the situation.
-	 * is only a single vector, then managing the queue is pointless as
-	 * well.
 	 */
-	if (nvecs > 1 && nvecs > affd->pre_vectors + affd->post_vectors)
+	if (nvecs > affd->pre_vectors + affd->post_vectors)
 		affvecs = nvecs - affd->pre_vectors - affd->post_vectors;
 	else
 		affvecs = 0;

kernel/sched/cpufreq_schedutil.c+10−4

 	struct task_struct	*thread;
 	bool			work_in_progress;
+	bool			limits_changed;
 	bool			need_freq_update;
 };
 	    !cpufreq_this_cpu_can_update(sg_policy->policy))
 		return false;
-	if (unlikely(sg_policy->need_freq_update))
+	if (unlikely(sg_policy->limits_changed)) {
+		sg_policy->limits_changed = false;
+		sg_policy->need_freq_update = true;
 		return true;
+	}
 	delta_ns = time - sg_policy->last_freq_update_time;
 static inline void ignore_dl_rate_limit(struct sugov_cpu *sg_cpu, struct sugov_policy *sg_policy)
 {
 	if (cpu_bw_dl(cpu_rq(sg_cpu->cpu)) > sg_cpu->bw_dl)
-		sg_policy->need_freq_update = true;
+		sg_policy->limits_changed = true;
 }
 static void sugov_update_single(struct update_util_data *hook, u64 time,
 	if (!sugov_should_update_freq(sg_policy, time))
 		return;
-	busy = sugov_cpu_is_busy(sg_cpu);
+	/* Limits may have changed, don't skip frequency update */
+	busy = !sg_policy->need_freq_update && sugov_cpu_is_busy(sg_cpu);
 	util = sugov_get_util(sg_cpu);
 	max = sg_cpu->max;
 	sg_policy->last_freq_update_time	= 0;
 	sg_policy->next_freq			= 0;
 	sg_policy->work_in_progress		= false;
+	sg_policy->limits_changed		= false;
 	sg_policy->need_freq_update		= false;
 	sg_policy->cached_raw_freq		= 0;
 		mutex_unlock(&sg_policy->work_lock);
 	}
-	sg_policy->need_freq_update = true;
+	sg_policy->limits_changed = true;
 }
 struct cpufreq_governor schedutil_gov = {

kernel/sched/deadline.c+0−8

 	}
 	deactivate_task(rq, next_task, 0);
-	sub_running_bw(&next_task->dl, &rq->dl);
-	sub_rq_bw(&next_task->dl, &rq->dl);
 	set_task_cpu(next_task, later_rq->cpu);
-	add_rq_bw(&next_task->dl, &later_rq->dl);
 	/*
 	 * Update the later_rq clock here, because the clock is used
 	 * by the cpufreq_update_util() inside __add_running_bw().
 	 */
 	update_rq_clock(later_rq);
-	add_running_bw(&next_task->dl, &later_rq->dl);
 	activate_task(later_rq, next_task, ENQUEUE_NOCLOCK);
 	ret = 1;
 			resched = true;
 			deactivate_task(src_rq, p, 0);
-			sub_running_bw(&p->dl, &src_rq->dl);
-			sub_rq_bw(&p->dl, &src_rq->dl);
 			set_task_cpu(p, this_cpu);
-			add_rq_bw(&p->dl, &this_rq->dl);
-			add_running_bw(&p->dl, &this_rq->dl);
 			activate_task(this_rq, p, 0);
 			dmin = p->dl.deadline;

kernel/sched/psi.c+2−2

@@ -1051,7 +1051,7 @@ struct psi_trigger psi_trigger_create(struct psi_group group, · 1050 unmodified lines
1051		1051
1052	if (!rcu_access_pointer(group->poll_kworker)) {	1052	if (!rcu_access_pointer(group->poll_kworker)) {
1053	struct sched_param param = {	1053	struct sched_param param = {
1054	.sched_priority = MAX_RT_PRIO - 1,	1054	.sched_priority = 1,
1055	};	1055	};
1056	struct kthread_worker *kworker;	1056	struct kthread_worker *kworker;
1057		1057
@@ -1061,7 +1061,7 @@ struct psi_trigger psi_trigger_create(struct psi_group group, · 3 unmodified lines
1061	mutex_unlock(&group->trigger_lock);	1061	mutex_unlock(&group->trigger_lock);
1062	return ERR_CAST(kworker);	1062	return ERR_CAST(kworker);
1063	}	1063	}
1064	sched_setscheduler(kworker->task, SCHED_FIFO, &param);	1064	sched_setscheduler_nocheck(kworker->task, SCHED_FIFO, &param);
1065	kthread_init_delayed_work(&group->poll_work,	1065	kthread_init_delayed_work(&group->poll_work,
1066	psi_poll_work);	1066	psi_poll_work);
1067	rcu_assign_pointer(group->poll_kworker, kworker);	1067	rcu_assign_pointer(group->poll_kworker, kworker);

mm/huge_memory.c+31−20

@@ -644,30 +644,40 @@ release: · 643 unmodified lines
644	* available	644	* available
645	* never: never stall for any thp allocation	645	* never: never stall for any thp allocation
646	*/	646	*/
647	static inline gfp_t alloc_hugepage_direct_gfpmask(struct vm_area_struct *vma)	647	static inline gfp_t alloc_hugepage_direct_gfpmask(struct vm_area_struct *vma, unsigned long addr)
648	{	648	{
649	const bool vma_madvised = !!(vma->vm_flags & VM_HUGEPAGE);	649	const bool vma_madvised = !!(vma->vm_flags & VM_HUGEPAGE);
		650	gfp_t this_node = 0;
		651
		652	#ifdef CONFIG_NUMA
		653	struct mempolicy *pol;
		654	/*
		655	* __GFP_THISNODE is used only when __GFP_DIRECT_RECLAIM is not
		656	* specified, to express a general desire to stay on the current
		657	* node for optimistic allocation attempts. If the defrag mode
		658	* and/or madvise hint requires the direct reclaim then we prefer
		659	* to fallback to other node rather than node reclaim because that
		660	* can lead to excessive reclaim even though there is free memory
		661	* on other nodes. We expect that NUMA preferences are specified
		662	* by memory policies.
		663	*/
		664	pol = get_vma_policy(vma, addr);
		665	if (pol->mode != MPOL_BIND)
		666	this_node = __GFP_THISNODE;
		667	mpol_cond_put(pol);
		668	#endif
650		669
651	/* Always do synchronous compaction */
652	if (test_bit(TRANSPARENT_HUGEPAGE_DEFRAG_DIRECT_FLAG, &transparent_hugepage_flags))	670	if (test_bit(TRANSPARENT_HUGEPAGE_DEFRAG_DIRECT_FLAG, &transparent_hugepage_flags))
653	return GFP_TRANSHUGE \| (vma_madvised ? 0 : __GFP_NORETRY);	671	return GFP_TRANSHUGE \| (vma_madvised ? 0 : __GFP_NORETRY);
654
655	/* Kick kcompactd and fail quickly */
656	if (test_bit(TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_FLAG, &transparent_hugepage_flags))	672	if (test_bit(TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_FLAG, &transparent_hugepage_flags))
657	return GFP_TRANSHUGE_LIGHT \| __GFP_KSWAPD_RECLAIM;	673	return GFP_TRANSHUGE_LIGHT \| __GFP_KSWAPD_RECLAIM \| this_node;
658
659	/* Synchronous compaction if madvised, otherwise kick kcompactd */
660	if (test_bit(TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_OR_MADV_FLAG, &transparent_hugepage_flags))	674	if (test_bit(TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_OR_MADV_FLAG, &transparent_hugepage_flags))
661	return GFP_TRANSHUGE_LIGHT \|	675	return GFP_TRANSHUGE_LIGHT \| (vma_madvised ? __GFP_DIRECT_RECLAIM :
662	(vma_madvised ? __GFP_DIRECT_RECLAIM :	676	__GFP_KSWAPD_RECLAIM \| this_node);
663	__GFP_KSWAPD_RECLAIM);
664
665	/* Only do synchronous compaction if madvised */
666	if (test_bit(TRANSPARENT_HUGEPAGE_DEFRAG_REQ_MADV_FLAG, &transparent_hugepage_flags))	677	if (test_bit(TRANSPARENT_HUGEPAGE_DEFRAG_REQ_MADV_FLAG, &transparent_hugepage_flags))
667	return GFP_TRANSHUGE_LIGHT \|	678	return GFP_TRANSHUGE_LIGHT \| (vma_madvised ? __GFP_DIRECT_RECLAIM :
668	(vma_madvised ? __GFP_DIRECT_RECLAIM : 0);	679	this_node);
669		680	return GFP_TRANSHUGE_LIGHT \| this_node;
670	return GFP_TRANSHUGE_LIGHT;
671	}	681	}
672		682
673	/* Caller must hold page table lock. */	683	/* Caller must hold page table lock. */
@@ -739,8 +749,8 @@ vm_fault_t do_huge_pmd_anonymous_page(struct vm_fault *vmf) · 65 unmodified lines
739	pte_free(vma->vm_mm, pgtable);	749	pte_free(vma->vm_mm, pgtable);
740	return ret;	750	return ret;
741	}	751	}
742	gfp = alloc_hugepage_direct_gfpmask(vma);	752	gfp = alloc_hugepage_direct_gfpmask(vma, haddr);
743	page = alloc_hugepage_vma(gfp, vma, haddr, HPAGE_PMD_ORDER);	753	page = alloc_pages_vma(gfp, HPAGE_PMD_ORDER, vma, haddr, numa_node_id());
744	if (unlikely(!page)) {	754	if (unlikely(!page)) {
745	count_vm_event(THP_FAULT_FALLBACK);	755	count_vm_event(THP_FAULT_FALLBACK);
746	return VM_FAULT_FALLBACK;	756	return VM_FAULT_FALLBACK;
@@ -1347,8 +1357,9 @@ vm_fault_t do_huge_pmd_wp_page(struct vm_fault *vmf, pmd_t orig_pmd) · 600 unmodified lines
1347	alloc:	1357	alloc:
1348	if (__transparent_hugepage_enabled(vma) &&	1358	if (__transparent_hugepage_enabled(vma) &&
1349	!transparent_hugepage_debug_cow()) {	1359	!transparent_hugepage_debug_cow()) {
1350	huge_gfp = alloc_hugepage_direct_gfpmask(vma);	1360	huge_gfp = alloc_hugepage_direct_gfpmask(vma, haddr);
1351	new_page = alloc_hugepage_vma(huge_gfp, vma, haddr, HPAGE_PMD_ORDER);	1361	new_page = alloc_pages_vma(huge_gfp, HPAGE_PMD_ORDER, vma,
		1362	haddr, numa_node_id());
1352	} else	1363	} else
1353	new_page = NULL;	1364	new_page = NULL;
1354		1365

mm/hugetlb.c+19−0

@@ -3856,6 +3856,25 @@ retry: · 3855 unmodified lines
3856		3856
3857	page = alloc_huge_page(vma, haddr, 0);	3857	page = alloc_huge_page(vma, haddr, 0);
3858	if (IS_ERR(page)) {	3858	if (IS_ERR(page)) {
		3859	/*
		3860	* Returning error will result in faulting task being
		3861	* sent SIGBUS. The hugetlb fault mutex prevents two
		3862	* tasks from racing to fault in the same page which
		3863	* could result in false unable to allocate errors.
		3864	* Page migration does not take the fault mutex, but
		3865	* does a clear then write of pte's under page table
		3866	* lock. Page fault code could race with migration,
		3867	* notice the clear pte and try to allocate a page
		3868	* here. Before returning error, get ptl and make
		3869	* sure there really is no pte entry.
		3870	*/
		3871	ptl = huge_pte_lock(h, mm, ptep);
		3872	if (!huge_pte_none(huge_ptep_get(ptep))) {
		3873	ret = 0;
		3874	spin_unlock(ptl);
		3875	goto out;
		3876	}
		3877	spin_unlock(ptl);
3859	ret = vmf_error(PTR_ERR(page));	3878	ret = vmf_error(PTR_ERR(page));
3860	goto out;	3879	goto out;
3861	}	3880	}

mm/kmemleak.c+1−1

 	/* stop any memory operation tracing */
 	kmemleak_enabled = 0;
+	kmemleak_early_log = 0;
 	/* check whether it is too early for a kernel thread */
 	if (kmemleak_initialized)
 #ifdef CONFIG_DEBUG_KMEMLEAK_DEFAULT_OFF
 	if (!kmemleak_skip_disable) {
-		kmemleak_early_log = 0;
 		kmemleak_disable();
 		return;
 	}

mm/memcontrol.c+49−10

@@ -768,6 +768,26 @@ void __mod_lruvec_state(struct lruvec *lruvec, enum node_stat_item idx, · 767 unmodified lines
768	__this_cpu_write(pn->lruvec_stat_cpu->count[idx], x);	768	__this_cpu_write(pn->lruvec_stat_cpu->count[idx], x);
769	}	769	}
770		770
		771	void __mod_lruvec_slab_state(void *p, enum node_stat_item idx, int val)
		772	{
		773	struct page *page = virt_to_head_page(p);
		774	pg_data_t *pgdat = page_pgdat(page);
		775	struct mem_cgroup *memcg;
		776	struct lruvec *lruvec;
		777
		778	rcu_read_lock();
		779	memcg = memcg_from_slab_page(page);
		780
		781	/* Untracked pages have no memcg, no lruvec. Update only the node */
		782	if (!memcg \|\| memcg == root_mem_cgroup) {
		783	__mod_node_page_state(pgdat, idx, val);
		784	} else {
		785	lruvec = mem_cgroup_lruvec(pgdat, memcg);
		786	__mod_lruvec_state(lruvec, idx, val);
		787	}
		788	rcu_read_unlock();
		789	}
		790
771	/**	791	/**
772	* __count_memcg_events - account VM events in a cgroup	792	* __count_memcg_events - account VM events in a cgroup
773	* @memcg: the memory cgroup	793	* @memcg: the memory cgroup
@@ -1130,26 +1150,45 @@ void mem_cgroup_iter_break(struct mem_cgroup *root, · 356 unmodified lines
1130	css_put(&prev->css);	1150	css_put(&prev->css);
1131	}	1151	}
1132		1152
1133	static void invalidate_reclaim_iterators(struct mem_cgroup *dead_memcg)	1153	static void __invalidate_reclaim_iterators(struct mem_cgroup *from,
		1154	struct mem_cgroup *dead_memcg)
1134	{	1155	{
1135	struct mem_cgroup *memcg = dead_memcg;
1136	struct mem_cgroup_reclaim_iter *iter;	1156	struct mem_cgroup_reclaim_iter *iter;
1137	struct mem_cgroup_per_node *mz;	1157	struct mem_cgroup_per_node *mz;
1138	int nid;	1158	int nid;
1139	int i;	1159	int i;
1140		1160
1141	for (; memcg; memcg = parent_mem_cgroup(memcg)) {	1161	for_each_node(nid) {
1142	for_each_node(nid) {	1162	mz = mem_cgroup_nodeinfo(from, nid);
1143	mz = mem_cgroup_nodeinfo(memcg, nid);	1163	for (i = 0; i <= DEF_PRIORITY; i++) {
1144	for (i = 0; i <= DEF_PRIORITY; i++) {	1164	iter = &mz->iter[i];
1145	iter = &mz->iter[i];	1165	cmpxchg(&iter->position,
1146	cmpxchg(&iter->position,	1166	dead_memcg, NULL);
1147	dead_memcg, NULL);
1148	}
1149	}	1167	}
1150	}	1168	}
1151	}	1169	}
1152		1170
		1171	static void invalidate_reclaim_iterators(struct mem_cgroup *dead_memcg)
		1172	{
		1173	struct mem_cgroup *memcg = dead_memcg;
		1174	struct mem_cgroup *last;
		1175
		1176	do {
		1177	__invalidate_reclaim_iterators(memcg, dead_memcg);
		1178	last = memcg;
		1179	} while ((memcg = parent_mem_cgroup(memcg)));
		1180
		1181	/*
		1182	* When cgruop1 non-hierarchy mode is used,
		1183	* parent_mem_cgroup() does not walk all the way up to the
		1184	* cgroup root (root_mem_cgroup). So we have to handle
		1185	* dead_memcg from cgroup root separately.
		1186	*/
		1187	if (last != root_mem_cgroup)
		1188	__invalidate_reclaim_iterators(root_mem_cgroup,
		1189	dead_memcg);
		1190	}
		1191
1153	/**	1192	/**
1154	* mem_cgroup_scan_tasks - iterate over tasks of a memory cgroup hierarchy	1193	* mem_cgroup_scan_tasks - iterate over tasks of a memory cgroup hierarchy
1155	* @memcg: hierarchy root	1194	* @memcg: hierarchy root

mm/mempolicy.c+77−57

@@ -403,7 +403,7 @@ static const struct mempolicy_operations mpol_ops[MPOL_MAX] = { · 402 unmodified lines
403	},	403	},
404	};	404	};
405		405
406	static void migrate_page_add(struct page page, struct list_head pagelist,	406	static int migrate_page_add(struct page page, struct list_head pagelist,
407	unsigned long flags);	407	unsigned long flags);
408		408
409	struct queue_pages {	409	struct queue_pages {
@@ -429,11 +429,14 @@ static inline bool queue_pages_required(struct page *page, · 19 unmodified lines
429	}	429	}
430		430
431	/*	431	/*
432	* queue_pages_pmd() has three possible return values:	432	* queue_pages_pmd() has four possible return values:
433	* 1 - pages are placed on the right node or queued successfully.	433	* 0 - pages are placed on the right node or queued successfully.
434	* 0 - THP was split.	434	* 1 - there is unmovable page, and MPOL_MF_MOVE* & MPOL_MF_STRICT were
435	* -EIO - is migration entry or MPOL_MF_STRICT was specified and an existing	435	* specified.
436	* page was already on a node that does not follow the policy.	436	* 2 - THP was split.
		437	* -EIO - is migration entry or only MPOL_MF_STRICT was specified and an
		438	* existing page was already on a node that does not follow the
		439	* policy.
437	*/	440	*/
438	static int queue_pages_pmd(pmd_t pmd, spinlock_t ptl, unsigned long addr,	441	static int queue_pages_pmd(pmd_t pmd, spinlock_t ptl, unsigned long addr,
439	unsigned long end, struct mm_walk *walk)	442	unsigned long end, struct mm_walk *walk)
@@ -451,23 +454,20 @@ static int queue_pages_pmd(pmd_t pmd, spinlock_t ptl, unsigned long addr, · 11 unmodified lines
451	if (is_huge_zero_page(page)) {	454	if (is_huge_zero_page(page)) {
452	spin_unlock(ptl);	455	spin_unlock(ptl);
453	__split_huge_pmd(walk->vma, pmd, addr, false, NULL);	456	__split_huge_pmd(walk->vma, pmd, addr, false, NULL);
		457	ret = 2;
454	goto out;	458	goto out;
455	}	459	}
456	if (!queue_pages_required(page, qp)) {	460	if (!queue_pages_required(page, qp))
457	ret = 1;
458	goto unlock;	461	goto unlock;
459	}
460		462
461	ret = 1;
462	flags = qp->flags;	463	flags = qp->flags;
463	/* go to thp migration */	464	/* go to thp migration */
464	if (flags & (MPOL_MF_MOVE \| MPOL_MF_MOVE_ALL)) {	465	if (flags & (MPOL_MF_MOVE \| MPOL_MF_MOVE_ALL)) {
465	if (!vma_migratable(walk->vma)) {	466	if (!vma_migratable(walk->vma) \|\|
466	ret = -EIO;	467	migrate_page_add(page, qp->pagelist, flags)) {
		468	ret = 1;
467	goto unlock;	469	goto unlock;
468	}	470	}
469
470	migrate_page_add(page, qp->pagelist, flags);
471	} else	471	} else
472	ret = -EIO;	472	ret = -EIO;
473	unlock:	473	unlock:
@@ -479,6 +479,13 @@ out: · 5 unmodified lines
479	/*	479	/*
480	* Scan through pages checking if pages follow certain conditions,	480	* Scan through pages checking if pages follow certain conditions,
481	* and move them to the pagelist if they do.	481	* and move them to the pagelist if they do.
		482	*
		483	* queue_pages_pte_range() has three possible return values:
		484	* 0 - pages are placed on the right node or queued successfully.
		485	* 1 - there is unmovable page, and MPOL_MF_MOVE* & MPOL_MF_STRICT were
		486	* specified.
		487	* -EIO - only MPOL_MF_STRICT was specified and an existing page was already
		488	* on a node that does not follow the policy.
482	*/	489	*/
483	static int queue_pages_pte_range(pmd_t *pmd, unsigned long addr,	490	static int queue_pages_pte_range(pmd_t *pmd, unsigned long addr,
484	unsigned long end, struct mm_walk *walk)	491	unsigned long end, struct mm_walk *walk)
@@ -488,17 +495,17 @@ static int queue_pages_pte_range(pmd_t *pmd, unsigned long addr, · 3 unmodified lines
488	struct queue_pages *qp = walk->private;	495	struct queue_pages *qp = walk->private;
489	unsigned long flags = qp->flags;	496	unsigned long flags = qp->flags;
490	int ret;	497	int ret;
		498	bool has_unmovable = false;
491	pte_t *pte;	499	pte_t *pte;
492	spinlock_t *ptl;	500	spinlock_t *ptl;
493		501
494	ptl = pmd_trans_huge_lock(pmd, vma);	502	ptl = pmd_trans_huge_lock(pmd, vma);
495	if (ptl) {	503	if (ptl) {
496	ret = queue_pages_pmd(pmd, ptl, addr, end, walk);	504	ret = queue_pages_pmd(pmd, ptl, addr, end, walk);
497	if (ret > 0)	505	if (ret != 2)
498	return 0;
499	else if (ret < 0)
500	return ret;	506	return ret;
501	}	507	}
		508	/* THP was split, fall through to pte walk */
502		509
503	if (pmd_trans_unstable(pmd))	510	if (pmd_trans_unstable(pmd))
504	return 0;	511	return 0;
@@ -519,14 +526,28 @@ static int queue_pages_pte_range(pmd_t *pmd, unsigned long addr, · 14 unmodified lines
519	if (!queue_pages_required(page, qp))	526	if (!queue_pages_required(page, qp))
520	continue;	527	continue;
521	if (flags & (MPOL_MF_MOVE \| MPOL_MF_MOVE_ALL)) {	528	if (flags & (MPOL_MF_MOVE \| MPOL_MF_MOVE_ALL)) {
522	if (!vma_migratable(vma))	529	/* MPOL_MF_STRICT must be specified if we get here */
		530	if (!vma_migratable(vma)) {
		531	has_unmovable = true;
523	break;	532	break;
524	migrate_page_add(page, qp->pagelist, flags);	533	}
		534
		535	/*
		536	* Do not abort immediately since there may be
		537	* temporary off LRU pages in the range. Still
		538	* need migrate other LRU pages.
		539	*/
		540	if (migrate_page_add(page, qp->pagelist, flags))
		541	has_unmovable = true;
525	} else	542	} else
526	break;	543	break;
527	}	544	}
528	pte_unmap_unlock(pte - 1, ptl);	545	pte_unmap_unlock(pte - 1, ptl);
529	cond_resched();	546	cond_resched();
		547
		548	if (has_unmovable)
		549	return 1;
		550
530	return addr != end ? -EIO : 0;	551	return addr != end ? -EIO : 0;
531	}	552	}
532		553
@@ -639,7 +660,13 @@ static int queue_pages_test_walk(unsigned long start, unsigned long end, · 106 unmodified lines
639	*	660	*
640	* If pages found in a given range are on a set of nodes (determined by	661	* If pages found in a given range are on a set of nodes (determined by
641	* @nodes and @flags,) it's isolated and queued to the pagelist which is	662	* @nodes and @flags,) it's isolated and queued to the pagelist which is
642	* passed via @private.)	663	* passed via @private.
		664	*
		665	* queue_pages_range() has three possible return values:
		666	* 1 - there is unmovable page, but MPOL_MF_MOVE* & MPOL_MF_STRICT were
		667	* specified.
		668	* 0 - queue pages successfully or no misplaced page.
		669	* -EIO - there is misplaced page and only MPOL_MF_STRICT was specified.
643	*/	670	*/
644	static int	671	static int
645	queue_pages_range(struct mm_struct *mm, unsigned long start, unsigned long end,	672	queue_pages_range(struct mm_struct *mm, unsigned long start, unsigned long end,
@@ -940,7 +967,7 @@ static long do_get_mempolicy(int policy, nodemask_t nmask, · 294 unmodified lines
940	/*	967	/*
941	* page migration, thp tail pages can be passed.	968	* page migration, thp tail pages can be passed.
942	*/	969	*/
943	static void migrate_page_add(struct page page, struct list_head pagelist,	970	static int migrate_page_add(struct page page, struct list_head pagelist,
944	unsigned long flags)	971	unsigned long flags)
945	{	972	{
946	struct page *head = compound_head(page);	973	struct page *head = compound_head(page);
@@ -953,8 +980,19 @@ static void migrate_page_add(struct page page, struct list_head pagelist, · 6 unmodified lines
953	mod_node_page_state(page_pgdat(head),	980	mod_node_page_state(page_pgdat(head),
954	NR_ISOLATED_ANON + page_is_file_cache(head),	981	NR_ISOLATED_ANON + page_is_file_cache(head),
955	hpage_nr_pages(head));	982	hpage_nr_pages(head));
		983	} else if (flags & MPOL_MF_STRICT) {
		984	/*
		985	* Non-movable page may reach here. And, there may be
		986	* temporary off LRU pages or non-LRU movable pages.
		987	* Treat them as unmovable pages since they can't be
		988	* isolated, so they can't be moved at the moment. It
		989	* should return -EIO for this case too.
		990	*/
		991	return -EIO;
956	}	992	}
957	}	993	}
		994
		995	return 0;
958	}	996	}
959		997
960	/* page allocation callback for NUMA node migration */	998	/* page allocation callback for NUMA node migration */
@@ -1142,8 +1180,8 @@ static struct page new_page(struct page page, unsigned long start) · 181 unmodified lines
1142	} else if (PageTransHuge(page)) {	1180	} else if (PageTransHuge(page)) {
1143	struct page *thp;	1181	struct page *thp;
1144		1182
1145	thp = alloc_hugepage_vma(GFP_TRANSHUGE, vma, address,	1183	thp = alloc_pages_vma(GFP_TRANSHUGE, HPAGE_PMD_ORDER, vma,
1146	HPAGE_PMD_ORDER);	1184	address, numa_node_id());
1147	if (!thp)	1185	if (!thp)
1148	return NULL;	1186	return NULL;
1149	prep_transhuge_page(thp);	1187	prep_transhuge_page(thp);
@@ -1157,9 +1195,10 @@ static struct page new_page(struct page page, unsigned long start) · 7 unmodified lines
1157	}	1195	}
1158	#else	1196	#else
1159		1197
1160	static void migrate_page_add(struct page page, struct list_head pagelist,	1198	static int migrate_page_add(struct page page, struct list_head pagelist,
1161	unsigned long flags)	1199	unsigned long flags)
1162	{	1200	{
		1201	return -EIO;
1163	}	1202	}
1164		1203
1165	int do_migrate_pages(struct mm_struct mm, const nodemask_t from,	1204	int do_migrate_pages(struct mm_struct mm, const nodemask_t from,
@@ -1182,6 +1221,7 @@ static long do_mbind(unsigned long start, unsigned long len, · 16 unmodified lines
1182	struct mempolicy *new;	1221	struct mempolicy *new;
1183	unsigned long end;	1222	unsigned long end;
1184	int err;	1223	int err;
		1224	int ret;
1185	LIST_HEAD(pagelist);	1225	LIST_HEAD(pagelist);
1186		1226
1187	if (flags & ~(unsigned long)MPOL_MF_VALID)	1227	if (flags & ~(unsigned long)MPOL_MF_VALID)
@@ -1243,10 +1283,15 @@ static long do_mbind(unsigned long start, unsigned long len, · 55 unmodified lines
1243	if (err)	1283	if (err)
1244	goto mpol_out;	1284	goto mpol_out;
1245		1285
1246	err = queue_pages_range(mm, start, end, nmask,	1286	ret = queue_pages_range(mm, start, end, nmask,
1247	flags \| MPOL_MF_INVERT, &pagelist);	1287	flags \| MPOL_MF_INVERT, &pagelist);
1248	if (!err)	1288
1249	err = mbind_range(mm, start, end, new);	1289	if (ret < 0) {
		1290	err = -EIO;
		1291	goto up_out;
		1292	}
		1293
		1294	err = mbind_range(mm, start, end, new);
1250		1295
1251	if (!err) {	1296	if (!err) {
1252	int nr_failed = 0;	1297	int nr_failed = 0;
@@ -1259,13 +1304,14 @@ static long do_mbind(unsigned long start, unsigned long len, · 6 unmodified lines
1259	putback_movable_pages(&pagelist);	1304	putback_movable_pages(&pagelist);
1260	}	1305	}
1261		1306
1262	if (nr_failed && (flags & MPOL_MF_STRICT))	1307	if ((ret > 0) \|\| (nr_failed && (flags & MPOL_MF_STRICT)))
1263	err = -EIO;	1308	err = -EIO;
1264	} else	1309	} else
1265	putback_movable_pages(&pagelist);	1310	putback_movable_pages(&pagelist);
1266		1311
		1312	up_out:
1267	up_write(&mm->mmap_sem);	1313	up_write(&mm->mmap_sem);
1268	mpol_out:	1314	mpol_out:
1269	mpol_put(new);	1315	mpol_put(new);
1270	return err;	1316	return err;
1271	}	1317	}
@@ -1688,7 +1734,7 @@ struct mempolicy __get_vma_policy(struct vm_area_struct vma, · 416 unmodified lines
1688	* freeing by another task. It is the caller's responsibility to free the	1734	* freeing by another task. It is the caller's responsibility to free the
1689	* extra reference for shared policies.	1735	* extra reference for shared policies.
1690	*/	1736	*/
1691	static struct mempolicy get_vma_policy(struct vm_area_struct vma,	1737	struct mempolicy get_vma_policy(struct vm_area_struct vma,
1692	unsigned long addr)	1738	unsigned long addr)
1693	{	1739	{
1694	struct mempolicy *pol = __get_vma_policy(vma, addr);	1740	struct mempolicy *pol = __get_vma_policy(vma, addr);
@@ -2037,7 +2083,6 @@ static struct page *alloc_page_interleave(gfp_t gfp, unsigned order, · 342 unmodified lines
2037	* @vma: Pointer to VMA or NULL if not available.	2083	* @vma: Pointer to VMA or NULL if not available.
2038	* @addr: Virtual Address of the allocation. Must be inside the VMA.	2084	* @addr: Virtual Address of the allocation. Must be inside the VMA.
2039	* @node: Which node to prefer for allocation (modulo policy).	2085	* @node: Which node to prefer for allocation (modulo policy).
2040	* @hugepage: for hugepages try only the preferred node if possible
2041	*	2086	*
2042	* This function allocates a page from the kernel page pool and applies	2087	* This function allocates a page from the kernel page pool and applies
2043	* a NUMA policy associated with the VMA or the current process.	2088	* a NUMA policy associated with the VMA or the current process.
@@ -2048,7 +2093,7 @@ static struct page *alloc_page_interleave(gfp_t gfp, unsigned order, · 4 unmodified lines
2048	*/	2093	*/
2049	struct page *	2094	struct page *
2050	alloc_pages_vma(gfp_t gfp, int order, struct vm_area_struct *vma,	2095	alloc_pages_vma(gfp_t gfp, int order, struct vm_area_struct *vma,
2051	unsigned long addr, int node, bool hugepage)	2096	unsigned long addr, int node)
2052	{	2097	{
2053	struct mempolicy *pol;	2098	struct mempolicy *pol;
2054	struct page *page;	2099	struct page *page;
@@ -2066,31 +2111,6 @@ alloc_pages_vma(gfp_t gfp, int order, struct vm_area_struct *vma, · 11 unmodified lines
2066	goto out;	2111	goto out;
2067	}	2112	}
2068		2113
2069	if (unlikely(IS_ENABLED(CONFIG_TRANSPARENT_HUGEPAGE) && hugepage)) {
2070	int hpage_node = node;
2071
2072	/*
2073	* For hugepage allocation and non-interleave policy which
2074	* allows the current node (or other explicitly preferred
2075	* node) we only try to allocate from the current/preferred
2076	* node and don't fall back to other nodes, as the cost of
2077	* remote accesses would likely offset THP benefits.
2078	*
2079	* If the policy is interleave, or does not allow the current
2080	* node in its nodemask, we allocate the standard way.
2081	*/
2082	if (pol->mode == MPOL_PREFERRED && !(pol->flags & MPOL_F_LOCAL))
2083	hpage_node = pol->v.preferred_node;
2084
2085	nmask = policy_nodemask(gfp, pol);
2086	if (!nmask \|\| node_isset(hpage_node, *nmask)) {
2087	mpol_cond_put(pol);
2088	page = __alloc_pages_node(hpage_node,
2089	gfp \| __GFP_THISNODE, order);
2090	goto out;
2091	}
2092	}
2093
2094	nmask = policy_nodemask(gfp, pol);	2114	nmask = policy_nodemask(gfp, pol);
2095	preferred_nid = policy_node(gfp, pol, node);	2115	preferred_nid = policy_node(gfp, pol, node);
2096	page = __alloc_pages_nodemask(gfp, order, preferred_nid, nmask);	2116	page = __alloc_pages_nodemask(gfp, order, preferred_nid, nmask);

mm/memremap.c+30−0

@@ -91,6 +91,12 @@ static void dev_pagemap_cleanup(struct dev_pagemap *pgmap) · 90 unmodified lines
91	wait_for_completion(&pgmap->done);	91	wait_for_completion(&pgmap->done);
92	percpu_ref_exit(pgmap->ref);	92	percpu_ref_exit(pgmap->ref);
93	}	93	}
		94	/*
		95	* Undo the pgmap ref assignment for the internal case as the
		96	* caller may re-enable the same pgmap.
		97	*/
		98	if (pgmap->ref == &pgmap->internal_ref)
		99	pgmap->ref = NULL;
94	}	100	}
95		101
96	static void devm_memremap_pages_release(void *data)	102	static void devm_memremap_pages_release(void *data)
@@ -397,6 +403,30 @@ void __put_devmap_managed_page(struct page *page) · 300 unmodified lines
397		403
398	mem_cgroup_uncharge(page);	404	mem_cgroup_uncharge(page);
399		405
		406	/*
		407	* When a device_private page is freed, the page->mapping field
		408	* may still contain a (stale) mapping value. For example, the
		409	* lower bits of page->mapping may still identify the page as
		410	* an anonymous page. Ultimately, this entire field is just
		411	* stale and wrong, and it will cause errors if not cleared.
		412	* One example is:
		413	*
		414	* migrate_vma_pages()
		415	* migrate_vma_insert_page()
		416	* page_add_new_anon_rmap()
		417	* __page_set_anon_rmap()
		418	* ...checks page->mapping, via PageAnon(page) call,
		419	* and incorrectly concludes that the page is an
		420	* anonymous page. Therefore, it incorrectly,
		421	* silently fails to set up the new anon rmap.
		422	*
		423	* For other types of ZONE_DEVICE pages, migration is either
		424	* handled differently or not done at all, so there is no need
		425	* to clear page->mapping.
		426	*/
		427	if (is_device_private_page(page))
		428	page->mapping = NULL;
		429
400	page->pgmap->ops->page_free(page);	430	page->pgmap->ops->page_free(page);
401	} else if (!count)	431	} else if (!count)
402	__put_page(page);	432	__put_page(page);

mm/rmap.c+8−0

@@ -1475,7 +1475,15 @@ static bool try_to_unmap_one(struct page page, struct vm_area_struct vma, · 1474 unmodified lines
1475	/*	1475	/*
1476	* No need to invalidate here it will synchronize on	1476	* No need to invalidate here it will synchronize on
1477	* against the special swap migration pte.	1477	* against the special swap migration pte.
		1478	*
		1479	* The assignment to subpage above was computed from a
		1480	* swap PTE which results in an invalid pointer.
		1481	* Since only PAGE_SIZE pages can currently be
		1482	* migrated, just set it to page. This will need to be
		1483	* changed when hugepage migrations to device private
		1484	* memory are supported.
1478	*/	1485	*/
		1486	subpage = page;
1479	goto discard;	1487	goto discard;
1480	}	1488	}
1481		1489

mm/shmem.c+1−1

@@ -1466,7 +1466,7 @@ static struct page *shmem_alloc_hugepage(gfp_t gfp, · 1465 unmodified lines
1466		1466
1467	shmem_pseudo_vma_init(&pvma, info, hindex);	1467	shmem_pseudo_vma_init(&pvma, info, hindex);
1468	page = alloc_pages_vma(gfp \| __GFP_COMP \| __GFP_NORETRY \| __GFP_NOWARN,	1468	page = alloc_pages_vma(gfp \| __GFP_COMP \| __GFP_NORETRY \| __GFP_NOWARN,
1469	HPAGE_PMD_ORDER, &pvma, 0, numa_node_id(), true);	1469	HPAGE_PMD_ORDER, &pvma, 0, numa_node_id());
1470	shmem_pseudo_vma_destroy(&pvma);	1470	shmem_pseudo_vma_destroy(&pvma);
1471	if (page)	1471	if (page)
1472	prep_transhuge_page(page);	1472	prep_transhuge_page(page);

mm/usercopy.c+1−1

@@ -147,7 +147,7 @@ static inline void check_bogus_address(const unsigned long ptr, unsigned long n, · 146 unmodified lines
147	bool to_user)	147	bool to_user)
148	{	148	{
149	/* Reject if object wraps past end of memory. */	149	/* Reject if object wraps past end of memory. */
150	if (ptr + n < ptr)	150	if (ptr + (n - 1) < ptr)
151	usercopy_abort("wrapped address", NULL, to_user, 0, ptr + n);	151	usercopy_abort("wrapped address", NULL, to_user, 0, ptr + n);
152		152
153	/* Reject if NULL or ZERO-allocation. */	153	/* Reject if NULL or ZERO-allocation. */

mm/vmalloc.c+11−1

 		if (va == NULL)
 			goto overflow;
+		/*
+		 * If required width exeeds current VA block, move
+		 * base downwards and then recheck.
+		 */
+		if (base + end > va->va_end) {
+			base = pvm_determine_end_from_reverse(&va, align) - end;
+			term_area = area;
+			continue;
+		}
 		/*
 		 * If this VA does not fit, move base downwards and recheck.
 		 */
-		if (base + start < va->va_start || base + end > va->va_end) {
+		if (base + start < va->va_start) {
 			va = node_to_va(rb_prev(&va->rb_node));
 			base = pvm_determine_end_from_reverse(&va, align) - end;
 			term_area = area;

mm/vmscan.c+2−11

 	/* Can pages be swapped as part of reclaim? */
 	unsigned int may_swap:1;
-	/* e.g. boosted watermark reclaim leaves slabs alone */
-	unsigned int may_shrinkslab:1;
 	/*
 	 * Cgroups are not reclaimed below their configured memory.low,
 	 * unless we threaten to OOM. If any cgroups are skipped due to
 			shrink_node_memcg(pgdat, memcg, sc, &lru_pages);
 			node_lru_pages += lru_pages;
-			if (sc->may_shrinkslab) {
+			shrink_slab(sc->gfp_mask, pgdat->node_id, memcg,
-				shrink_slab(sc->gfp_mask, pgdat->node_id,
+					sc->priority);
-				    memcg, sc->priority);
-			}
 			/* Record the group's reclaim efficiency */
 			vmpressure(sc->gfp_mask, memcg, false,
 		.may_writepage = !laptop_mode,
 		.may_unmap = 1,
 		.may_swap = 1,
-		.may_shrinkslab = 1,
 	};
 	/*
 		.may_unmap = 1,
 		.reclaim_idx = MAX_NR_ZONES - 1,
 		.may_swap = !noswap,
-		.may_shrinkslab = 1,
 	};
 	unsigned long lru_pages;
 		.may_writepage = !laptop_mode,
 		.may_unmap = 1,
 		.may_swap = may_swap,
-		.may_shrinkslab = 1,
 	};
 	set_task_reclaim_state(current, &sc.reclaim_state);
 		 */
 		sc.may_writepage = !laptop_mode && !nr_boost_reclaim;
 		sc.may_swap = !nr_boost_reclaim;
-		sc.may_shrinkslab = !nr_boost_reclaim;
 		/*
 		 * Do some background aging of the anon list, to give

mm/workingset.c+4−6

 	if (node->count && node->count == node->nr_values) {
 		if (list_empty(&node->private_list)) {
 			list_lru_add(&shadow_nodes, &node->private_list);
-			__inc_lruvec_page_state(virt_to_page(node),
+			__inc_lruvec_slab_state(node, WORKINGSET_NODES);
-						WORKINGSET_NODES);
 		}
 	} else {
 		if (!list_empty(&node->private_list)) {
 			list_lru_del(&shadow_nodes, &node->private_list);
-			__dec_lruvec_page_state(virt_to_page(node),
+			__dec_lruvec_slab_state(node, WORKINGSET_NODES);
-						WORKINGSET_NODES);
 		}
 	}
 }
 	}
 	list_lru_isolate(lru, item);
-	__dec_lruvec_page_state(virt_to_page(node), WORKINGSET_NODES);
+	__dec_lruvec_slab_state(node, WORKINGSET_NODES);
 	spin_unlock(lru_lock);
 	 * shadow entries we were tracking ...
 	 */
 	xas_store(&xas, NULL);
-	__inc_lruvec_page_state(virt_to_page(node), WORKINGSET_NODERECLAIM);
+	__inc_lruvec_slab_state(node, WORKINGSET_NODERECLAIM);
 out_invalid:
 	xa_unlock_irq(&mapping->i_pages);

mm/z3fold.c+12−2

@@ -817,9 +817,19 @@ out: · 816 unmodified lines
817	static void z3fold_destroy_pool(struct z3fold_pool *pool)	817	static void z3fold_destroy_pool(struct z3fold_pool *pool)
818	{	818	{
819	kmem_cache_destroy(pool->c_handle);	819	kmem_cache_destroy(pool->c_handle);
820	z3fold_unregister_migration(pool);	820
821	destroy_workqueue(pool->release_wq);	821	/*
		822	* We need to destroy pool->compact_wq before pool->release_wq,
		823	* as any pending work on pool->compact_wq will call
		824	* queue_work(pool->release_wq, &pool->work).
		825	*
		826	* There are still outstanding pages until both workqueues are drained,
		827	* so we cannot unregister migration until then.
		828	*/
		829
822	destroy_workqueue(pool->compact_wq);	830	destroy_workqueue(pool->compact_wq);
		831	destroy_workqueue(pool->release_wq);
		832	z3fold_unregister_migration(pool);
823	kfree(pool);	833	kfree(pool);
824	}	834	}
825		835

net/batman-adv/multicast.c+5−3

 	while (bucket_tmp < hash->size) {
 		if (batadv_mcast_flags_dump_bucket(msg, portid, cb, hash,
-						   *bucket, &idx_tmp))
+						   bucket_tmp, &idx_tmp))
 			break;
 		bucket_tmp++;
 	batadv_mcast_want_unsnoop_update(bat_priv, orig, BATADV_NO_FLAGS);
 	batadv_mcast_want_ipv4_update(bat_priv, orig, BATADV_NO_FLAGS);
 	batadv_mcast_want_ipv6_update(bat_priv, orig, BATADV_NO_FLAGS);
-	batadv_mcast_want_rtr4_update(bat_priv, orig, BATADV_NO_FLAGS);
+	batadv_mcast_want_rtr4_update(bat_priv, orig,
-	batadv_mcast_want_rtr6_update(bat_priv, orig, BATADV_NO_FLAGS);
+				      BATADV_MCAST_WANT_NO_RTR4);
+	batadv_mcast_want_rtr6_update(bat_priv, orig,
+				      BATADV_MCAST_WANT_NO_RTR6);
 	spin_unlock_bh(&orig->mcast_handler_lock);
 }

net/bluetooth/hci_core.c+1−0

@@ -3202,6 +3202,7 @@ struct hci_dev *hci_alloc_dev(void) · 3201 unmodified lines
3202	hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE;	3202	hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE;
3203	hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE;	3203	hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE;
3204	hdev->auth_payload_timeout = DEFAULT_AUTH_PAYLOAD_TIMEOUT;	3204	hdev->auth_payload_timeout = DEFAULT_AUTH_PAYLOAD_TIMEOUT;
		3205	hdev->min_enc_key_size = HCI_MIN_ENC_KEY_SIZE;
3205		3206
3206	mutex_init(&hdev->lock);	3207	mutex_init(&hdev->lock);
3207	mutex_init(&hdev->req_lock);	3208	mutex_init(&hdev->req_lock);

net/bluetooth/hci_debugfs.c+31−0

@@ -433,6 +433,35 @@ static int auto_accept_delay_set(void *data, u64 val) · 432 unmodified lines
433	return 0;	433	return 0;
434	}	434	}
435		435
		436	static int min_encrypt_key_size_set(void *data, u64 val)
		437	{
		438	struct hci_dev *hdev = data;
		439
		440	if (val < 1 \|\| val > 16)
		441	return -EINVAL;
		442
		443	hci_dev_lock(hdev);
		444	hdev->min_enc_key_size = val;
		445	hci_dev_unlock(hdev);
		446
		447	return 0;
		448	}
		449
		450	static int min_encrypt_key_size_get(void data, u64 val)
		451	{
		452	struct hci_dev *hdev = data;
		453
		454	hci_dev_lock(hdev);
		455	*val = hdev->min_enc_key_size;
		456	hci_dev_unlock(hdev);
		457
		458	return 0;
		459	}
		460
		461	DEFINE_SIMPLE_ATTRIBUTE(min_encrypt_key_size_fops,
		462	min_encrypt_key_size_get,
		463	min_encrypt_key_size_set, "%llu\n");
		464
436	static int auto_accept_delay_get(void data, u64 val)	465	static int auto_accept_delay_get(void data, u64 val)
437	{	466	{
438	struct hci_dev *hdev = data;	467	struct hci_dev *hdev = data;
@@ -545,6 +574,8 @@ void hci_debugfs_create_bredr(struct hci_dev *hdev) · 106 unmodified lines
545	if (lmp_ssp_capable(hdev)) {	574	if (lmp_ssp_capable(hdev)) {
546	debugfs_create_file("ssp_debug_mode", 0444, hdev->debugfs,	575	debugfs_create_file("ssp_debug_mode", 0444, hdev->debugfs,
547	hdev, &ssp_debug_mode_fops);	576	hdev, &ssp_debug_mode_fops);
		577	debugfs_create_file("min_encrypt_key_size", 0644, hdev->debugfs,
		578	hdev, &min_encrypt_key_size_fops);
548	debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs,	579	debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs,
549	hdev, &auto_accept_delay_fops);	580	hdev, &auto_accept_delay_fops);
550	}	581	}

net/bluetooth/hidp/core.c+7−2

 {
 	struct sk_buff *skb;
 	struct sock *sk = sock->sk;
+	int ret;
 	BT_DBG("session %p data %p size %d", session, data, size);
 	}
 	skb_put_u8(skb, hdr);
-	if (data && size > 0)
+	if (data && size > 0) {
 		skb_put_data(skb, data, size);
+		ret = size;
+	} else {
+		ret = 0;
+	}
 	skb_queue_tail(transmit, skb);
 	wake_up_interruptible(sk_sleep(sk));
-	return 0;
+	return ret;
 }
 static int hidp_send_ctrl_message(struct hidp_session *session,

net/bluetooth/l2cap_core.c+1−1

@@ -1361,7 +1361,7 @@ static bool l2cap_check_enc_key_size(struct hci_conn *hcon) · 1360 unmodified lines
1361	* actually encrypted before enforcing a key size.	1361	* actually encrypted before enforcing a key size.
1362	*/	1362	*/
1363	return (!test_bit(HCI_CONN_ENCRYPT, &hcon->flags) \|\|	1363	return (!test_bit(HCI_CONN_ENCRYPT, &hcon->flags) \|\|
1364	hcon->enc_key_size >= HCI_MIN_ENC_KEY_SIZE);	1364	hcon->enc_key_size >= hcon->hdev->min_enc_key_size);
1365	}	1365	}
1366		1366
1367	static void l2cap_do_start(struct l2cap_chan *chan)	1367	static void l2cap_do_start(struct l2cap_chan *chan)

net/core/sock.c+14−5

 }
 EXPORT_SYMBOL(skb_set_owner_w);
+static bool can_skb_orphan_partial(const struct sk_buff *skb)
+{
+#ifdef CONFIG_TLS_DEVICE
+	/* Drivers depend on in-order delivery for crypto offload,
+	 * partial orphan breaks out-of-order-OK logic.
+	 */
+	if (skb->decrypted)
+		return false;
+#endif
+	return (skb->destructor == sock_wfree ||
+		(IS_ENABLED(CONFIG_INET) && skb->destructor == tcp_wfree));
+}
 /* This helper is used by netem, as it can hold packets in its
  * delay queue. We want to allow the owner socket to send more
  * packets, as if they were already TX completed by a typical driver.
 	if (skb_is_tcp_pure_ack(skb))
 		return;
-	if (skb->destructor == sock_wfree
+	if (can_skb_orphan_partial(skb)) {
-#ifdef CONFIG_INET
-	    || skb->destructor == tcp_wfree
-#endif
-		) {
 		struct sock *sk = skb->sk;
 		if (refcount_inc_not_zero(&sk->sk_refcnt)) {

net/core/sock_diag.c+2−1

 static int (*inet_rcv_compat)(struct sk_buff *skb, struct nlmsghdr *nlh);
 static DEFINE_MUTEX(sock_diag_table_mutex);
 static struct workqueue_struct *broadcast_wq;
+static atomic64_t cookie_gen;
 u64 sock_gen_cookie(struct sock *sk)
 {
 		if (res)
 			return res;
-		res = atomic64_inc_return(&sock_net(sk)->cookie_gen);
+		res = atomic64_inc_return(&cookie_gen);
 		atomic64_cmpxchg(&sk->sk_cookie, 0, res);
 	}
 }

net/dsa/switch.c+3−0

@@ -153,6 +153,9 @@ static void dsa_switch_mdb_add_bitmap(struct dsa_switch *ds, · 152 unmodified lines
153	{	153	{
154	int port;	154	int port;
155		155
		156	if (!ds->ops->port_mdb_add)
		157	return;
		158
156	for_each_set_bit(port, bitmap, ds->num_ports)	159	for_each_set_bit(port, bitmap, ds->num_ports)
157	ds->ops->port_mdb_add(ds, port, mdb);	160	ds->ops->port_mdb_add(ds, port, mdb);
158	}	161	}

net/ieee802154/6lowpan/reassembly.c+1−1

@@ -170,7 +170,7 @@ static int lowpan_frag_reasm(struct lowpan_frag_queue fq, struct sk_buff skb, · 169 unmodified lines
170	reasm_data = inet_frag_reasm_prepare(&fq->q, skb, prev_tail);	170	reasm_data = inet_frag_reasm_prepare(&fq->q, skb, prev_tail);
171	if (!reasm_data)	171	if (!reasm_data)
172	goto out_oom;	172	goto out_oom;
173	inet_frag_reasm_finish(&fq->q, skb, reasm_data);	173	inet_frag_reasm_finish(&fq->q, skb, reasm_data, false);
174		174
175	skb->dev = ldev;	175	skb->dev = ldev;
176	skb->tstamp = fq->q.stamp;	176	skb->tstamp = fq->q.stamp;

net/ipv4/inet_fragment.c+28−11

@@ -475,11 +475,12 @@ void inet_frag_reasm_prepare(struct inet_frag_queue q, struct sk_buff *skb, · 474 unmodified lines
475	EXPORT_SYMBOL(inet_frag_reasm_prepare);	475	EXPORT_SYMBOL(inet_frag_reasm_prepare);
476		476
477	void inet_frag_reasm_finish(struct inet_frag_queue q, struct sk_buff head,	477	void inet_frag_reasm_finish(struct inet_frag_queue q, struct sk_buff head,
478	void *reasm_data)	478	void *reasm_data, bool try_coalesce)
479	{	479	{
480	struct sk_buff nextp = (struct sk_buff )reasm_data;	480	struct sk_buff nextp = (struct sk_buff )reasm_data;
481	struct rb_node *rbn;	481	struct rb_node *rbn;
482	struct sk_buff *fp;	482	struct sk_buff *fp;
		483	int sum_truesize;
483		484
484	skb_push(head, head->data - skb_network_header(head));	485	skb_push(head, head->data - skb_network_header(head));
485		486
@@ -487,25 +488,41 @@ void inet_frag_reasm_finish(struct inet_frag_queue q, struct sk_buff head, · 1 unmodified line
487	fp = FRAG_CB(head)->next_frag;	488	fp = FRAG_CB(head)->next_frag;
488	rbn = rb_next(&head->rbnode);	489	rbn = rb_next(&head->rbnode);
489	rb_erase(&head->rbnode, &q->rb_fragments);	490	rb_erase(&head->rbnode, &q->rb_fragments);
		491
		492	sum_truesize = head->truesize;
490	while (rbn \|\| fp) {	493	while (rbn \|\| fp) {
491	/* fp points to the next sk_buff in the current run;	494	/* fp points to the next sk_buff in the current run;
492	* rbn points to the next run.	495	* rbn points to the next run.
493	*/	496	*/
494	/* Go through the current run. */	497	/* Go through the current run. */
495	while (fp) {	498	while (fp) {
496	*nextp = fp;	499	struct sk_buff *next_frag = FRAG_CB(fp)->next_frag;
497	nextp = &fp->next;	500	bool stolen;
498	fp->prev = NULL;	501	int delta;
499	memset(&fp->rbnode, 0, sizeof(fp->rbnode));	502
500	fp->sk = NULL;	503	sum_truesize += fp->truesize;
501	head->data_len += fp->len;
502	head->len += fp->len;
503	if (head->ip_summed != fp->ip_summed)	504	if (head->ip_summed != fp->ip_summed)
504	head->ip_summed = CHECKSUM_NONE;	505	head->ip_summed = CHECKSUM_NONE;
505	else if (head->ip_summed == CHECKSUM_COMPLETE)	506	else if (head->ip_summed == CHECKSUM_COMPLETE)
506	head->csum = csum_add(head->csum, fp->csum);	507	head->csum = csum_add(head->csum, fp->csum);
507	head->truesize += fp->truesize;	508
508	fp = FRAG_CB(fp)->next_frag;	509	if (try_coalesce && skb_try_coalesce(head, fp, &stolen,
		510	&delta)) {
		511	kfree_skb_partial(fp, stolen);
		512	} else {
		513	fp->prev = NULL;
		514	memset(&fp->rbnode, 0, sizeof(fp->rbnode));
		515	fp->sk = NULL;
		516
		517	head->data_len += fp->len;
		518	head->len += fp->len;
		519	head->truesize += fp->truesize;
		520
		521	*nextp = fp;
		522	nextp = &fp->next;
		523	}
		524
		525	fp = next_frag;
509	}	526	}
510	/* Move to the next run. */	527	/* Move to the next run. */
511	if (rbn) {	528	if (rbn) {
@@ -516,7 +533,7 @@ void inet_frag_reasm_finish(struct inet_frag_queue q, struct sk_buff head, · 4 unmodified lines
516	rbn = rbnext;	533	rbn = rbnext;
517	}	534	}
518	}	535	}
519	sub_frag_mem_limit(q->fqdir, head->truesize);	536	sub_frag_mem_limit(q->fqdir, sum_truesize);
520		537
521	*nextp = NULL;	538	*nextp = NULL;
522	skb_mark_not_on_list(head);	539	skb_mark_not_on_list(head);

net/ipv4/ip_fragment.c+7−1

 	return err;
 }
+static bool ip_frag_coalesce_ok(const struct ipq *qp)
+{
+	return qp->q.key.v4.user == IP_DEFRAG_LOCAL_DELIVER;
+}
 /* Build a new IP datagram from all its fragments. */
 static int ip_frag_reasm(struct ipq *qp, struct sk_buff *skb,
 			 struct sk_buff *prev_tail, struct net_device *dev)
 	if (len > 65535)
 		goto out_oversize;
-	inet_frag_reasm_finish(&qp->q, skb, reasm_data);
+	inet_frag_reasm_finish(&qp->q, skb, reasm_data,
+			       ip_frag_coalesce_ok(qp));
 	skb->dev = dev;
 	IPCB(skb)->frag_max_size = max(qp->max_df_size, qp->q.max_size);

net/ipv4/tcp.c+3−0

 			if (!skb)
 				goto wait_for_memory;
+#ifdef CONFIG_TLS_DEVICE
+			skb->decrypted = !!(flags & MSG_SENDPAGE_DECRYPTED);
+#endif
 			skb_entail(sk, skb);
 			copy = size_goal;
 		}

net/ipv4/tcp_bpf.c+5−1

 static int tcp_bpf_sendmsg(struct sock *sk, struct msghdr *msg, size_t size)
 {
 	struct sk_msg tmp, *msg_tx = NULL;
-	int flags = msg->msg_flags | MSG_NO_SHARED_FRAGS;
 	int copied = 0, err = 0;
 	struct sk_psock *psock;
 	long timeo;
+	int flags;
+	/* Don't let internal do_tcp_sendpages() flags through */
+	flags = (msg->msg_flags & ~MSG_SENDPAGE_DECRYPTED);
+	flags |= MSG_NO_SHARED_FRAGS;
 	psock = sk_psock_get(sk);
 	if (unlikely(!psock))

net/ipv4/tcp_output.c+3−0

 	buff = sk_stream_alloc_skb(sk, nsize, gfp, true);
 	if (!buff)
 		return -ENOMEM; /* We'll just try again later. */
+	skb_copy_decrypted(buff, skb);
 	sk->sk_wmem_queued += buff->truesize;
 	sk_mem_charge(sk, buff->truesize);
 	buff = sk_stream_alloc_skb(sk, 0, gfp, true);
 	if (unlikely(!buff))
 		return -ENOMEM;
+	skb_copy_decrypted(buff, skb);
 	sk->sk_wmem_queued += buff->truesize;
 	sk_mem_charge(sk, buff->truesize);
 	sk_mem_charge(sk, nskb->truesize);
 	skb = tcp_send_head(sk);
+	skb_copy_decrypted(nskb, skb);
 	TCP_SKB_CB(nskb)->seq = TCP_SKB_CB(skb)->seq;
 	TCP_SKB_CB(nskb)->end_seq = TCP_SKB_CB(skb)->seq + probe_size;

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

@@ -348,7 +348,7 @@ static int nf_ct_frag6_reasm(struct frag_queue fq, struct sk_buff skb, · 347 unmodified lines
348		348
349	skb_reset_transport_header(skb);	349	skb_reset_transport_header(skb);
350		350
351	inet_frag_reasm_finish(&fq->q, skb, reasm_data);	351	inet_frag_reasm_finish(&fq->q, skb, reasm_data, false);
352		352
353	skb->ignore_df = 1;	353	skb->ignore_df = 1;
354	skb->dev = dev;	354	skb->dev = dev;

net/ipv6/reassembly.c+1−1

@@ -282,7 +282,7 @@ static int ip6_frag_reasm(struct frag_queue fq, struct sk_buff skb, · 281 unmodified lines
282		282
283	skb_reset_transport_header(skb);	283	skb_reset_transport_header(skb);
284		284
285	inet_frag_reasm_finish(&fq->q, skb, reasm_data);	285	inet_frag_reasm_finish(&fq->q, skb, reasm_data, true);
286		286
287	skb->dev = dev;	287	skb->dev = dev;
288	ipv6_hdr(skb)->payload_len = htons(payload_len);	288	ipv6_hdr(skb)->payload_len = htons(payload_len);

net/netfilter/nf_conntrack_core.c+8−8

  * table location, we assume id gets exposed to userspace.
  *
  * Following nf_conn items do not change throughout lifetime
- * of the nf_conn after it has been committed to main hash table:
+ * of the nf_conn:
  *
  * 1. nf_conn address
- * 2. nf_conn->ext address
+ * 2. nf_conn->master address (normally NULL)
- * 3. nf_conn->master address (normally NULL)
+ * 3. the associated net namespace
- * 4. tuple
+ * 4. the original direction tuple
- * 5. the associated net namespace
  */
 u32 nf_ct_get_id(const struct nf_conn *ct)
 {
 	net_get_random_once(&ct_id_seed, sizeof(ct_id_seed));
 	a = (unsigned long)ct;
-	b = (unsigned long)ct->master ^ net_hash_mix(nf_ct_net(ct));
+	b = (unsigned long)ct->master;
-	c = (unsigned long)ct->ext;
+	c = (unsigned long)nf_ct_net(ct);
-	d = (unsigned long)siphash(&ct->tuplehash, sizeof(ct->tuplehash),
+	d = (unsigned long)siphash(&ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple,
+				   sizeof(ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple),
 				   &ct_id_seed);
 #ifdef CONFIG_64BIT
 	return siphash_4u64((u64)a, (u64)b, (u64)c, (u64)d, &ct_id_seed);

net/netfilter/nf_flow_table_core.c+31−12

 #define NF_FLOWTABLE_TCP_PICKUP_TIMEOUT	(120 * HZ)
 #define NF_FLOWTABLE_UDP_PICKUP_TIMEOUT	(30 * HZ)
-static void flow_offload_fixup_ct_state(struct nf_conn *ct)
+static inline __s32 nf_flow_timeout_delta(unsigned int timeout)
+{
+	return (__s32)(timeout - (u32)jiffies);
+}
+static void flow_offload_fixup_ct_timeout(struct nf_conn *ct)
 {
 	const struct nf_conntrack_l4proto *l4proto;
+	int l4num = nf_ct_protonum(ct);
 	unsigned int timeout;
-	int l4num;
-	l4num = nf_ct_protonum(ct);
-	if (l4num == IPPROTO_TCP)
-		flow_offload_fixup_tcp(&ct->proto.tcp);
 	l4proto = nf_ct_l4proto_find(l4num);
 	if (!l4proto)
 	else
 		return;
-	ct->timeout = nfct_time_stamp + timeout;
+	if (nf_flow_timeout_delta(ct->timeout) > (__s32)timeout)
+		ct->timeout = nfct_time_stamp + timeout;
+}
+static void flow_offload_fixup_ct_state(struct nf_conn *ct)
+{
+	if (nf_ct_protonum(ct) == IPPROTO_TCP)
+		flow_offload_fixup_tcp(&ct->proto.tcp);
+}
+static void flow_offload_fixup_ct(struct nf_conn *ct)
+{
+	flow_offload_fixup_ct_state(ct);
+	flow_offload_fixup_ct_timeout(ct);
 }
 void flow_offload_free(struct flow_offload *flow)
 }
 EXPORT_SYMBOL_GPL(flow_offload_add);
+static inline bool nf_flow_has_expired(const struct flow_offload *flow)
+{
+	return nf_flow_timeout_delta(flow->timeout) <= 0;
+}
 static void flow_offload_del(struct nf_flowtable *flow_table,
 			     struct flow_offload *flow)
 {
 	e = container_of(flow, struct flow_offload_entry, flow);
 	clear_bit(IPS_OFFLOAD_BIT, &e->ct->status);
+	if (nf_flow_has_expired(flow))
+		flow_offload_fixup_ct(e->ct);
+	else if (flow->flags & FLOW_OFFLOAD_TEARDOWN)
+		flow_offload_fixup_ct_timeout(e->ct);
 	flow_offload_free(flow);
 }
 	return err;
 }
-static inline bool nf_flow_has_expired(const struct flow_offload *flow)
-{
-	return (__s32)(flow->timeout - (u32)jiffies) <= 0;
-}
 static void nf_flow_offload_gc_step(struct flow_offload *flow, void *data)
 {
 	struct nf_flowtable *flow_table = data;

net/netfilter/nf_flow_table_ip.c+43−0

@@ -214,6 +214,25 @@ static bool nf_flow_exceeds_mtu(const struct sk_buff *skb, unsigned int mtu) · 213 unmodified lines
214	return true;	214	return true;
215	}	215	}
216		216
		217	static int nf_flow_offload_dst_check(struct dst_entry *dst)
		218	{
		219	if (unlikely(dst_xfrm(dst)))
		220	return dst_check(dst, 0) ? 0 : -1;
		221
		222	return 0;
		223	}
		224
		225	static unsigned int nf_flow_xmit_xfrm(struct sk_buff *skb,
		226	const struct nf_hook_state *state,
		227	struct dst_entry *dst)
		228	{
		229	skb_orphan(skb);
		230	skb_dst_set_noref(skb, dst);
		231	skb->tstamp = 0;
		232	dst_output(state->net, state->sk, skb);
		233	return NF_STOLEN;
		234	}
		235
217	unsigned int	236	unsigned int
218	nf_flow_offload_ip_hook(void priv, struct sk_buff skb,	237	nf_flow_offload_ip_hook(void priv, struct sk_buff skb,
219	const struct nf_hook_state *state)	238	const struct nf_hook_state *state)
@@ -254,6 +273,11 @@ nf_flow_offload_ip_hook(void priv, struct sk_buff skb, · 34 unmodified lines
254	if (nf_flow_state_check(flow, ip_hdr(skb)->protocol, skb, thoff))	273	if (nf_flow_state_check(flow, ip_hdr(skb)->protocol, skb, thoff))
255	return NF_ACCEPT;	274	return NF_ACCEPT;
256		275
		276	if (nf_flow_offload_dst_check(&rt->dst)) {
		277	flow_offload_teardown(flow);
		278	return NF_ACCEPT;
		279	}
		280
257	if (nf_flow_nat_ip(flow, skb, thoff, dir) < 0)	281	if (nf_flow_nat_ip(flow, skb, thoff, dir) < 0)
258	return NF_DROP;	282	return NF_DROP;
259		283
@@ -261,6 +285,13 @@ nf_flow_offload_ip_hook(void priv, struct sk_buff skb, · 1 unmodified line
261	iph = ip_hdr(skb);	285	iph = ip_hdr(skb);
262	ip_decrease_ttl(iph);	286	ip_decrease_ttl(iph);
263		287
		288	if (unlikely(dst_xfrm(&rt->dst))) {
		289	memset(skb->cb, 0, sizeof(struct inet_skb_parm));
		290	IPCB(skb)->iif = skb->dev->ifindex;
		291	IPCB(skb)->flags = IPSKB_FORWARDED;
		292	return nf_flow_xmit_xfrm(skb, state, &rt->dst);
		293	}
		294
264	skb->dev = outdev;	295	skb->dev = outdev;
265	nexthop = rt_nexthop(rt, flow->tuplehash[!dir].tuple.src_v4.s_addr);	296	nexthop = rt_nexthop(rt, flow->tuplehash[!dir].tuple.src_v4.s_addr);
266	skb_dst_set_noref(skb, &rt->dst);	297	skb_dst_set_noref(skb, &rt->dst);
@@ -467,6 +498,11 @@ nf_flow_offload_ipv6_hook(void priv, struct sk_buff skb, · 200 unmodified lines
467	sizeof(*ip6h)))	498	sizeof(*ip6h)))
468	return NF_ACCEPT;	499	return NF_ACCEPT;
469		500
		501	if (nf_flow_offload_dst_check(&rt->dst)) {
		502	flow_offload_teardown(flow);
		503	return NF_ACCEPT;
		504	}
		505
470	if (skb_try_make_writable(skb, sizeof(*ip6h)))	506	if (skb_try_make_writable(skb, sizeof(*ip6h)))
471	return NF_DROP;	507	return NF_DROP;
472		508
@@ -477,6 +513,13 @@ nf_flow_offload_ipv6_hook(void priv, struct sk_buff skb, · 4 unmodified lines
477	ip6h = ipv6_hdr(skb);	513	ip6h = ipv6_hdr(skb);
478	ip6h->hop_limit--;	514	ip6h->hop_limit--;
479		515
		516	if (unlikely(dst_xfrm(&rt->dst))) {
		517	memset(skb->cb, 0, sizeof(struct inet6_skb_parm));
		518	IP6CB(skb)->iif = skb->dev->ifindex;
		519	IP6CB(skb)->flags = IP6SKB_FORWARDED;
		520	return nf_flow_xmit_xfrm(skb, state, &rt->dst);
		521	}
		522
480	skb->dev = outdev;	523	skb->dev = outdev;
481	nexthop = rt6_nexthop(rt, &flow->tuplehash[!dir].tuple.src_v6);	524	nexthop = rt6_nexthop(rt, &flow->tuplehash[!dir].tuple.src_v6);
482	skb_dst_set_noref(skb, &rt->dst);	525	skb_dst_set_noref(skb, &rt->dst);

net/netfilter/nf_tables_api.c+14−5

 		return;
 	list_for_each_entry_reverse(trans, &net->nft.commit_list, list) {
-		if (trans->msg_type == NFT_MSG_NEWSET &&
+		switch (trans->msg_type) {
-		    nft_trans_set(trans) == set) {
+		case NFT_MSG_NEWSET:
-			set->bound = true;
+			if (nft_trans_set(trans) == set)
+				nft_trans_set_bound(trans) = true;
+			break;
+		case NFT_MSG_NEWSETELEM:
+			if (nft_trans_elem_set(trans) == set)
+				nft_trans_elem_set_bound(trans) = true;
 			break;
 		}
 	}
 		chain->flags |= NFT_BASE_CHAIN | flags;
 		basechain->policy = NF_ACCEPT;
+		if (chain->flags & NFT_CHAIN_HW_OFFLOAD &&
+		    nft_chain_offload_priority(basechain) < 0)
+			return -EOPNOTSUPP;
 		flow_block_init(&basechain->flow_block);
 	} else {
 		chain = kzalloc(sizeof(*chain), GFP_KERNEL);
 			break;
 		case NFT_MSG_NEWSET:
 			trans->ctx.table->use--;
-			if (nft_trans_set(trans)->bound) {
+			if (nft_trans_set_bound(trans)) {
 				nft_trans_destroy(trans);
 				break;
 			}
 			nft_trans_destroy(trans);
 			break;
 		case NFT_MSG_NEWSETELEM:
-			if (nft_trans_elem_set(trans)->bound) {
+			if (nft_trans_elem_set_bound(trans)) {
 				nft_trans_destroy(trans);
 				break;
 			}

net/netfilter/nf_tables_offload.c+14−3

 }
 static void nft_flow_offload_common_init(struct flow_cls_common_offload *common,
-					 __be16 proto,
+					 __be16 proto, int priority,
-					struct netlink_ext_ack *extack)
+					 struct netlink_ext_ack *extack)
 {
 	common->protocol = proto;
+	common->prio = priority;
 	common->extack = extack;
 }
 	return 0;
 }
+int nft_chain_offload_priority(struct nft_base_chain *basechain)
+{
+	if (basechain->ops.priority <= 0 ||
+	    basechain->ops.priority > USHRT_MAX)
+		return -1;
+	return 0;
+}
 static int nft_flow_offload_rule(struct nft_trans *trans,
 				 enum flow_cls_command command)
 {
 	if (flow)
 		proto = flow->proto;
-	nft_flow_offload_common_init(&cls_flow.common, proto, &extack);
+	nft_flow_offload_common_init(&cls_flow.common, proto,
+				     basechain->ops.priority, &extack);
 	cls_flow.command = command;
 	cls_flow.cookie = (unsigned long) rule;
 	if (flow)

net/netfilter/nft_flow_offload.c+6−3

 {
 	struct nft_flow_offload *priv = nft_expr_priv(expr);
 	struct nf_flowtable *flowtable = &priv->flowtable->data;
+	struct tcphdr _tcph, *tcph = NULL;
 	enum ip_conntrack_info ctinfo;
 	struct nf_flow_route route;
 	struct flow_offload *flow;
 	enum ip_conntrack_dir dir;
-	bool is_tcp = false;
 	struct nf_conn *ct;
 	int ret;
 	switch (ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum) {
 	case IPPROTO_TCP:
-		is_tcp = true;
+		tcph = skb_header_pointer(pkt->skb, pkt->xt.thoff,
+					  sizeof(_tcph), &_tcph);
+		if (unlikely(!tcph || tcph->fin || tcph->rst))
+			goto out;
 		break;
 	case IPPROTO_UDP:
 		break;
 	if (!flow)
 		goto err_flow_alloc;
-	if (is_tcp) {
+	if (tcph) {
 		ct->proto.tcp.seen[0].flags |= IP_CT_TCP_FLAG_BE_LIBERAL;
 		ct->proto.tcp.seen[1].flags |= IP_CT_TCP_FLAG_BE_LIBERAL;
 	}

net/packet/af_packet.c+7−0

@@ -2618,6 +2618,13 @@ static int tpacket_snd(struct packet_sock po, struct msghdr msg) · 2617 unmodified lines
2618		2618
2619	mutex_lock(&po->pg_vec_lock);	2619	mutex_lock(&po->pg_vec_lock);
2620		2620
		2621	/* packet_sendmsg() check on tx_ring.pg_vec was lockless,
		2622	* we need to confirm it under protection of pg_vec_lock.
		2623	*/
		2624	if (unlikely(!po->tx_ring.pg_vec)) {
		2625	err = -EBUSY;
		2626	goto out;
		2627	}
2621	if (likely(saddr == NULL)) {	2628	if (likely(saddr == NULL)) {
2622	dev = packet_cached_dev_get(po);	2629	dev = packet_cached_dev_get(po);
2623	proto = po->num;	2630	proto = po->num;

net/rxrpc/af_rxrpc.c+3−3

@@ -193,7 +193,7 @@ static int rxrpc_bind(struct socket sock, struct sockaddr saddr, int len) · 192 unmodified lines
193		193
194	service_in_use:	194	service_in_use:
195	write_unlock(&local->services_lock);	195	write_unlock(&local->services_lock);
196	rxrpc_put_local(local);	196	rxrpc_unuse_local(local);
197	ret = -EADDRINUSE;	197	ret = -EADDRINUSE;
198	error_unlock:	198	error_unlock:
199	release_sock(&rx->sk);	199	release_sock(&rx->sk);
@@ -402,7 +402,7 @@ EXPORT_SYMBOL(rxrpc_kernel_check_life); · 202 unmodified lines
402	*/	402	*/
403	void rxrpc_kernel_probe_life(struct socket sock, struct rxrpc_call call)	403	void rxrpc_kernel_probe_life(struct socket sock, struct rxrpc_call call)
404	{	404	{
405	rxrpc_propose_ACK(call, RXRPC_ACK_PING, 0, 0, true, false,	405	rxrpc_propose_ACK(call, RXRPC_ACK_PING, 0, true, false,
406	rxrpc_propose_ack_ping_for_check_life);	406	rxrpc_propose_ack_ping_for_check_life);
407	rxrpc_send_ack_packet(call, true, NULL);	407	rxrpc_send_ack_packet(call, true, NULL);
408	}	408	}
@@ -901,7 +901,7 @@ static int rxrpc_release_sock(struct sock *sk) · 492 unmodified lines
901	rxrpc_queue_work(&rxnet->service_conn_reaper);	901	rxrpc_queue_work(&rxnet->service_conn_reaper);
902	rxrpc_queue_work(&rxnet->client_conn_reaper);	902	rxrpc_queue_work(&rxnet->client_conn_reaper);
903		903
904	rxrpc_put_local(rx->local);	904	rxrpc_unuse_local(rx->local);
905	rx->local = NULL;	905	rx->local = NULL;
906	key_put(rx->key);	906	key_put(rx->key);
907	rx->key = NULL;	907	rx->key = NULL;

net/rxrpc/ar-internal.h+5−3

  */
 struct rxrpc_local {
 	struct rcu_head		rcu;
-	atomic_t		usage;
+	atomic_t		active_users;	/* Number of users of the local endpoint */
+	atomic_t		usage;		/* Number of references to the structure */
 	struct rxrpc_net	*rxnet;		/* The network ns in which this resides */
 	struct list_head	link;
 	struct socket		*socket;	/* my UDP socket */
 	/* receive-phase ACK management */
 	u8			ackr_reason;	/* reason to ACK */
-	u16			ackr_skew;	/* skew on packet being ACK'd */
 	rxrpc_serial_t		ackr_serial;	/* serial of packet being ACK'd */
 	rxrpc_serial_t		ackr_first_seq;	/* first sequence number received */
 	rxrpc_seq_t		ackr_prev_seq;	/* previous sequence number received */
 /*
  * call_event.c
  */
-void rxrpc_propose_ACK(struct rxrpc_call *, u8, u16, u32, bool, bool,
+void rxrpc_propose_ACK(struct rxrpc_call *, u8, u32, bool, bool,
 		       enum rxrpc_propose_ack_trace);
 void rxrpc_process_call(struct work_struct *);
 struct rxrpc_local *rxrpc_get_local(struct rxrpc_local *);
 struct rxrpc_local *rxrpc_get_local_maybe(struct rxrpc_local *);
 void rxrpc_put_local(struct rxrpc_local *);
+struct rxrpc_local *rxrpc_use_local(struct rxrpc_local *);
+void rxrpc_unuse_local(struct rxrpc_local *);
 void rxrpc_queue_local(struct rxrpc_local *);
 void rxrpc_destroy_all_locals(struct rxrpc_net *);

net/rxrpc/call_event.c+6−9

  * propose an ACK be sent
  */
 static void __rxrpc_propose_ACK(struct rxrpc_call *call, u8 ack_reason,
-				u16 skew, u32 serial, bool immediate,
+				u32 serial, bool immediate, bool background,
-				bool background,
 				enum rxrpc_propose_ack_trace why)
 {
 	enum rxrpc_propose_ack_outcome outcome = rxrpc_propose_ack_use;
 		if (RXRPC_ACK_UPDATEABLE & (1 << ack_reason)) {
 			outcome = rxrpc_propose_ack_update;
 			call->ackr_serial = serial;
-			call->ackr_skew = skew;
 		}
 		if (!immediate)
 			goto trace;
 	} else if (prior > rxrpc_ack_priority[call->ackr_reason]) {
 		call->ackr_reason = ack_reason;
 		call->ackr_serial = serial;
-		call->ackr_skew = skew;
 	} else {
 		outcome = rxrpc_propose_ack_subsume;
 	}
  * propose an ACK be sent, locking the call structure
  */
 void rxrpc_propose_ACK(struct rxrpc_call *call, u8 ack_reason,
-		       u16 skew, u32 serial, bool immediate, bool background,
+		       u32 serial, bool immediate, bool background,
 		       enum rxrpc_propose_ack_trace why)
 {
 	spin_lock_bh(&call->lock);
-	__rxrpc_propose_ACK(call, ack_reason, skew, serial,
+	__rxrpc_propose_ACK(call, ack_reason, serial,
 			    immediate, background, why);
 	spin_unlock_bh(&call->lock);
 }
 		ack_ts = ktime_sub(now, call->acks_latest_ts);
 		if (ktime_to_ns(ack_ts) < call->peer->rtt)
 			goto out;
-		rxrpc_propose_ACK(call, RXRPC_ACK_PING, 0, 0, true, false,
+		rxrpc_propose_ACK(call, RXRPC_ACK_PING, 0, true, false,
 				  rxrpc_propose_ack_ping_for_lost_ack);
 		rxrpc_send_ack_packet(call, true, NULL);
 		goto out;
 	if (time_after_eq(now, t)) {
 		trace_rxrpc_timer(call, rxrpc_timer_exp_keepalive, now);
 		cmpxchg(&call->keepalive_at, t, now + MAX_JIFFY_OFFSET);
-		rxrpc_propose_ACK(call, RXRPC_ACK_PING, 0, 0, true, true,
+		rxrpc_propose_ACK(call, RXRPC_ACK_PING, 0, true, true,
 				  rxrpc_propose_ack_ping_for_keepalive);
 		set_bit(RXRPC_CALL_EV_PING, &call->events);
 	}
 	send_ack = NULL;
 	if (test_and_clear_bit(RXRPC_CALL_EV_ACK_LOST, &call->events)) {
 		call->acks_lost_top = call->tx_top;
-		rxrpc_propose_ACK(call, RXRPC_ACK_PING, 0, 0, true, false,
+		rxrpc_propose_ACK(call, RXRPC_ACK_PING, 0, true, false,
 				  rxrpc_propose_ack_ping_for_lost_ack);
 		send_ack = &call->acks_lost_ping;
 	}

net/rxrpc/input.c+28−31

  * Ping the other end to fill our RTT cache and to retrieve the rwind
  * and MTU parameters.
  */
-static void rxrpc_send_ping(struct rxrpc_call *call, struct sk_buff *skb,
+static void rxrpc_send_ping(struct rxrpc_call *call, struct sk_buff *skb)
-			    int skew)
 {
 	struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
 	ktime_t now = skb->tstamp;
 	if (call->peer->rtt_usage < 3 ||
 	    ktime_before(ktime_add_ms(call->peer->rtt_last_req, 1000), now))
-		rxrpc_propose_ACK(call, RXRPC_ACK_PING, skew, sp->hdr.serial,
+		rxrpc_propose_ACK(call, RXRPC_ACK_PING, sp->hdr.serial,
 				  true, true,
 				  rxrpc_propose_ack_ping_for_params);
 }
 /*
  * Process a DATA packet, adding the packet to the Rx ring.
  */
-static void rxrpc_input_data(struct rxrpc_call *call, struct sk_buff *skb,
+static void rxrpc_input_data(struct rxrpc_call *call, struct sk_buff *skb)
-			     u16 skew)
 {
 	struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
 	enum rxrpc_call_state state;
 ack:
 	if (ack)
-		rxrpc_propose_ACK(call, ack, skew, ack_serial,
+		rxrpc_propose_ACK(call, ack, ack_serial,
 				  immediate_ack, true,
 				  rxrpc_propose_ack_input_data);
 	else
-		rxrpc_propose_ACK(call, RXRPC_ACK_DELAY, skew, serial,
+		rxrpc_propose_ACK(call, RXRPC_ACK_DELAY, serial,
 				  false, true,
 				  rxrpc_propose_ack_input_data);
  * soft-ACK means that the packet may be discarded and retransmission
  * requested.  A phase is complete when all packets are hard-ACK'd.
  */
-static void rxrpc_input_ack(struct rxrpc_call *call, struct sk_buff *skb,
+static void rxrpc_input_ack(struct rxrpc_call *call, struct sk_buff *skb)
-			    u16 skew)
 {
 	struct rxrpc_ack_summary summary = { 0 };
 	struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
 	if (buf.ack.reason == RXRPC_ACK_PING) {
 		_proto("Rx ACK %%%u PING Request", sp->hdr.serial);
 		rxrpc_propose_ACK(call, RXRPC_ACK_PING_RESPONSE,
-				  skew, sp->hdr.serial, true, true,
+				  sp->hdr.serial, true, true,
 				  rxrpc_propose_ack_respond_to_ping);
 	} else if (sp->hdr.flags & RXRPC_REQUEST_ACK) {
 		rxrpc_propose_ACK(call, RXRPC_ACK_REQUESTED,
-				  skew, sp->hdr.serial, true, true,
+				  sp->hdr.serial, true, true,
 				  rxrpc_propose_ack_respond_to_ack);
 	}
 	    RXRPC_TX_ANNO_LAST &&
 	    summary.nr_acks == call->tx_top - hard_ack &&
 	    rxrpc_is_client_call(call))
-		rxrpc_propose_ACK(call, RXRPC_ACK_PING, skew, sp->hdr.serial,
+		rxrpc_propose_ACK(call, RXRPC_ACK_PING, sp->hdr.serial,
 				  false, true,
 				  rxrpc_propose_ack_ping_for_lost_reply);
  * Process an incoming call packet.
  */
 static void rxrpc_input_call_packet(struct rxrpc_call *call,
-				    struct sk_buff *skb, u16 skew)
+				    struct sk_buff *skb)
 {
 	struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
 	unsigned long timo;
 	switch (sp->hdr.type) {
 	case RXRPC_PACKET_TYPE_DATA:
-		rxrpc_input_data(call, skb, skew);
+		rxrpc_input_data(call, skb);
 		break;
 	case RXRPC_PACKET_TYPE_ACK:
-		rxrpc_input_ack(call, skb, skew);
+		rxrpc_input_ack(call, skb);
 		break;
 	case RXRPC_PACKET_TYPE_BUSY:
 {
 	_enter("%p,%p", local, skb);
-	skb_queue_tail(&local->event_queue, skb);
+	if (rxrpc_get_local_maybe(local)) {
-	rxrpc_queue_local(local);
+		skb_queue_tail(&local->event_queue, skb);
+		rxrpc_queue_local(local);
+	} else {
+		rxrpc_free_skb(skb, rxrpc_skb_rx_freed);
+	}
 }
 /*
 {
 	CHECK_SLAB_OKAY(&local->usage);
-	skb_queue_tail(&local->reject_queue, skb);
+	if (rxrpc_get_local_maybe(local)) {
-	rxrpc_queue_local(local);
+		skb_queue_tail(&local->reject_queue, skb);
+		rxrpc_queue_local(local);
+	} else {
+		rxrpc_free_skb(skb, rxrpc_skb_rx_freed);
+	}
 }
 /*
 	struct rxrpc_peer *peer = NULL;
 	struct rxrpc_sock *rx = NULL;
 	unsigned int channel;
-	int skew = 0;
 	_enter("%p", udp_sk);
 			goto out;
 		}
-		/* Note the serial number skew here */
+		if ((int)sp->hdr.serial - (int)conn->hi_serial > 0)
-		skew = (int)sp->hdr.serial - (int)conn->hi_serial;
+			conn->hi_serial = sp->hdr.serial;
-		if (skew >= 0) {
-			if (skew > 0)
-				conn->hi_serial = sp->hdr.serial;
-		} else {
-			skew = -skew;
-			skew = min(skew, 65535);
-		}
 		/* Call-bound packets are routed by connection channel. */
 		channel = sp->hdr.cid & RXRPC_CHANNELMASK;
 		call = rxrpc_new_incoming_call(local, rx, skb);
 		if (!call)
 			goto reject_packet;
-		rxrpc_send_ping(call, skb, skew);
+		rxrpc_send_ping(call, skb);
 		mutex_unlock(&call->user_mutex);
 	}
-	rxrpc_input_call_packet(call, skb, skew);
+	rxrpc_input_call_packet(call, skb);
 	goto discard;
 discard:

net/rxrpc/local_object.c+64−39

 	local = kzalloc(sizeof(struct rxrpc_local), GFP_KERNEL);
 	if (local) {
 		atomic_set(&local->usage, 1);
+		atomic_set(&local->active_users, 1);
 		local->rxnet = rxnet;
 		INIT_LIST_HEAD(&local->link);
 		INIT_WORK(&local->processor, rxrpc_local_processor);
 		local->debug_id = atomic_inc_return(&rxrpc_debug_id);
 		memcpy(&local->srx, srx, sizeof(*srx));
 		local->srx.srx_service = 0;
-		trace_rxrpc_local(local, rxrpc_local_new, 1, NULL);
+		trace_rxrpc_local(local->debug_id, rxrpc_local_new, 1, NULL);
 	}
 	_leave(" = %p", local);
 		 * bind the transport socket may still fail if we're attempting
 		 * to use a local address that the dying object is still using.
 		 */
-		if (!rxrpc_get_local_maybe(local)) {
+		if (!rxrpc_use_local(local))
-			cursor = cursor->next;
-			list_del_init(&local->link);
 			break;
-		}
 		age = "old";
 		goto found;
 	if (ret < 0)
 		goto sock_error;
-	list_add_tail(&local->link, cursor);
+	if (cursor != &rxnet->local_endpoints)
+		list_replace_init(cursor, &local->link);
+	else
+		list_add_tail(&local->link, cursor);
 	age = "new";
 found:
 	int n;
 	n = atomic_inc_return(&local->usage);
-	trace_rxrpc_local(local, rxrpc_local_got, n, here);
+	trace_rxrpc_local(local->debug_id, rxrpc_local_got, n, here);
 	return local;
 }
 	if (local) {
 		int n = atomic_fetch_add_unless(&local->usage, 1, 0);
 		if (n > 0)
-			trace_rxrpc_local(local, rxrpc_local_got, n + 1, here);
+			trace_rxrpc_local(local->debug_id, rxrpc_local_got,
+					  n + 1, here);
 		else
 			local = NULL;
 	}
 }
 /*
- * Queue a local endpoint.
+ * Queue a local endpoint and pass the caller's reference to the work item.
  */
 void rxrpc_queue_local(struct rxrpc_local *local)
 {
 	const void *here = __builtin_return_address(0);
+	unsigned int debug_id = local->debug_id;
+	int n = atomic_read(&local->usage);
 	if (rxrpc_queue_work(&local->processor))
-		trace_rxrpc_local(local, rxrpc_local_queued,
+		trace_rxrpc_local(debug_id, rxrpc_local_queued, n, here);
-				  atomic_read(&local->usage), here);
+	else
-}
+		rxrpc_put_local(local);
-/*
- * A local endpoint reached its end of life.
- */
-static void __rxrpc_put_local(struct rxrpc_local *local)
-{
-	_enter("%d", local->debug_id);
-	rxrpc_queue_work(&local->processor);
 }
 /*
 	if (local) {
 		n = atomic_dec_return(&local->usage);
-		trace_rxrpc_local(local, rxrpc_local_put, n, here);
+		trace_rxrpc_local(local->debug_id, rxrpc_local_put, n, here);
 		if (n == 0)
-			__rxrpc_put_local(local);
+			call_rcu(&local->rcu, rxrpc_local_rcu);
+	}
+}
+/*
+ * Start using a local endpoint.
+ */
+struct rxrpc_local *rxrpc_use_local(struct rxrpc_local *local)
+{
+	unsigned int au;
+	local = rxrpc_get_local_maybe(local);
+	if (!local)
+		return NULL;
+	au = atomic_fetch_add_unless(&local->active_users, 1, 0);
+	if (au == 0) {
+		rxrpc_put_local(local);
+		return NULL;
+	}
+	return local;
+}
+/*
+ * Cease using a local endpoint.  Once the number of active users reaches 0, we
+ * start the closure of the transport in the work processor.
+ */
+void rxrpc_unuse_local(struct rxrpc_local *local)
+{
+	unsigned int au;
+	if (local) {
+		au = atomic_dec_return(&local->active_users);
+		if (au == 0)
+			rxrpc_queue_local(local);
+		else
+			rxrpc_put_local(local);
 	}
 }
 	_enter("%d", local->debug_id);
-	/* We can get a race between an incoming call packet queueing the
-	 * processor again and the work processor starting the destruction
-	 * process which will shut down the UDP socket.
-	 */
-	if (local->dead) {
-		_leave(" [already dead]");
-		return;
-	}
-	local->dead = true;
 	mutex_lock(&rxnet->local_mutex);
 	list_del_init(&local->link);
 	mutex_unlock(&rxnet->local_mutex);
 	 */
 	rxrpc_purge_queue(&local->reject_queue);
 	rxrpc_purge_queue(&local->event_queue);
-	_debug("rcu local %d", local->debug_id);
-	call_rcu(&local->rcu, rxrpc_local_rcu);
 }
 /*
- * Process events on an endpoint
+ * Process events on an endpoint.  The work item carries a ref which
+ * we must release.
  */
 static void rxrpc_local_processor(struct work_struct *work)
 {
 		container_of(work, struct rxrpc_local, processor);
 	bool again;
-	trace_rxrpc_local(local, rxrpc_local_processing,
+	trace_rxrpc_local(local->debug_id, rxrpc_local_processing,
 			  atomic_read(&local->usage), NULL);
 	do {
 		again = false;
-		if (atomic_read(&local->usage) == 0)
+		if (atomic_read(&local->active_users) == 0) {
-			return rxrpc_local_destroyer(local);
+			rxrpc_local_destroyer(local);
+			break;
+		}
 		if (!skb_queue_empty(&local->reject_queue)) {
 			rxrpc_reject_packets(local);
 			again = true;
 		}
 	} while (again);
+	rxrpc_put_local(local);
 }
 /*

net/rxrpc/output.c+1−2

 	*_top = top;
 	pkt->ack.bufferSpace	= htons(8);
-	pkt->ack.maxSkew	= htons(call->ackr_skew);
+	pkt->ack.maxSkew	= htons(0);
 	pkt->ack.firstPacket	= htonl(hard_ack + 1);
 	pkt->ack.previousPacket	= htonl(call->ackr_prev_seq);
 	pkt->ack.serial		= htonl(serial);
 			if (ping)
 				clear_bit(RXRPC_CALL_PINGING, &call->flags);
 			rxrpc_propose_ACK(call, pkt->ack.reason,
-					  ntohs(pkt->ack.maxSkew),
 					  ntohl(pkt->ack.serial),
 					  false, true,
 					  rxrpc_propose_ack_retry_tx);

net/rxrpc/recvmsg.c+3−3

net/sched/act_skbedit.c+12−0

 	return tcf_idr_search(tn, a, index);
 }
+static size_t tcf_skbedit_get_fill_size(const struct tc_action *act)
+{
+	return nla_total_size(sizeof(struct tc_skbedit))
+		+ nla_total_size(sizeof(u32)) /* TCA_SKBEDIT_PRIORITY */
+		+ nla_total_size(sizeof(u16)) /* TCA_SKBEDIT_QUEUE_MAPPING */
+		+ nla_total_size(sizeof(u32)) /* TCA_SKBEDIT_MARK */
+		+ nla_total_size(sizeof(u16)) /* TCA_SKBEDIT_PTYPE */
+		+ nla_total_size(sizeof(u32)) /* TCA_SKBEDIT_MASK */
+		+ nla_total_size_64bit(sizeof(u64)); /* TCA_SKBEDIT_FLAGS */
+}
 static struct tc_action_ops act_skbedit_ops = {
 	.kind		=	"skbedit",
 	.id		=	TCA_ID_SKBEDIT,
 	.init		=	tcf_skbedit_init,
 	.cleanup	=	tcf_skbedit_cleanup,
 	.walk		=	tcf_skbedit_walker,
+	.get_fill_size	=	tcf_skbedit_get_fill_size,
 	.lookup		=	tcf_skbedit_search,
 	.size		=	sizeof(struct tcf_skbedit),
 };

net/sched/sch_taprio.c+2−1

@@ -1191,7 +1191,8 @@ unlock: · 1190 unmodified lines
1191	spin_unlock_bh(qdisc_lock(sch));	1191	spin_unlock_bh(qdisc_lock(sch));
1192		1192
1193	free_sched:	1193	free_sched:
1194	kfree(new_admin);	1194	if (new_admin)
		1195	call_rcu(&new_admin->rcu, taprio_free_sched_cb);
1195		1196
1196	return err;	1197	return err;
1197	}	1198	}

net/sctp/sm_sideeffect.c+1−1

@@ -546,7 +546,7 @@ static void sctp_do_8_2_transport_strike(struct sctp_cmd_seq *commands, · 545 unmodified lines
546	*/	546	*/
547	if (net->sctp.pf_enable &&	547	if (net->sctp.pf_enable &&
548	(transport->state == SCTP_ACTIVE) &&	548	(transport->state == SCTP_ACTIVE) &&
549	(asoc->pf_retrans < transport->pathmaxrxt) &&	549	(transport->error_count < transport->pathmaxrxt) &&
550	(transport->error_count > asoc->pf_retrans)) {	550	(transport->error_count > asoc->pf_retrans)) {
551		551
552	sctp_assoc_control_transport(asoc, transport,	552	sctp_assoc_control_transport(asoc, transport,

net/sctp/stream.c+1−0

@@ -316,6 +316,7 @@ int sctp_send_reset_streams(struct sctp_association *asoc, · 315 unmodified lines
316	nstr_list[i] = htons(str_list[i]);	316	nstr_list[i] = htons(str_list[i]);
317		317
318	if (out && !sctp_stream_outq_is_empty(stream, str_nums, nstr_list)) {	318	if (out && !sctp_stream_outq_is_empty(stream, str_nums, nstr_list)) {
		319	kfree(nstr_list);
319	retval = -EAGAIN;	320	retval = -EAGAIN;
320	goto out;	321	goto out;
321	}	322	}

net/tipc/addr.c+1−0

@@ -75,6 +75,7 @@ void tipc_set_node_addr(struct net *net, u32 addr) · 74 unmodified lines
75	tipc_set_node_id(net, node_id);	75	tipc_set_node_id(net, node_id);
76	}	76	}
77	tn->trial_addr = addr;	77	tn->trial_addr = addr;
		78	tn->addr_trial_end = jiffies;
78	pr_info("32-bit node address hash set to %x\n", addr);	79	pr_info("32-bit node address hash set to %x\n", addr);
79	}	80	}
80		81

net/tipc/link.c+52−40

@@ -106,8 +106,6 @@ struct tipc_stats { · 105 unmodified lines
106	* @transmitq: queue for sent, non-acked messages	106	* @transmitq: queue for sent, non-acked messages
107	* @backlogq: queue for messages waiting to be sent	107	* @backlogq: queue for messages waiting to be sent
108	* @snt_nxt: next sequence number to use for outbound messages	108	* @snt_nxt: next sequence number to use for outbound messages
109	* @prev_from: sequence number of most previous retransmission request
110	* @stale_limit: time when repeated identical retransmits must force link reset
111	* @ackers: # of peers that needs to ack each packet before it can be released	109	* @ackers: # of peers that needs to ack each packet before it can be released
112	* @acked: # last packet acked by a certain peer. Used for broadcast.	110	* @acked: # last packet acked by a certain peer. Used for broadcast.
113	* @rcv_nxt: next sequence number to expect for inbound messages	111	* @rcv_nxt: next sequence number to expect for inbound messages
@@ -164,9 +162,7 @@ struct tipc_link { · 50 unmodified lines
164	u16 limit;	162	u16 limit;
165	} backlog[5];	163	} backlog[5];
166	u16 snd_nxt;	164	u16 snd_nxt;
167	u16 prev_from;
168	u16 window;	165	u16 window;
169	unsigned long stale_limit;
170		166
171	/* Reception */	167	/* Reception */
172	u16 rcv_nxt;	168	u16 rcv_nxt;
@@ -1063,47 +1059,53 @@ static void tipc_link_advance_backlog(struct tipc_link *l, · 890 unmodified lines
1063	* link_retransmit_failure() - Detect repeated retransmit failures	1059	* link_retransmit_failure() - Detect repeated retransmit failures
1064	* @l: tipc link sender	1060	* @l: tipc link sender
1065	* @r: tipc link receiver (= l in case of unicast)	1061	* @r: tipc link receiver (= l in case of unicast)
1066	* @from: seqno of the 1st packet in retransmit request
1067	* @rc: returned code	1062	* @rc: returned code
1068	*	1063	*
1069	* Return: true if the repeated retransmit failures happens, otherwise	1064	* Return: true if the repeated retransmit failures happens, otherwise
1070	* false	1065	* false
1071	*/	1066	*/
1072	static bool link_retransmit_failure(struct tipc_link l, struct tipc_link r,	1067	static bool link_retransmit_failure(struct tipc_link l, struct tipc_link r,
1073	u16 from, int *rc)	1068	int *rc)
1074	{	1069	{
1075	struct sk_buff *skb = skb_peek(&l->transmq);	1070	struct sk_buff *skb = skb_peek(&l->transmq);
1076	struct tipc_msg *hdr;	1071	struct tipc_msg *hdr;
1077		1072
1078	if (!skb)	1073	if (!skb)
1079	return false;	1074	return false;
1080	hdr = buf_msg(skb);
1081		1075
1082	/* Detect repeated retransmit failures on same packet */	1076	if (!TIPC_SKB_CB(skb)->retr_cnt)
1083	if (r->prev_from != from) {	1077	return false;
1084	r->prev_from = from;
1085	r->stale_limit = jiffies + msecs_to_jiffies(r->tolerance);
1086	} else if (time_after(jiffies, r->stale_limit)) {
1087	pr_warn("Retransmission failure on link <%s>\n", l->name);
1088	link_print(l, "State of link ");
1089	pr_info("Failed msg: usr %u, typ %u, len %u, err %u\n",
1090	msg_user(hdr), msg_type(hdr), msg_size(hdr),
1091	msg_errcode(hdr));
1092	pr_info("sqno %u, prev: %x, src: %x\n",
1093	msg_seqno(hdr), msg_prevnode(hdr), msg_orignode(hdr));
1094
1095	trace_tipc_list_dump(&l->transmq, true, "retrans failure!");
1096	trace_tipc_link_dump(l, TIPC_DUMP_NONE, "retrans failure!");
1097	trace_tipc_link_dump(r, TIPC_DUMP_NONE, "retrans failure!");
1098		1078
1099	if (link_is_bc_sndlink(l))	1079	if (!time_after(jiffies, TIPC_SKB_CB(skb)->retr_stamp +
1100	*rc = TIPC_LINK_DOWN_EVT;	1080	msecs_to_jiffies(r->tolerance)))
		1081	return false;
		1082
		1083	hdr = buf_msg(skb);
		1084	if (link_is_bc_sndlink(l) && !less(r->acked, msg_seqno(hdr)))
		1085	return false;
1101		1086
		1087	pr_warn("Retransmission failure on link <%s>\n", l->name);
		1088	link_print(l, "State of link ");
		1089	pr_info("Failed msg: usr %u, typ %u, len %u, err %u\n",
		1090	msg_user(hdr), msg_type(hdr), msg_size(hdr), msg_errcode(hdr));
		1091	pr_info("sqno %u, prev: %x, dest: %x\n",
		1092	msg_seqno(hdr), msg_prevnode(hdr), msg_destnode(hdr));
		1093	pr_info("retr_stamp %d, retr_cnt %d\n",
		1094	jiffies_to_msecs(TIPC_SKB_CB(skb)->retr_stamp),
		1095	TIPC_SKB_CB(skb)->retr_cnt);
		1096
		1097	trace_tipc_list_dump(&l->transmq, true, "retrans failure!");
		1098	trace_tipc_link_dump(l, TIPC_DUMP_NONE, "retrans failure!");
		1099	trace_tipc_link_dump(r, TIPC_DUMP_NONE, "retrans failure!");
		1100
		1101	if (link_is_bc_sndlink(l)) {
		1102	r->state = LINK_RESET;
		1103	*rc = TIPC_LINK_DOWN_EVT;
		1104	} else {
1102	*rc = tipc_link_fsm_evt(l, LINK_FAILURE_EVT);	1105	*rc = tipc_link_fsm_evt(l, LINK_FAILURE_EVT);
1103	return true;
1104	}	1106	}
1105		1107
1106	return false;	1108	return true;
1107	}	1109	}
1108		1110
1109	/* tipc_link_bc_retrans() - retransmit zero or more packets	1111	/* tipc_link_bc_retrans() - retransmit zero or more packets
@@ -1129,7 +1131,7 @@ static int tipc_link_bc_retrans(struct tipc_link l, struct tipc_link r, · 19 unmodified lines
1129		1131
1130	trace_tipc_link_retrans(r, from, to, &l->transmq);	1132	trace_tipc_link_retrans(r, from, to, &l->transmq);
1131		1133
1132	if (link_retransmit_failure(l, r, from, &rc))	1134	if (link_retransmit_failure(l, r, &rc))
1133	return rc;	1135	return rc;
1134		1136
1135	skb_queue_walk(&l->transmq, skb) {	1137	skb_queue_walk(&l->transmq, skb) {
@@ -1138,11 +1140,10 @@ static int tipc_link_bc_retrans(struct tipc_link l, struct tipc_link r, · 2 unmodified lines
1138	continue;	1140	continue;
1139	if (more(msg_seqno(hdr), to))	1141	if (more(msg_seqno(hdr), to))
1140	break;	1142	break;
1141	if (link_is_bc_sndlink(l)) {	1143
1142	if (time_before(jiffies, TIPC_SKB_CB(skb)->nxt_retr))	1144	if (time_before(jiffies, TIPC_SKB_CB(skb)->nxt_retr))
1143	continue;	1145	continue;
1144	TIPC_SKB_CB(skb)->nxt_retr = TIPC_BC_RETR_LIM;	1146	TIPC_SKB_CB(skb)->nxt_retr = TIPC_BC_RETR_LIM;
1145	}
1146	_skb = __pskb_copy(skb, LL_MAX_HEADER + MIN_H_SIZE, GFP_ATOMIC);	1147	_skb = __pskb_copy(skb, LL_MAX_HEADER + MIN_H_SIZE, GFP_ATOMIC);
1147	if (!_skb)	1148	if (!_skb)
1148	return 0;	1149	return 0;
@@ -1152,6 +1153,10 @@ static int tipc_link_bc_retrans(struct tipc_link l, struct tipc_link r, · 3 unmodified lines
1152	_skb->priority = TC_PRIO_CONTROL;	1153	_skb->priority = TC_PRIO_CONTROL;
1153	__skb_queue_tail(xmitq, _skb);	1154	__skb_queue_tail(xmitq, _skb);
1154	l->stats.retransmitted++;	1155	l->stats.retransmitted++;
		1156
		1157	/* Increase actual retrans counter & mark first time */
		1158	if (!TIPC_SKB_CB(skb)->retr_cnt++)
		1159	TIPC_SKB_CB(skb)->retr_stamp = jiffies;
1155	}	1160	}
1156	return 0;	1161	return 0;
1157	}	1162	}
@@ -1393,12 +1398,10 @@ static int tipc_link_advance_transmq(struct tipc_link *l, u16 acked, u16 gap, · 235 unmodified lines
1393	struct tipc_msg *hdr;	1398	struct tipc_msg *hdr;
1394	u16 bc_ack = l->bc_rcvlink->rcv_nxt - 1;	1399	u16 bc_ack = l->bc_rcvlink->rcv_nxt - 1;
1395	u16 ack = l->rcv_nxt - 1;	1400	u16 ack = l->rcv_nxt - 1;
		1401	bool passed = false;
1396	u16 seqno, n = 0;	1402	u16 seqno, n = 0;
1397	int rc = 0;	1403	int rc = 0;
1398		1404
1399	if (gap && link_retransmit_failure(l, l, acked + 1, &rc))
1400	return rc;
1401
1402	skb_queue_walk_safe(&l->transmq, skb, tmp) {	1405	skb_queue_walk_safe(&l->transmq, skb, tmp) {
1403	seqno = buf_seqno(skb);	1406	seqno = buf_seqno(skb);
1404		1407
@@ -1408,12 +1411,17 @@ next_gap_ack: · 3 unmodified lines
1408	__skb_unlink(skb, &l->transmq);	1411	__skb_unlink(skb, &l->transmq);
1409	kfree_skb(skb);	1412	kfree_skb(skb);
1410	} else if (less_eq(seqno, acked + gap)) {	1413	} else if (less_eq(seqno, acked + gap)) {
1411	/* retransmit skb */	1414	/* First, check if repeated retrans failures occurs? */
		1415	if (!passed && link_retransmit_failure(l, l, &rc))
		1416	return rc;
		1417	passed = true;
		1418
		1419	/* retransmit skb if unrestricted*/
1412	if (time_before(jiffies, TIPC_SKB_CB(skb)->nxt_retr))	1420	if (time_before(jiffies, TIPC_SKB_CB(skb)->nxt_retr))
1413	continue;	1421	continue;
1414	TIPC_SKB_CB(skb)->nxt_retr = TIPC_UC_RETR_TIME;	1422	TIPC_SKB_CB(skb)->nxt_retr = TIPC_UC_RETR_TIME;
1415		1423	_skb = __pskb_copy(skb, LL_MAX_HEADER + MIN_H_SIZE,
1416	_skb = __pskb_copy(skb, MIN_H_SIZE, GFP_ATOMIC);	1424	GFP_ATOMIC);
1417	if (!_skb)	1425	if (!_skb)
1418	continue;	1426	continue;
1419	hdr = buf_msg(_skb);	1427	hdr = buf_msg(_skb);
@@ -1422,6 +1430,10 @@ next_gap_ack: · 2 unmodified lines
1422	_skb->priority = TC_PRIO_CONTROL;	1430	_skb->priority = TC_PRIO_CONTROL;
1423	__skb_queue_tail(xmitq, _skb);	1431	__skb_queue_tail(xmitq, _skb);
1424	l->stats.retransmitted++;	1432	l->stats.retransmitted++;
		1433
		1434	/* Increase actual retrans counter & mark first time */
		1435	if (!TIPC_SKB_CB(skb)->retr_cnt++)
		1436	TIPC_SKB_CB(skb)->retr_stamp = jiffies;
1425	} else {	1437	} else {
1426	/* retry with Gap ACK blocks if any */	1438	/* retry with Gap ACK blocks if any */
1427	if (!ga \|\| n >= ga->gack_cnt)	1439	if (!ga \|\| n >= ga->gack_cnt)
@@ -2681,7 +2693,7 @@ int tipc_link_dump(struct tipc_link l, u16 dqueues, char buf) · 1253 unmodified lines
2681	i += scnprintf(buf + i, sz - i, " %x", l->peer_caps);	2693	i += scnprintf(buf + i, sz - i, " %x", l->peer_caps);
2682	i += scnprintf(buf + i, sz - i, " %u", l->silent_intv_cnt);	2694	i += scnprintf(buf + i, sz - i, " %u", l->silent_intv_cnt);
2683	i += scnprintf(buf + i, sz - i, " %u", l->rst_cnt);	2695	i += scnprintf(buf + i, sz - i, " %u", l->rst_cnt);
2684	i += scnprintf(buf + i, sz - i, " %u", l->prev_from);	2696	i += scnprintf(buf + i, sz - i, " %u", 0);
2685	i += scnprintf(buf + i, sz - i, " %u", 0);	2697	i += scnprintf(buf + i, sz - i, " %u", 0);
2686	i += scnprintf(buf + i, sz - i, " %u", l->acked);	2698	i += scnprintf(buf + i, sz - i, " %u", l->acked);
2687		2699

net/tipc/msg.h+5−3

 #define TIPC_MEDIA_INFO_OFFSET	5
 struct tipc_skb_cb {
-	u32 bytes_read;
-	u32 orig_member;
 	struct sk_buff *tail;
 	unsigned long nxt_retr;
-	bool validated;
+	unsigned long retr_stamp;
+	u32 bytes_read;
+	u32 orig_member;
 	u16 chain_imp;
 	u16 ackers;
+	u16 retr_cnt;
+	bool validated;
 };
 #define TIPC_SKB_CB(__skb) ((struct tipc_skb_cb *)&((__skb)->cb[0]))

net/tls/tls_device.c+7−2

 	struct tls_context *tls_ctx = tls_get_ctx(sk);
 	struct tls_prot_info *prot = &tls_ctx->prot_info;
 	struct tls_offload_context_tx *ctx = tls_offload_ctx_tx(tls_ctx);
-	int tls_push_record_flags = flags | MSG_SENDPAGE_NOTLAST;
 	int more = flags & (MSG_SENDPAGE_NOTLAST | MSG_MORE);
 	struct tls_record_info *record = ctx->open_record;
+	int tls_push_record_flags;
 	struct page_frag *pfrag;
 	size_t orig_size = size;
 	u32 max_open_record_len;
 	if (sk->sk_err)
 		return -sk->sk_err;
+	flags |= MSG_SENDPAGE_DECRYPTED;
+	tls_push_record_flags = flags | MSG_SENDPAGE_NOTLAST;
 	timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT);
 	if (tls_is_partially_sent_record(tls_ctx)) {
 		rc = tls_push_partial_record(sk, tls_ctx, flags);
 		gfp_t sk_allocation = sk->sk_allocation;
 		sk->sk_allocation = GFP_ATOMIC;
-		tls_push_partial_record(sk, ctx, MSG_DONTWAIT | MSG_NOSIGNAL);
+		tls_push_partial_record(sk, ctx,
+					MSG_DONTWAIT | MSG_NOSIGNAL |
+					MSG_SENDPAGE_DECRYPTED);
 		sk->sk_allocation = sk_allocation;
 	}
 }

net/tls/tls_main.c+2−0

 	if (free_ctx)
 		icsk->icsk_ulp_data = NULL;
 	sk->sk_prot = ctx->sk_proto;
+	if (sk->sk_write_space == tls_write_space)
+		sk->sk_write_space = ctx->sk_write_space;
 	write_unlock_bh(&sk->sk_callback_lock);
 	release_sock(sk);
 	if (ctx->tx_conf == TLS_SW)

samples/auxdisplay/cfag12864b-example.c+1−1

@@ -245,7 +245,7 @@ int main(int argc, char *argv[]) · 244 unmodified lines
245		245
246	if (argc != 2) {	246	if (argc != 2) {
247	printf(	247	printf(
248	"Sintax: %s fbdev\n"	248	"Syntax: %s fbdev\n"
249	"Usually: /dev/fb0, /dev/fb1...\n", argv[0]);	249	"Usually: /dev/fb0, /dev/fb1...\n", argv[0]);
250	return -1;	250	return -1;
251	}	251	}

scripts/Makefile.build+10−1

 $(warning kbuild: Makefile.build is included improperly)
 endif
+ifeq ($(MAKECMDGOALS)$(need-modorder),)
+ifneq ($(obj-m),)
+$(warning $(patsubst %.o,'%.ko',$(obj-m)) will not be built even though obj-m is specified.)
+$(warning You cannot use subdir-y/m to visit a module Makefile. Use obj-y/m instead.)
+endif
+endif
 # ===========================================================================
 ifneq ($(strip $(lib-y) $(lib-m) $(lib-)),)
 PHONY += $(subdir-ym)
 $(subdir-ym):
-	$(Q)$(MAKE) $(build)=$@ need-builtin=$(if $(findstring $@,$(subdir-obj-y)),1)
+	$(Q)$(MAKE) $(build)=$@ \
+	need-builtin=$(if $(filter $@/built-in.a, $(subdir-obj-y)),1) \
+	need-modorder=$(if $(need-modorder),$(if $(filter $@/modules.order, $(modorder)),1))
 # Add FORCE to the prequisites of a target to force it to be always rebuilt.
 # ---------------------------------------------------------------------------

scripts/Makefile.modpost+2−4

 include scripts/Makefile.lib
-modorder := $(if $(KBUILD_EXTMOD),$(KBUILD_EXTMOD)/)modules.order
 # find all modules listed in modules.order
-modules := $(sort $(shell cat $(modorder)))
+modules := $(sort $(shell cat $(MODORDER)))
 # Stop after building .o files if NOFINAL is set. Makes compile tests quicker
 __modpost: $(if $(KBUILD_MODPOST_NOFINAL), $(modules:.ko:.o),$(modules))
 # We can go over command line length here, so be careful.
 quiet_cmd_modpost = MODPOST $(words $(modules)) modules
-      cmd_modpost = sed 's/ko$$/o/' $(modorder) | $(MODPOST)
+      cmd_modpost = sed 's/ko$$/o/' $(MODORDER) | $(MODPOST)
 PHONY += modules-modpost
 modules-modpost:

scripts/coccinelle/api/atomic_as_refcounter.cocci+1−0

@@ -1,3 +1,4 @@
		1	// SPDX-License-Identifier: GPL-2.0-only
1	// Check if refcount_t type and API should be used	2	// Check if refcount_t type and API should be used
2	// instead of atomic_t type when dealing with refcounters	3	// instead of atomic_t type when dealing with refcounters
3	//	4	//

security/keys/trusted.c+0−13

@@ -1228,24 +1228,11 @@ hashalg_fail: · 1227 unmodified lines
1228		1228
1229	static int __init init_digests(void)	1229	static int __init init_digests(void)
1230	{	1230	{
1231	u8 digest[TPM_MAX_DIGEST_SIZE];
1232	int ret;
1233	int i;
1234
1235	ret = tpm_get_random(chip, digest, TPM_MAX_DIGEST_SIZE);
1236	if (ret < 0)
1237	return ret;
1238	if (ret < TPM_MAX_DIGEST_SIZE)
1239	return -EFAULT;
1240
1241	digests = kcalloc(chip->nr_allocated_banks, sizeof(*digests),	1231	digests = kcalloc(chip->nr_allocated_banks, sizeof(*digests),
1242	GFP_KERNEL);	1232	GFP_KERNEL);
1243	if (!digests)	1233	if (!digests)
1244	return -ENOMEM;	1234	return -ENOMEM;
1245		1235
1246	for (i = 0; i < chip->nr_allocated_banks; i++)
1247	memcpy(digests[i].digest, digest, TPM_MAX_DIGEST_SIZE);
1248
1249	return 0;	1236	return 0;
1250	}	1237	}
1251		1238

sound/firewire/packets-buffer.c+1−1

@@ -37,7 +37,7 @@ int iso_packets_buffer_init(struct iso_packets_buffer b, struct fw_unit unit, · 36 unmodified lines
37	packets_per_page = PAGE_SIZE / packet_size;	37	packets_per_page = PAGE_SIZE / packet_size;
38	if (WARN_ON(!packets_per_page)) {	38	if (WARN_ON(!packets_per_page)) {
39	err = -EINVAL;	39	err = -EINVAL;
40	goto error;	40	goto err_packets;
41	}	41	}
42	pages = DIV_ROUND_UP(count, packets_per_page);	42	pages = DIV_ROUND_UP(count, packets_per_page);
43		43

sound/pci/hda/hda_controller.c+9−4

 	}
 	runtime->private_data = azx_dev;
-	if (chip->gts_present)
-		azx_pcm_hw.info = azx_pcm_hw.info |
-			SNDRV_PCM_INFO_HAS_LINK_SYNCHRONIZED_ATIME;
 	runtime->hw = azx_pcm_hw;
+	if (chip->gts_present)
+		runtime->hw.info |= SNDRV_PCM_INFO_HAS_LINK_SYNCHRONIZED_ATIME;
 	runtime->hw.channels_min = hinfo->channels_min;
 	runtime->hw.channels_max = hinfo->channels_max;
 	runtime->hw.formats = hinfo->formats;
 				     20,
 				     178000000);
+	/* by some reason, the playback stream stalls on PulseAudio with
+	 * tsched=1 when a capture stream triggers.  Until we figure out the
+	 * real cause, disable tsched mode by telling the PCM info flag.
+	 */
+	if (chip->driver_caps & AZX_DCAPS_AMD_WORKAROUND)
+		runtime->hw.info |= SNDRV_PCM_INFO_BATCH;
 	if (chip->align_buffer_size)
 		/* constrain buffer sizes to be multiple of 128
 		   bytes. This is more efficient in terms of memory

sound/pci/hda/hda_controller.h+1−1

@@ -31,7 +31,7 @@ · 30 unmodified lines
31	/* 14 unused */	31	/* 14 unused */
32	#define AZX_DCAPS_CTX_WORKAROUND (1 << 15) /* X-Fi workaround */	32	#define AZX_DCAPS_CTX_WORKAROUND (1 << 15) /* X-Fi workaround */
33	#define AZX_DCAPS_POSFIX_LPIB (1 << 16) /* Use LPIB as default */	33	#define AZX_DCAPS_POSFIX_LPIB (1 << 16) /* Use LPIB as default */
34	/* 17 unused */	34	#define AZX_DCAPS_AMD_WORKAROUND (1 << 17) /* AMD-specific workaround */
35	#define AZX_DCAPS_NO_64BIT (1 << 18) /* No 64bit address */	35	#define AZX_DCAPS_NO_64BIT (1 << 18) /* No 64bit address */
36	#define AZX_DCAPS_SYNC_WRITE (1 << 19) /* sync each cmd write */	36	#define AZX_DCAPS_SYNC_WRITE (1 << 19) /* sync each cmd write */
37	#define AZX_DCAPS_OLD_SSYNC (1 << 20) /* Old SSYNC reg for ICH */	37	#define AZX_DCAPS_OLD_SSYNC (1 << 20) /* Old SSYNC reg for ICH */

sound/pci/hda/hda_generic.c+20−1

 }
 EXPORT_SYMBOL_GPL(snd_hda_gen_free);
+/**
+ * snd_hda_gen_reboot_notify - Make codec enter D3 before rebooting
+ * @codec: the HDA codec
+ *
+ * This can be put as patch_ops reboot_notify function.
+ */
+void snd_hda_gen_reboot_notify(struct hda_codec *codec)
+{
+	/* Make the codec enter D3 to avoid spurious noises from the internal
+	 * speaker during (and after) reboot
+	 */
+	snd_hda_codec_set_power_to_all(codec, codec->core.afg, AC_PWRST_D3);
+	snd_hda_codec_write(codec, codec->core.afg, 0,
+			    AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
+	msleep(10);
+}
+EXPORT_SYMBOL_GPL(snd_hda_gen_reboot_notify);
 #ifdef CONFIG_PM
 /**
  * snd_hda_gen_check_power_status - check the loopback power save state
 	.init = snd_hda_gen_init,
 	.free = snd_hda_gen_free,
 	.unsol_event = snd_hda_jack_unsol_event,
+	.reboot_notify = snd_hda_gen_reboot_notify,
 #ifdef CONFIG_PM
 	.check_power_status = snd_hda_gen_check_power_status,
 #endif
 	err = snd_hda_parse_pin_defcfg(codec, &spec->autocfg, NULL, 0);
 	if (err < 0)
-		return err;
+		goto error;
 	err = snd_hda_gen_parse_auto_config(codec, &spec->autocfg);
 	if (err < 0)

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

@@ -332,6 +332,7 @@ int snd_hda_gen_parse_auto_config(struct hda_codec *codec, · 331 unmodified lines
332	struct auto_pin_cfg *cfg);	332	struct auto_pin_cfg *cfg);
333	int snd_hda_gen_build_controls(struct hda_codec *codec);	333	int snd_hda_gen_build_controls(struct hda_codec *codec);
334	int snd_hda_gen_build_pcms(struct hda_codec *codec);	334	int snd_hda_gen_build_pcms(struct hda_codec *codec);
		335	void snd_hda_gen_reboot_notify(struct hda_codec *codec);
335		336
336	/* standard jack event callbacks */	337	/* standard jack event callbacks */
337	void snd_hda_gen_hp_automute(struct hda_codec *codec,	338	void snd_hda_gen_hp_automute(struct hda_codec *codec,

sound/pci/hda/hda_intel.c+65−1

@@ -64,6 +64,7 @@ enum { · 63 unmodified lines
64	POS_FIX_VIACOMBO,	64	POS_FIX_VIACOMBO,
65	POS_FIX_COMBO,	65	POS_FIX_COMBO,
66	POS_FIX_SKL,	66	POS_FIX_SKL,
		67	POS_FIX_FIFO,
67	};	68	};
68		69
69	/* Defines for ATI HD Audio support in SB450 south bridge */	70	/* Defines for ATI HD Audio support in SB450 south bridge */
@@ -135,7 +136,7 @@ module_param_array(model, charp, NULL, 0444); · 65 unmodified lines
135	MODULE_PARM_DESC(model, "Use the given board model.");	136	MODULE_PARM_DESC(model, "Use the given board model.");
136	module_param_array(position_fix, int, NULL, 0444);	137	module_param_array(position_fix, int, NULL, 0444);
137	MODULE_PARM_DESC(position_fix, "DMA pointer read method."	138	MODULE_PARM_DESC(position_fix, "DMA pointer read method."
138	"(-1 = system default, 0 = auto, 1 = LPIB, 2 = POSBUF, 3 = VIACOMBO, 4 = COMBO, 5 = SKL+).");	139	"(-1 = system default, 0 = auto, 1 = LPIB, 2 = POSBUF, 3 = VIACOMBO, 4 = COMBO, 5 = SKL+, 6 = FIFO).");
139	module_param_array(bdl_pos_adj, int, NULL, 0644);	140	module_param_array(bdl_pos_adj, int, NULL, 0644);
140	MODULE_PARM_DESC(bdl_pos_adj, "BDL position adjustment offset.");	141	MODULE_PARM_DESC(bdl_pos_adj, "BDL position adjustment offset.");
141	module_param_array(probe_mask, int, NULL, 0444);	142	module_param_array(probe_mask, int, NULL, 0444);
@@ -332,6 +333,11 @@ enum { · 190 unmodified lines
332	#define AZX_DCAPS_PRESET_ATI_HDMI_NS \	333	#define AZX_DCAPS_PRESET_ATI_HDMI_NS \
333	(AZX_DCAPS_PRESET_ATI_HDMI \| AZX_DCAPS_SNOOP_OFF)	334	(AZX_DCAPS_PRESET_ATI_HDMI \| AZX_DCAPS_SNOOP_OFF)
334		335
		336	/* quirks for AMD SB */
		337	#define AZX_DCAPS_PRESET_AMD_SB \
		338	(AZX_DCAPS_NO_TCSEL \| AZX_DCAPS_SYNC_WRITE \| AZX_DCAPS_AMD_WORKAROUND \|\
		339	AZX_DCAPS_SNOOP_TYPE(ATI) \| AZX_DCAPS_PM_RUNTIME)
		340
335	/* quirks for Nvidia */	341	/* quirks for Nvidia */
336	#define AZX_DCAPS_PRESET_NVIDIA \	342	#define AZX_DCAPS_PRESET_NVIDIA \
337	(AZX_DCAPS_NO_MSI \| AZX_DCAPS_CORBRP_SELF_CLEAR \|\	343	(AZX_DCAPS_NO_MSI \| AZX_DCAPS_CORBRP_SELF_CLEAR \|\
@@ -841,6 +847,49 @@ static unsigned int azx_via_get_position(struct azx *chip, · 503 unmodified lines
841	return bound_pos + mod_dma_pos;	847	return bound_pos + mod_dma_pos;
842	}	848	}
843		849
		850	#define AMD_FIFO_SIZE 32
		851
		852	/* get the current DMA position with FIFO size correction */
		853	static unsigned int azx_get_pos_fifo(struct azx chip, struct azx_dev azx_dev)
		854	{
		855	struct snd_pcm_substream *substream = azx_dev->core.substream;
		856	struct snd_pcm_runtime *runtime = substream->runtime;
		857	unsigned int pos, delay;
		858
		859	pos = snd_hdac_stream_get_pos_lpib(azx_stream(azx_dev));
		860	if (!runtime)
		861	return pos;
		862
		863	runtime->delay = AMD_FIFO_SIZE;
		864	delay = frames_to_bytes(runtime, AMD_FIFO_SIZE);
		865	if (azx_dev->insufficient) {
		866	if (pos < delay) {
		867	delay = pos;
		868	runtime->delay = bytes_to_frames(runtime, pos);
		869	} else {
		870	azx_dev->insufficient = 0;
		871	}
		872	}
		873
		874	/* correct the DMA position for capture stream */
		875	if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
		876	if (pos < delay)
		877	pos += azx_dev->core.bufsize;
		878	pos -= delay;
		879	}
		880
		881	return pos;
		882	}
		883
		884	static int azx_get_delay_from_fifo(struct azx chip, struct azx_dev azx_dev,
		885	unsigned int pos)
		886	{
		887	struct snd_pcm_substream *substream = azx_dev->core.substream;
		888
		889	/* just read back the calculated value in the above */
		890	return substream->runtime->delay;
		891	}
		892
844	static unsigned int azx_skl_get_dpib_pos(struct azx *chip,	893	static unsigned int azx_skl_get_dpib_pos(struct azx *chip,
845	struct azx_dev *azx_dev)	894	struct azx_dev *azx_dev)
846	{	895	{
@@ -1417,6 +1466,7 @@ static int check_position_fix(struct azx *chip, int fix) · 570 unmodified lines
1417	case POS_FIX_VIACOMBO:	1466	case POS_FIX_VIACOMBO:
1418	case POS_FIX_COMBO:	1467	case POS_FIX_COMBO:
1419	case POS_FIX_SKL:	1468	case POS_FIX_SKL:
		1469	case POS_FIX_FIFO:
1420	return fix;	1470	return fix;
1421	}	1471	}
1422		1472
@@ -1433,6 +1483,10 @@ static int check_position_fix(struct azx *chip, int fix) · 10 unmodified lines
1433	dev_dbg(chip->card->dev, "Using VIACOMBO position fix\n");	1483	dev_dbg(chip->card->dev, "Using VIACOMBO position fix\n");
1434	return POS_FIX_VIACOMBO;	1484	return POS_FIX_VIACOMBO;
1435	}	1485	}
		1486	if (chip->driver_caps & AZX_DCAPS_AMD_WORKAROUND) {
		1487	dev_dbg(chip->card->dev, "Using FIFO position fix\n");
		1488	return POS_FIX_FIFO;
		1489	}
1436	if (chip->driver_caps & AZX_DCAPS_POSFIX_LPIB) {	1490	if (chip->driver_caps & AZX_DCAPS_POSFIX_LPIB) {
1437	dev_dbg(chip->card->dev, "Using LPIB position fix\n");	1491	dev_dbg(chip->card->dev, "Using LPIB position fix\n");
1438	return POS_FIX_LPIB;	1492	return POS_FIX_LPIB;
@@ -1453,6 +1507,7 @@ static void assign_position_fix(struct azx *chip, int fix) · 14 unmodified lines
1453	[POS_FIX_VIACOMBO] = azx_via_get_position,	1507	[POS_FIX_VIACOMBO] = azx_via_get_position,
1454	[POS_FIX_COMBO] = azx_get_pos_lpib,	1508	[POS_FIX_COMBO] = azx_get_pos_lpib,
1455	[POS_FIX_SKL] = azx_get_pos_skl,	1509	[POS_FIX_SKL] = azx_get_pos_skl,
		1510	[POS_FIX_FIFO] = azx_get_pos_fifo,
1456	};	1511	};
1457		1512
1458	chip->get_position[0] = chip->get_position[1] = callbacks[fix];	1513	chip->get_position[0] = chip->get_position[1] = callbacks[fix];
@@ -1467,6 +1522,9 @@ static void assign_position_fix(struct azx *chip, int fix) · 8 unmodified lines
1467	azx_get_delay_from_lpib;	1522	azx_get_delay_from_lpib;
1468	}	1523	}
1469		1524
		1525	if (fix == POS_FIX_FIFO)
		1526	chip->get_delay[0] = chip->get_delay[1] =
		1527	azx_get_delay_from_fifo;
1470	}	1528	}
1471		1529
1472	/*	1530	/*
@@ -2447,6 +2505,12 @@ static const struct pci_device_id azx_ids[] = { · 974 unmodified lines
2447	/* AMD Hudson */	2505	/* AMD Hudson */
2448	{ PCI_DEVICE(0x1022, 0x780d),	2506	{ PCI_DEVICE(0x1022, 0x780d),
2449	.driver_data = AZX_DRIVER_GENERIC \| AZX_DCAPS_PRESET_ATI_SB },	2507	.driver_data = AZX_DRIVER_GENERIC \| AZX_DCAPS_PRESET_ATI_SB },
		2508	/* AMD, X370 & co */
		2509	{ PCI_DEVICE(0x1022, 0x1457),
		2510	.driver_data = AZX_DRIVER_GENERIC \| AZX_DCAPS_PRESET_AMD_SB },
		2511	/* AMD, X570 & co */
		2512	{ PCI_DEVICE(0x1022, 0x1487),
		2513	.driver_data = AZX_DRIVER_GENERIC \| AZX_DCAPS_PRESET_AMD_SB },
2450	/* AMD Stoney */	2514	/* AMD Stoney */
2451	{ PCI_DEVICE(0x1022, 0x157a),	2515	{ PCI_DEVICE(0x1022, 0x157a),
2452	.driver_data = AZX_DRIVER_GENERIC \| AZX_DCAPS_PRESET_ATI_SB \|	2516	.driver_data = AZX_DRIVER_GENERIC \| AZX_DCAPS_PRESET_ATI_SB \|

sound/pci/hda/patch_conexant.c+1−14

@@ -163,23 +163,10 @@ static void cx_auto_reboot_notify(struct hda_codec *codec) · 162 unmodified lines
163	{	163	{
164	struct conexant_spec *spec = codec->spec;	164	struct conexant_spec *spec = codec->spec;
165		165
166	switch (codec->core.vendor_id) {
167	case 0x14f12008: /* CX8200 */
168	case 0x14f150f2: /* CX20722 */
169	case 0x14f150f4: /* CX20724 */
170	break;
171	default:
172	return;
173	}
174
175	/* Turn the problematic codec into D3 to avoid spurious noises	166	/* Turn the problematic codec into D3 to avoid spurious noises
176	from the internal speaker during (and after) reboot */	167	from the internal speaker during (and after) reboot */
177	cx_auto_turn_eapd(codec, spec->num_eapds, spec->eapds, false);	168	cx_auto_turn_eapd(codec, spec->num_eapds, spec->eapds, false);
178		169	snd_hda_gen_reboot_notify(codec);
179	snd_hda_codec_set_power_to_all(codec, codec->core.afg, AC_PWRST_D3);
180	snd_hda_codec_write(codec, codec->core.afg, 0,
181	AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
182	msleep(10);
183	}	170	}
184		171
185	static void cx_auto_free(struct hda_codec *codec)	172	static void cx_auto_free(struct hda_codec *codec)

sound/pci/hda/patch_realtek.c+2−10

 		alc_shutup(codec);
 }
-/* power down codec to D3 at reboot/shutdown; set as reboot_notify ops */
-static void alc_d3_at_reboot(struct hda_codec *codec)
-{
-	snd_hda_codec_set_power_to_all(codec, codec->core.afg, AC_PWRST_D3);
-	snd_hda_codec_write(codec, codec->core.afg, 0,
-			    AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
-	msleep(10);
-}
 #define alc_free	snd_hda_gen_free
 #ifdef CONFIG_PM
 	struct alc_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
-		spec->reboot_notify = alc_d3_at_reboot; /* reduce noise */
+		spec->reboot_notify = snd_hda_gen_reboot_notify; /* reduce noise */
 		spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
 		codec->power_save_node = 0; /* avoid click noises */
 		snd_hda_apply_pincfgs(codec, pincfgs);
 	SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
+	SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
 	SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
 	SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
 	SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),

sound/soc/amd/raven/acp3x-pcm-dma.c+9−11

 	u16 num_pages;
 	u16 channels;
 	u32 xfer_resolution;
-	struct page *pg;
 	u64 bytescount;
+	dma_addr_t dma_addr;
 	void __iomem *acp3x_base;
 };
 static void config_acp3x_dma(struct i2s_stream_instance *rtd, int direction)
 {
 	u16 page_idx;
-	u64 addr;
 	u32 low, high, val, acp_fifo_addr;
-	struct page *pg = rtd->pg;
+	dma_addr_t addr = rtd->dma_addr;
 	/* 8 scratch registers used to map one 64 bit address */
 	if (direction == SNDRV_PCM_STREAM_PLAYBACK)
 	for (page_idx = 0; page_idx < rtd->num_pages; page_idx++) {
 		/* Load the low address of page int ACP SRAM through SRBM */
-		addr = page_to_phys(pg);
 		low = lower_32_bits(addr);
 		high = upper_32_bits(addr);
 				+ 4);
 		/* Move to next physically contiguos page */
 		val += 8;
-		pg++;
+		addr += PAGE_SIZE;
 	}
 	if (direction == SNDRV_PCM_STREAM_PLAYBACK) {
 {
 	int status;
 	u64 size;
-	struct page *pg;
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	struct i2s_stream_instance *rtd = runtime->private_data;
 		return status;
 	memset(substream->runtime->dma_area, 0, params_buffer_bytes(params));
-	pg = virt_to_page(substream->dma_buffer.area);
+	if (substream->dma_buffer.area) {
-	if (pg) {
+		rtd->dma_addr = substream->dma_buffer.addr;
-		rtd->pg = pg;
 		rtd->num_pages = (PAGE_ALIGN(size) >> PAGE_SHIFT);
 		config_acp3x_dma(rtd, substream->stream);
 		status = 0;
 static int acp3x_dma_new(struct snd_soc_pcm_runtime *rtd)
 {
+	struct snd_soc_component *component = snd_soc_rtdcom_lookup(rtd,
+								    DRV_NAME);
+	struct device *parent = component->dev->parent;
 	snd_pcm_lib_preallocate_pages_for_all(rtd->pcm, SNDRV_DMA_TYPE_DEV,
-					      rtd->pcm->card->dev,
+					      parent, MIN_BUFFER, MAX_BUFFER);
-					      MIN_BUFFER, MAX_BUFFER);
 	return 0;
 }

sound/soc/codecs/cs42xx8.c+97−19

@@ -47,6 +47,7 @@ struct cs42xx8_priv { · 46 unmodified lines
47	unsigned long sysclk;	47	unsigned long sysclk;
48	u32 tx_channels;	48	u32 tx_channels;
49	struct gpio_desc *gpiod_reset;	49	struct gpio_desc *gpiod_reset;
		50	u32 rate[2];
50	};	51	};
51		52
52	/* -127.5dB to 0dB with step of 0.5dB */	53	/* -127.5dB to 0dB with step of 0.5dB */
@@ -176,21 +177,27 @@ static const struct snd_soc_dapm_route cs42xx8_adc3_dapm_routes[] = { · 123 unmodified lines
176	};	177	};
177		178
178	struct cs42xx8_ratios {	179	struct cs42xx8_ratios {
179	unsigned int ratio;	180	unsigned int mfreq;
180	unsigned char speed;	181	unsigned int min_mclk;
181	unsigned char mclk;	182	unsigned int max_mclk;
		183	unsigned int ratio[3];
182	};	184	};
183		185
		186	/*
		187	* According to reference mannual, define the cs42xx8_ratio struct
		188	* MFreq2 \| MFreq1 \| MFreq0 \| Description \| SSM \| DSM \| QSM \|
		189	* 0 \| 0 \| 0 \|1.029MHz to 12.8MHz \| 256 \| 128 \| 64 \|
		190	* 0 \| 0 \| 1 \|1.536MHz to 19.2MHz \| 384 \| 192 \| 96 \|
		191	* 0 \| 1 \| 0 \|2.048MHz to 25.6MHz \| 512 \| 256 \| 128 \|
		192	* 0 \| 1 \| 1 \|3.072MHz to 38.4MHz \| 768 \| 384 \| 192 \|
		193	* 1 \| x \| x \|4.096MHz to 51.2MHz \|1024 \| 512 \| 256 \|
		194	*/
184	static const struct cs42xx8_ratios cs42xx8_ratios[] = {	195	static const struct cs42xx8_ratios cs42xx8_ratios[] = {
185	{ 64, CS42XX8_FM_QUAD, CS42XX8_FUNCMOD_MFREQ_256(4) },	196	{ 0, 1029000, 12800000, {256, 128, 64} },
186	{ 96, CS42XX8_FM_QUAD, CS42XX8_FUNCMOD_MFREQ_384(4) },	197	{ 2, 1536000, 19200000, {384, 192, 96} },
187	{ 128, CS42XX8_FM_QUAD, CS42XX8_FUNCMOD_MFREQ_512(4) },	198	{ 4, 2048000, 25600000, {512, 256, 128} },
188	{ 192, CS42XX8_FM_QUAD, CS42XX8_FUNCMOD_MFREQ_768(4) },	199	{ 6, 3072000, 38400000, {768, 384, 192} },
189	{ 256, CS42XX8_FM_SINGLE, CS42XX8_FUNCMOD_MFREQ_256(1) },	200	{ 8, 4096000, 51200000, {1024, 512, 256} },
190	{ 384, CS42XX8_FM_SINGLE, CS42XX8_FUNCMOD_MFREQ_384(1) },
191	{ 512, CS42XX8_FM_SINGLE, CS42XX8_FUNCMOD_MFREQ_512(1) },
192	{ 768, CS42XX8_FM_SINGLE, CS42XX8_FUNCMOD_MFREQ_768(1) },
193	{ 1024, CS42XX8_FM_SINGLE, CS42XX8_FUNCMOD_MFREQ_1024(1) }
194	};	201	};
195		202
196	static int cs42xx8_set_dai_sysclk(struct snd_soc_dai *codec_dai,	203	static int cs42xx8_set_dai_sysclk(struct snd_soc_dai *codec_dai,
@@ -257,14 +264,68 @@ static int cs42xx8_hw_params(struct snd_pcm_substream *substream, · 60 unmodified lines
257	struct snd_soc_component *component = dai->component;	264	struct snd_soc_component *component = dai->component;
258	struct cs42xx8_priv *cs42xx8 = snd_soc_component_get_drvdata(component);	265	struct cs42xx8_priv *cs42xx8 = snd_soc_component_get_drvdata(component);
259	bool tx = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;	266	bool tx = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
260	u32 ratio = cs42xx8->sysclk / params_rate(params);	267	u32 ratio[2];
261	u32 i, fm, val, mask;	268	u32 rate[2];
		269	u32 fm[2];
		270	u32 i, val, mask;
		271	bool condition1, condition2;
262		272
263	if (tx)	273	if (tx)
264	cs42xx8->tx_channels = params_channels(params);	274	cs42xx8->tx_channels = params_channels(params);
265		275
		276	rate[tx] = params_rate(params);
		277	rate[!tx] = cs42xx8->rate[!tx];
		278
		279	ratio[tx] = rate[tx] > 0 ? cs42xx8->sysclk / rate[tx] : 0;
		280	ratio[!tx] = rate[!tx] > 0 ? cs42xx8->sysclk / rate[!tx] : 0;
		281
		282	/* Get functional mode for tx and rx according to rate */
		283	for (i = 0; i < 2; i++) {
		284	if (cs42xx8->slave_mode) {
		285	fm[i] = CS42XX8_FM_AUTO;
		286	} else {
		287	if (rate[i] < 50000) {
		288	fm[i] = CS42XX8_FM_SINGLE;
		289	} else if (rate[i] > 50000 && rate[i] < 100000) {
		290	fm[i] = CS42XX8_FM_DOUBLE;
		291	} else if (rate[i] > 100000 && rate[i] < 200000) {
		292	fm[i] = CS42XX8_FM_QUAD;
		293	} else {
		294	dev_err(component->dev,
		295	"unsupported sample rate\n");
		296	return -EINVAL;
		297	}
		298	}
		299	}
		300
266	for (i = 0; i < ARRAY_SIZE(cs42xx8_ratios); i++) {	301	for (i = 0; i < ARRAY_SIZE(cs42xx8_ratios); i++) {
267	if (cs42xx8_ratios[i].ratio == ratio)	302	/* Is the ratio[tx] valid ? */
		303	condition1 = ((fm[tx] == CS42XX8_FM_AUTO) ?
		304	(cs42xx8_ratios[i].ratio[0] == ratio[tx] \|\|
		305	cs42xx8_ratios[i].ratio[1] == ratio[tx] \|\|
		306	cs42xx8_ratios[i].ratio[2] == ratio[tx]) :
		307	(cs42xx8_ratios[i].ratio[fm[tx]] == ratio[tx])) &&
		308	cs42xx8->sysclk >= cs42xx8_ratios[i].min_mclk &&
		309	cs42xx8->sysclk <= cs42xx8_ratios[i].max_mclk;
		310
		311	if (!ratio[tx])
		312	condition1 = true;
		313
		314	/* Is the ratio[!tx] valid ? */
		315	condition2 = ((fm[!tx] == CS42XX8_FM_AUTO) ?
		316	(cs42xx8_ratios[i].ratio[0] == ratio[!tx] \|\|
		317	cs42xx8_ratios[i].ratio[1] == ratio[!tx] \|\|
		318	cs42xx8_ratios[i].ratio[2] == ratio[!tx]) :
		319	(cs42xx8_ratios[i].ratio[fm[!tx]] == ratio[!tx]));
		320
		321	if (!ratio[!tx])
		322	condition2 = true;
		323
		324	/*
		325	* Both ratio[tx] and ratio[!tx] is valid, then we get
		326	* a proper MFreq.
		327	*/
		328	if (condition1 && condition2)
268	break;	329	break;
269	}	330	}
270		331
@@ -273,15 +334,31 @@ static int cs42xx8_hw_params(struct snd_pcm_substream *substream, · 2 unmodified lines
273	return -EINVAL;	334	return -EINVAL;
274	}	335	}
275		336
276	mask = CS42XX8_FUNCMOD_MFREQ_MASK;	337	cs42xx8->rate[tx] = params_rate(params);
277	val = cs42xx8_ratios[i].mclk;
278		338
279	fm = cs42xx8->slave_mode ? CS42XX8_FM_AUTO : cs42xx8_ratios[i].speed;	339	mask = CS42XX8_FUNCMOD_MFREQ_MASK;
		340	val = cs42xx8_ratios[i].mfreq;
280		341
281	regmap_update_bits(cs42xx8->regmap, CS42XX8_FUNCMOD,	342	regmap_update_bits(cs42xx8->regmap, CS42XX8_FUNCMOD,
282	CS42XX8_FUNCMOD_xC_FM_MASK(tx) \| mask,	343	CS42XX8_FUNCMOD_xC_FM_MASK(tx) \| mask,
283	CS42XX8_FUNCMOD_xC_FM(tx, fm) \| val);	344	CS42XX8_FUNCMOD_xC_FM(tx, fm[tx]) \| val);
		345
		346	return 0;
		347	}
		348
		349	static int cs42xx8_hw_free(struct snd_pcm_substream *substream,
		350	struct snd_soc_dai *dai)
		351	{
		352	struct snd_soc_component *component = dai->component;
		353	struct cs42xx8_priv *cs42xx8 = snd_soc_component_get_drvdata(component);
		354	bool tx = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
284		355
		356	/* Clear stored rate */
		357	cs42xx8->rate[tx] = 0;
		358
		359	regmap_update_bits(cs42xx8->regmap, CS42XX8_FUNCMOD,
		360	CS42XX8_FUNCMOD_xC_FM_MASK(tx),
		361	CS42XX8_FUNCMOD_xC_FM(tx, CS42XX8_FM_AUTO));
285	return 0;	362	return 0;
286	}	363	}
287		364
@@ -302,6 +379,7 @@ static const struct snd_soc_dai_ops cs42xx8_dai_ops = { · 14 unmodified lines
302	.set_fmt = cs42xx8_set_dai_fmt,	379	.set_fmt = cs42xx8_set_dai_fmt,
303	.set_sysclk = cs42xx8_set_dai_sysclk,	380	.set_sysclk = cs42xx8_set_dai_sysclk,
304	.hw_params = cs42xx8_hw_params,	381	.hw_params = cs42xx8_hw_params,
		382	.hw_free = cs42xx8_hw_free,
305	.digital_mute = cs42xx8_digital_mute,	383	.digital_mute = cs42xx8_digital_mute,
306	};	384	};
307		385

sound/soc/codecs/max98357a.c+4−21

 #include <sound/soc-dapm.h>
 struct max98357a_priv {
-	struct delayed_work enable_sdmode_work;
 	struct gpio_desc *sdmode;
 	unsigned int sdmode_delay;
 };
-static void max98357a_enable_sdmode_work(struct work_struct *work)
-{
-	struct max98357a_priv *max98357a =
-	container_of(work, struct max98357a_priv,
-			enable_sdmode_work.work);
-	gpiod_set_value(max98357a->sdmode, 1);
-}
 static int max98357a_daiops_trigger(struct snd_pcm_substream *substream,
 		int cmd, struct snd_soc_dai *dai)
 {
 	case SNDRV_PCM_TRIGGER_START:
 	case SNDRV_PCM_TRIGGER_RESUME:
 	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
-		queue_delayed_work(system_power_efficient_wq,
+		mdelay(max98357a->sdmode_delay);
-				&max98357a->enable_sdmode_work,
+		gpiod_set_value(max98357a->sdmode, 1);
-				msecs_to_jiffies(max98357a->sdmode_delay));
 		break;
 	case SNDRV_PCM_TRIGGER_STOP:
 	case SNDRV_PCM_TRIGGER_SUSPEND:
 	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
-		cancel_delayed_work_sync(&max98357a->enable_sdmode_work);
 		gpiod_set_value(max98357a->sdmode, 0);
 		break;
 	}
 	int ret;
 	max98357a = devm_kzalloc(&pdev->dev, sizeof(*max98357a), GFP_KERNEL);
 	if (!max98357a)
 		return -ENOMEM;
 	max98357a->sdmode = devm_gpiod_get_optional(&pdev->dev,
 				"sdmode", GPIOD_OUT_LOW);
 	if (IS_ERR(max98357a->sdmode))
 		return PTR_ERR(max98357a->sdmode);
 	ret = device_property_read_u32(&pdev->dev, "sdmode-delay",
 					&max98357a->sdmode_delay);
 	if (ret) {
 		max98357a->sdmode_delay = 0;
 		dev_dbg(&pdev->dev,
-			"no optional property 'sdmode-delay' found, default: no delay\n");
+			"no optional property 'sdmode-delay' found, "
+			"default: no delay\n");
 	}
 	dev_set_drvdata(&pdev->dev, max98357a);
-	INIT_DELAYED_WORK(&max98357a->enable_sdmode_work,
-				max98357a_enable_sdmode_work);
 	return devm_snd_soc_register_component(&pdev->dev,
 			&max98357a_component_driver,
 			&max98357a_dai_driver, 1);

sound/soc/codecs/max98373.c+6−0

 	case 48000:
 		sampling_rate = MAX98373_PCM_SR_SET1_SR_48000;
 		break;
+	case 88200:
+		sampling_rate = MAX98373_PCM_SR_SET1_SR_88200;
+		break;
+	case 96000:
+		sampling_rate = MAX98373_PCM_SR_SET1_SR_96000;
+		break;
 	default:
 		dev_err(component->dev, "rate %d not supported\n",
 			params_rate(params));

sound/soc/codecs/max98373.h+2−0

@@ -130,6 +130,8 @@ · 129 unmodified lines
130	#define MAX98373_PCM_SR_SET1_SR_32000 (0x6 << 0)	130	#define MAX98373_PCM_SR_SET1_SR_32000 (0x6 << 0)
131	#define MAX98373_PCM_SR_SET1_SR_44100 (0x7 << 0)	131	#define MAX98373_PCM_SR_SET1_SR_44100 (0x7 << 0)
132	#define MAX98373_PCM_SR_SET1_SR_48000 (0x8 << 0)	132	#define MAX98373_PCM_SR_SET1_SR_48000 (0x8 << 0)
		133	#define MAX98373_PCM_SR_SET1_SR_88200 (0x9 << 0)
		134	#define MAX98373_PCM_SR_SET1_SR_96000 (0xA << 0)
133		135
134	/* MAX98373_R2028_PCM_SR_SETUP_2 */	136	/* MAX98373_R2028_PCM_SR_SETUP_2 */
135	#define MAX98373_PCM_SR_SET2_SR_MASK (0xF << 4)	137	#define MAX98373_PCM_SR_SET2_SR_MASK (0xF << 4)

sound/soc/codecs/pcm3060-i2c.c+2−2

@@ -2,7 +2,7 @@ · 1 unmodified line
2	//	2	//
3	// PCM3060 I2C driver	3	// PCM3060 I2C driver
4	//	4	//
5	// Copyright (C) 2018 Kirill Marinushkin <kmarinushkin@birdec.tech>	5	// Copyright (C) 2018 Kirill Marinushkin <kmarinushkin@birdec.com>
6		6
7	#include <linux/i2c.h>	7	#include <linux/i2c.h>
8	#include <linux/module.h>	8	#include <linux/module.h>
@@ -56,5 +56,5 @@ static struct i2c_driver pcm3060_i2c_driver = { · 47 unmodified lines
56	module_i2c_driver(pcm3060_i2c_driver);	56	module_i2c_driver(pcm3060_i2c_driver);
57		57
58	MODULE_DESCRIPTION("PCM3060 I2C driver");	58	MODULE_DESCRIPTION("PCM3060 I2C driver");
59	MODULE_AUTHOR("Kirill Marinushkin <kmarinushkin@birdec.tech>");	59	MODULE_AUTHOR("Kirill Marinushkin <kmarinushkin@birdec.com>");
60	MODULE_LICENSE("GPL v2");	60	MODULE_LICENSE("GPL v2");

sound/soc/codecs/pcm3060-spi.c+2−2

@@ -2,7 +2,7 @@ · 1 unmodified line
2	//	2	//
3	// PCM3060 SPI driver	3	// PCM3060 SPI driver
4	//	4	//
5	// Copyright (C) 2018 Kirill Marinushkin <kmarinushkin@birdec.tech>	5	// Copyright (C) 2018 Kirill Marinushkin <kmarinushkin@birdec.com>
6		6
7	#include <linux/module.h>	7	#include <linux/module.h>
8	#include <linux/spi/spi.h>	8	#include <linux/spi/spi.h>
@@ -55,5 +55,5 @@ static struct spi_driver pcm3060_spi_driver = { · 46 unmodified lines
55	module_spi_driver(pcm3060_spi_driver);	55	module_spi_driver(pcm3060_spi_driver);
56		56
57	MODULE_DESCRIPTION("PCM3060 SPI driver");	57	MODULE_DESCRIPTION("PCM3060 SPI driver");
58	MODULE_AUTHOR("Kirill Marinushkin <kmarinushkin@birdec.tech>");	58	MODULE_AUTHOR("Kirill Marinushkin <kmarinushkin@birdec.com>");
59	MODULE_LICENSE("GPL v2");	59	MODULE_LICENSE("GPL v2");

sound/soc/codecs/pcm3060.c+2−2

@@ -2,7 +2,7 @@ · 1 unmodified line
2	//	2	//
3	// PCM3060 codec driver	3	// PCM3060 codec driver
4	//	4	//
5	// Copyright (C) 2018 Kirill Marinushkin <kmarinushkin@birdec.tech>	5	// Copyright (C) 2018 Kirill Marinushkin <kmarinushkin@birdec.com>
6		6
7	#include <linux/module.h>	7	#include <linux/module.h>
8	#include <sound/pcm_params.h>	8	#include <sound/pcm_params.h>
@@ -342,5 +342,5 @@ int pcm3060_probe(struct device *dev) · 333 unmodified lines
342	EXPORT_SYMBOL(pcm3060_probe);	342	EXPORT_SYMBOL(pcm3060_probe);
343		343
344	MODULE_DESCRIPTION("PCM3060 codec driver");	344	MODULE_DESCRIPTION("PCM3060 codec driver");
345	MODULE_AUTHOR("Kirill Marinushkin <kmarinushkin@birdec.tech>");	345	MODULE_AUTHOR("Kirill Marinushkin <kmarinushkin@birdec.com>");
346	MODULE_LICENSE("GPL v2");	346	MODULE_LICENSE("GPL v2");

sound/soc/codecs/pcm3060.h+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	/*	2	/*
3	* PCM3060 codec driver	3	* PCM3060 codec driver
4	*	4	*
5	* Copyright (C) 2018 Kirill Marinushkin <kmarinushkin@birdec.tech>	5	* Copyright (C) 2018 Kirill Marinushkin <kmarinushkin@birdec.com>
6	*/	6	*/
7		7
8	#ifndef _SND_SOC_PCM3060_H	8	#ifndef _SND_SOC_PCM3060_H

sound/soc/codecs/rt1011.c+2−2

@@ -39,7 +39,7 @@ static const struct reg_sequence init_list[] = { · 38 unmodified lines
39	{ RT1011_POWER_9, 0xa840 },	39	{ RT1011_POWER_9, 0xa840 },
40		40
41	{ RT1011_ADC_SET_5, 0x0a20 },	41	{ RT1011_ADC_SET_5, 0x0a20 },
42	{ RT1011_DAC_SET_2, 0xa232 },	42	{ RT1011_DAC_SET_2, 0xa032 },
43	{ RT1011_ADC_SET_1, 0x2925 },	43	{ RT1011_ADC_SET_1, 0x2925 },
44		44
45	{ RT1011_SPK_PRO_DC_DET_1, 0xb00c },	45	{ RT1011_SPK_PRO_DC_DET_1, 0xb00c },
@@ -1917,7 +1917,7 @@ static int rt1011_set_bias_level(struct snd_soc_component *component, · 1871 unmodified lines
1917	snd_soc_component_write(component,	1917	snd_soc_component_write(component,
1918	RT1011_SYSTEM_RESET_2, 0x0000);	1918	RT1011_SYSTEM_RESET_2, 0x0000);
1919	snd_soc_component_write(component,	1919	snd_soc_component_write(component,
1920	RT1011_SYSTEM_RESET_3, 0x0000);	1920	RT1011_SYSTEM_RESET_3, 0x0001);
1921	snd_soc_component_write(component,	1921	snd_soc_component_write(component,
1922	RT1011_SYSTEM_RESET_1, 0x003f);	1922	RT1011_SYSTEM_RESET_1, 0x003f);
1923	snd_soc_component_write(component,	1923	snd_soc_component_write(component,

sound/soc/codecs/rt1308.c+0−0

File mode changed from 100755 to 100644.

sound/soc/codecs/rt1308.h+0−0

File mode changed from 100755 to 100644.

sound/soc/generic/audio-graph-card.c+16−14

 	struct device_node *endpoint;
 	struct of_endpoint info;
 	int i, id;
+	const u32 *reg;
 	int ret;
 	/* use driver specified DAI ID if exist */
 			return info.id;
 		node = of_get_parent(ep);
+		reg = of_get_property(node, "reg", NULL);
 		of_node_put(node);
-		if (of_get_property(node, "reg", NULL))
+		if (reg)
 			return info.port;
 	}
 	node = of_graph_get_port_parent(ep);
 	dev_dbg(dev, "link_of DPCM (%pOF)\n", ep);
-	of_node_put(ports);
-	of_node_put(port);
-	of_node_put(node);
 	if (li->cpu) {
 		int is_single_links = 0;
 		ret = asoc_simple_parse_cpu(ep, dai_link, &is_single_links);
 		if (ret)
-			return ret;
+			goto out_put_node;
 		ret = asoc_simple_parse_clk_cpu(dev, ep, dai_link, dai);
 		if (ret < 0)
-			return ret;
+			goto out_put_node;
 		ret = asoc_simple_set_dailink_name(dev, dai_link,
 						   "fe.%s",
 						   cpus->dai_name);
 		if (ret < 0)
-			return ret;
+			goto out_put_node;
 		/* card->num_links includes Codec */
 		asoc_simple_canonicalize_cpu(dai_link, is_single_links);
 		ret = asoc_simple_parse_codec(ep, dai_link);
 		if (ret < 0)
-			return ret;
+			goto out_put_node;
 		ret = asoc_simple_parse_clk_codec(dev, ep, dai_link, dai);
 		if (ret < 0)
-			return ret;
+			goto out_put_node;
 		ret = asoc_simple_set_dailink_name(dev, dai_link,
 						   "be.%s",
 						   codecs->dai_name);
 		if (ret < 0)
-			return ret;
+			goto out_put_node;
 		/* check "prefix" from top node */
 		snd_soc_of_parse_node_prefix(top, cconf, codecs->of_node,
 	ret = asoc_simple_parse_tdm(ep, dai);
 	if (ret)
-		return ret;
+		goto out_put_node;
 	ret = asoc_simple_parse_daifmt(dev, cpu_ep, codec_ep,
 				       NULL, &dai_link->dai_fmt);
 	if (ret < 0)
-		return ret;
+		goto out_put_node;
 	dai_link->dpcm_playback		= 1;
 	dai_link->dpcm_capture		= 1;
 	dai_link->ops			= &graph_ops;
 	dai_link->init			= asoc_simple_dai_init;
-	return 0;
+out_put_node:
+	of_node_put(ports);
+	of_node_put(port);
+	of_node_put(node);
+	return ret;
 }
 static int graph_dai_link_of(struct asoc_simple_priv *priv,

sound/soc/generic/simple-card-utils.c+7−0

@@ -349,6 +349,13 @@ void asoc_simple_canonicalize_platform(struct snd_soc_dai_link *dai_link) · 348 unmodified lines
349	/* Assumes platform == cpu */	349	/* Assumes platform == cpu */
350	if (!dai_link->platforms->of_node)	350	if (!dai_link->platforms->of_node)
351	dai_link->platforms->of_node = dai_link->cpus->of_node;	351	dai_link->platforms->of_node = dai_link->cpus->of_node;
		352
		353	/*
		354	* DPCM BE can be no platform.
		355	* Alloced memory will be waste, but not leak.
		356	*/
		357	if (!dai_link->platforms->of_node)
		358	dai_link->num_platforms = 0;
352	}	359	}
353	EXPORT_SYMBOL_GPL(asoc_simple_canonicalize_platform);	360	EXPORT_SYMBOL_GPL(asoc_simple_canonicalize_platform);
354		361

sound/soc/generic/simple-card.c+13−13

 	li->link++;
-	of_node_put(node);
 	/* For single DAI link & old style of DT node */
 	if (is_top)
 		prefix = PREFIX;
 		ret = asoc_simple_parse_cpu(np, dai_link, &is_single_links);
 		if (ret)
-			return ret;
+			goto out_put_node;
 		ret = asoc_simple_parse_clk_cpu(dev, np, dai_link, dai);
 		if (ret < 0)
-			return ret;
+			goto out_put_node;
 		ret = asoc_simple_set_dailink_name(dev, dai_link,
 						   "fe.%s",
 						   cpus->dai_name);
 		if (ret < 0)
-			return ret;
+			goto out_put_node;
 		asoc_simple_canonicalize_cpu(dai_link, is_single_links);
 	} else {
 		ret = asoc_simple_parse_codec(np, dai_link);
 		if (ret < 0)
-			return ret;
+			goto out_put_node;
 		ret = asoc_simple_parse_clk_codec(dev, np, dai_link, dai);
 		if (ret < 0)
-			return ret;
+			goto out_put_node;
 		ret = asoc_simple_set_dailink_name(dev, dai_link,
 						   "be.%s",
 						   codecs->dai_name);
 		if (ret < 0)
-			return ret;
+			goto out_put_node;
 		/* check "prefix" from top node */
 		snd_soc_of_parse_node_prefix(top, cconf, codecs->of_node,
 	ret = asoc_simple_parse_tdm(np, dai);
 	if (ret)
-		return ret;
+		goto out_put_node;
 	ret = asoc_simple_parse_daifmt(dev, node, codec,
 				       prefix, &dai_link->dai_fmt);
 	if (ret < 0)
-		return ret;
+		goto out_put_node;
 	dai_link->dpcm_playback		= 1;
 	dai_link->dpcm_capture		= 1;
 	dai_link->ops			= &simple_ops;
 	dai_link->init			= asoc_simple_dai_init;
-	return 0;
+out_put_node:
+	of_node_put(node);
+	return ret;
 }
 static int simple_dai_link_of(struct asoc_simple_priv *priv,
 			goto error;
 		}
-		of_node_put(codec);
 		/* get convert-xxx property */
 		memset(&adata, 0, sizeof(adata));
 		for_each_child_of_node(node, np)
 				ret = func_noml(priv, np, codec, li, is_top);
 			if (ret < 0) {
+				of_node_put(codec);
 				of_node_put(np);
 				goto error;
 			}
 		}
+		of_node_put(codec);
 		node = of_get_next_child(top, node);
 	} while (!is_top && node);

sound/soc/intel/boards/bytcht_es8316.c+8−0

@@ -437,6 +437,14 @@ static const struct acpi_gpio_mapping byt_cht_es8316_gpios[] = { · 436 unmodified lines
437		437
438	/* Please keep this list alphabetically sorted */	438	/* Please keep this list alphabetically sorted */
439	static const struct dmi_system_id byt_cht_es8316_quirk_table[] = {	439	static const struct dmi_system_id byt_cht_es8316_quirk_table[] = {
		440	{ /* Irbis NB41 */
		441	.matches = {
		442	DMI_MATCH(DMI_SYS_VENDOR, "IRBIS"),
		443	DMI_MATCH(DMI_PRODUCT_NAME, "NB41"),
		444	},
		445	.driver_data = (void *)(BYT_CHT_ES8316_INTMIC_IN2_MAP
		446	\| BYT_CHT_ES8316_JD_INVERTED),
		447	},
440	{ /* Teclast X98 Plus II */	448	{ /* Teclast X98 Plus II */
441	.matches = {	449	.matches = {
442	DMI_MATCH(DMI_SYS_VENDOR, "TECLAST"),	450	DMI_MATCH(DMI_SYS_VENDOR, "TECLAST"),

sound/soc/intel/common/soc-acpi-intel-bxt-match.c+1−1

@@ -1,6 +1,6 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	/*	2	/*
3	* soc-apci-intel-bxt-match.c - tables and support for BXT ACPI enumeration.	3	* soc-acpi-intel-bxt-match.c - tables and support for BXT ACPI enumeration.
4	*	4	*
5	* Copyright (c) 2018, Intel Corporation.	5	* Copyright (c) 2018, Intel Corporation.
6	*	6	*

sound/soc/intel/common/soc-acpi-intel-byt-match.c+1−1

@@ -1,6 +1,6 @@
1	// SPDX-License-Identifier: GPL-2.0-only	1	// SPDX-License-Identifier: GPL-2.0-only
2	/*	2	/*
3	* soc-apci-intel-byt-match.c - tables and support for BYT ACPI enumeration.	3	* soc-acpi-intel-byt-match.c - tables and support for BYT ACPI enumeration.
4	*	4	*
5	* Copyright (c) 2017, Intel Corporation.	5	* Copyright (c) 2017, Intel Corporation.
6	*/	6	*/

sound/soc/intel/common/soc-acpi-intel-cht-match.c+1−1

@@ -1,6 +1,6 @@
1	// SPDX-License-Identifier: GPL-2.0-only	1	// SPDX-License-Identifier: GPL-2.0-only
2	/*	2	/*
3	* soc-apci-intel-cht-match.c - tables and support for CHT ACPI enumeration.	3	* soc-acpi-intel-cht-match.c - tables and support for CHT ACPI enumeration.
4	*	4	*
5	* Copyright (c) 2017, Intel Corporation.	5	* Copyright (c) 2017, Intel Corporation.
6	*/	6	*/

sound/soc/intel/common/soc-acpi-intel-cnl-match.c+1−1

@@ -1,6 +1,6 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	/*	2	/*
3	* soc-apci-intel-cnl-match.c - tables and support for CNL ACPI enumeration.	3	* soc-acpi-intel-cnl-match.c - tables and support for CNL ACPI enumeration.
4	*	4	*
5	* Copyright (c) 2018, Intel Corporation.	5	* Copyright (c) 2018, Intel Corporation.
6	*	6	*

sound/soc/intel/common/soc-acpi-intel-glk-match.c+1−1

@@ -1,6 +1,6 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	/*	2	/*
3	* soc-apci-intel-glk-match.c - tables and support for GLK ACPI enumeration.	3	* soc-acpi-intel-glk-match.c - tables and support for GLK ACPI enumeration.
4	*	4	*
5	* Copyright (c) 2018, Intel Corporation.	5	* Copyright (c) 2018, Intel Corporation.
6	*	6	*

sound/soc/intel/common/soc-acpi-intel-hda-match.c+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	// Copyright (c) 2018, Intel Corporation.	2	// Copyright (c) 2018, Intel Corporation.
3		3
4	/*	4	/*
5	* soc-apci-intel-hda-match.c - tables and support for HDA+ACPI enumeration.	5	* soc-acpi-intel-hda-match.c - tables and support for HDA+ACPI enumeration.
6	*	6	*
7	*/	7	*/
8		8

sound/soc/intel/common/soc-acpi-intel-hsw-bdw-match.c+1−1

@@ -1,6 +1,6 @@
1	// SPDX-License-Identifier: GPL-2.0-only	1	// SPDX-License-Identifier: GPL-2.0-only
2	/*	2	/*
3	* soc-apci-intel-hsw-bdw-match.c - tables and support for ACPI enumeration.	3	* soc-acpi-intel-hsw-bdw-match.c - tables and support for ACPI enumeration.
4	*	4	*
5	* Copyright (c) 2017, Intel Corporation.	5	* Copyright (c) 2017, Intel Corporation.
6	*/	6	*/

sound/soc/intel/common/soc-acpi-intel-icl-match.c+1−1

@@ -1,6 +1,6 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	/*	2	/*
3	* soc-apci-intel-icl-match.c - tables and support for ICL ACPI enumeration.	3	* soc-acpi-intel-icl-match.c - tables and support for ICL ACPI enumeration.
4	*	4	*
5	* Copyright (c) 2018, Intel Corporation.	5	* Copyright (c) 2018, Intel Corporation.
6	*	6	*

sound/soc/intel/common/soc-acpi-intel-kbl-match.c+1−1

@@ -1,6 +1,6 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	/*	2	/*
3	* soc-apci-intel-kbl-match.c - tables and support for KBL ACPI enumeration.	3	* soc-acpi-intel-kbl-match.c - tables and support for KBL ACPI enumeration.
4	*	4	*
5	* Copyright (c) 2018, Intel Corporation.	5	* Copyright (c) 2018, Intel Corporation.
6	*	6	*

sound/soc/intel/common/soc-acpi-intel-skl-match.c+1−1

@@ -1,6 +1,6 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	/*	2	/*
3	* soc-apci-intel-skl-match.c - tables and support for SKL ACPI enumeration.	3	* soc-acpi-intel-skl-match.c - tables and support for SKL ACPI enumeration.
4	*	4	*
5	* Copyright (c) 2018, Intel Corporation.	5	* Copyright (c) 2018, Intel Corporation.
6	*	6	*

sound/soc/qcom/apq8016_sbc.c+8−8

@@ -150,17 +150,17 @@ static struct apq8016_sbc_data apq8016_sbc_parse_of(struct snd_soc_card card) · 149 unmodified lines
150		150
151	link = data->dai_link;	151	link = data->dai_link;
152		152
153	dlc = devm_kzalloc(dev, 2 * sizeof(*dlc), GFP_KERNEL);	153	for_each_child_of_node(node, np) {
154	if (!dlc)	154	dlc = devm_kzalloc(dev, 2 * sizeof(*dlc), GFP_KERNEL);
155	return ERR_PTR(-ENOMEM);	155	if (!dlc)
		156	return ERR_PTR(-ENOMEM);
156		157
157	link->cpus = &dlc[0];	158	link->cpus = &dlc[0];
158	link->platforms = &dlc[1];	159	link->platforms = &dlc[1];
159		160
160	link->num_cpus = 1;	161	link->num_cpus = 1;
161	link->num_platforms = 1;	162	link->num_platforms = 1;
162		163
163	for_each_child_of_node(node, np) {
164	cpu = of_get_child_by_name(np, "cpu");	164	cpu = of_get_child_by_name(np, "cpu");
165	codec = of_get_child_by_name(np, "codec");	165	codec = of_get_child_by_name(np, "codec");
166		166

sound/soc/rockchip/rockchip_i2s.c+2−3

 		val |= I2S_CHN_4;
 		break;
 	case 2:
-	case 1:
 		val |= I2S_CHN_2;
 		break;
 	default:
 	},
 	.capture = {
 		.stream_name = "Capture",
-		.channels_min = 1,
+		.channels_min = 2,
 		.channels_max = 2,
 		.rates = SNDRV_PCM_RATE_8000_192000,
 		.formats = (SNDRV_PCM_FMTBIT_S8 |
 	}
 	if (!of_property_read_u32(node, "rockchip,capture-channels", &val)) {
-		if (val >= 1 && val <= 8)
+		if (val >= 2 && val <= 8)
 			soc_dai->capture.channels_max = val;
 	}

sound/soc/rockchip/rockchip_max98090.c+32−0

@@ -61,6 +61,37 @@ static const struct snd_kcontrol_new rk_mc_controls[] = { · 60 unmodified lines
61	SOC_DAPM_PIN_SWITCH("Speaker"),	61	SOC_DAPM_PIN_SWITCH("Speaker"),
62	};	62	};
63		63
		64	static int rk_jack_event(struct notifier_block *nb, unsigned long event,
		65	void *data)
		66	{
		67	struct snd_soc_jack jack = (struct snd_soc_jack )data;
		68	struct snd_soc_dapm_context *dapm = &jack->card->dapm;
		69
		70	if (event & SND_JACK_MICROPHONE)
		71	snd_soc_dapm_force_enable_pin(dapm, "MICBIAS");
		72	else
		73	snd_soc_dapm_disable_pin(dapm, "MICBIAS");
		74
		75	snd_soc_dapm_sync(dapm);
		76
		77	return 0;
		78	}
		79
		80	static struct notifier_block rk_jack_nb = {
		81	.notifier_call = rk_jack_event,
		82	};
		83
		84	static int rk_init(struct snd_soc_pcm_runtime *runtime)
		85	{
		86	/*
		87	* The jack has already been created in the rk_98090_headset_init()
		88	* function.
		89	*/
		90	snd_soc_jack_notifier_register(&headset_jack, &rk_jack_nb);
		91
		92	return 0;
		93	}
		94
64	static int rk_aif1_hw_params(struct snd_pcm_substream *substream,	95	static int rk_aif1_hw_params(struct snd_pcm_substream *substream,
65	struct snd_pcm_hw_params *params)	96	struct snd_pcm_hw_params *params)
66	{	97	{
@@ -119,6 +150,7 @@ SND_SOC_DAILINK_DEFS(hifi, · 52 unmodified lines
119	static struct snd_soc_dai_link rk_dailink = {	150	static struct snd_soc_dai_link rk_dailink = {
120	.name = "max98090",	151	.name = "max98090",
121	.stream_name = "Audio",	152	.stream_name = "Audio",
		153	.init = rk_init,
122	.ops = &rk_aif1_ops,	154	.ops = &rk_aif1_ops,
123	/* set max98090 as slave */	155	/* set max98090 as slave */
124	.dai_fmt = SND_SOC_DAIFMT_I2S \| SND_SOC_DAIFMT_NB_NF \|	156	.dai_fmt = SND_SOC_DAIFMT_I2S \| SND_SOC_DAIFMT_NB_NF \|

sound/soc/samsung/odroid.c+5−3

 	}
 	of_node_put(cpu);
-	of_node_put(codec);
 	if (ret < 0)
-		return ret;
+		goto err_put_node;
 	ret = snd_soc_of_get_dai_link_codecs(dev, codec, codec_link);
 	if (ret < 0)
 		ret = PTR_ERR(priv->clk_i2s_bus);
 		goto err_put_sclk;
 	}
-	of_node_put(cpu_dai);
 	ret = devm_snd_soc_register_card(dev, card);
 	if (ret < 0) {
 		goto err_put_clk_i2s;
 	}
+	of_node_put(cpu_dai);
+	of_node_put(codec);
 	return 0;
 err_put_clk_i2s:
 err_put_cpu_dai:
 	of_node_put(cpu_dai);
 	snd_soc_of_put_dai_link_codecs(codec_link);
+err_put_node:
+	of_node_put(codec);
 	return ret;
 }

sound/soc/soc-core.c+5−2

 		}
 	}
-	if (dai_link->dai_fmt)
+	if (dai_link->dai_fmt) {
-		snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt);
+		ret = snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt);
+		if (ret)
+			return ret;
+	}
 	ret = soc_post_component_init(rtd, dai_link->name);
 	if (ret)

sound/soc/soc-dapm.c+6−4

 		list_add_tail(&widget->work_list, list);
 	if (custom_stop_condition && custom_stop_condition(widget, dir)) {
-		widget->endpoints[dir] = 1;
+		list = NULL;
-		return widget->endpoints[dir];
+		custom_stop_condition = NULL;
 	}
 	if ((widget->is_ep & SND_SOC_DAPM_DIR_TO_EP(dir)) && widget->connected) {
  *
  * Optionally, can be supplied with a function acting as a stopping condition.
  * This function takes the dapm widget currently being examined and the walk
- * direction as an arguments, it should return true if the walk should be
+ * direction as an arguments, it should return true if widgets from that point
- * stopped and false otherwise.
+ * in the graph onwards should not be added to the widget list.
  */
 static int is_connected_output_ep(struct snd_soc_dapm_widget *widget,
 	struct list_head *list,
 		dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n",
 			w->name, ret);
+	kfree_const(w->sname);
+	kfree(w);
 	return ERR_PTR(ret);
 }

sound/soc/sof/intel/cnl.c+2−2

@@ -101,8 +101,8 @@ static irqreturn_t cnl_ipc_irq_thread(int irq, void *context) · 100 unmodified lines
101	/*	101	/*
102	* This interrupt is not shared so no need to return IRQ_NONE.	102	* This interrupt is not shared so no need to return IRQ_NONE.
103	*/	103	*/
104	dev_err_ratelimited(sdev->dev,	104	dev_dbg_ratelimited(sdev->dev,
105	"error: nothing to do in IRQ thread\n");	105	"nothing to do in IPC IRQ thread\n");
106	}	106	}
107		107
108	/* re-enable IPC interrupt */	108	/* re-enable IPC interrupt */

sound/soc/sof/intel/hda-ipc.c+2−2

@@ -224,8 +224,8 @@ irqreturn_t hda_dsp_ipc_irq_thread(int irq, void *context) · 223 unmodified lines
224	/*	224	/*
225	* This interrupt is not shared so no need to return IRQ_NONE.	225	* This interrupt is not shared so no need to return IRQ_NONE.
226	*/	226	*/
227	dev_err_ratelimited(sdev->dev,	227	dev_dbg_ratelimited(sdev->dev,
228	"error: nothing to do in IRQ thread\n");	228	"nothing to do in IPC IRQ thread\n");
229	}	229	}
230		230
231	/* re-enable IPC interrupt */	231	/* re-enable IPC interrupt */

sound/soc/sunxi/sun4i-i2s.c+2−2

@@ -1002,8 +1002,8 @@ static const struct sun4i_i2s_quirks sun50i_a64_codec_i2s_quirks = { · 1001 unmodified lines
1002	.field_rxchanmap = REG_FIELD(SUN4I_I2S_RX_CHAN_MAP_REG, 0, 31),	1002	.field_rxchanmap = REG_FIELD(SUN4I_I2S_RX_CHAN_MAP_REG, 0, 31),
1003	.field_txchansel = REG_FIELD(SUN4I_I2S_TX_CHAN_SEL_REG, 0, 2),	1003	.field_txchansel = REG_FIELD(SUN4I_I2S_TX_CHAN_SEL_REG, 0, 2),
1004	.field_rxchansel = REG_FIELD(SUN4I_I2S_RX_CHAN_SEL_REG, 0, 2),	1004	.field_rxchansel = REG_FIELD(SUN4I_I2S_RX_CHAN_SEL_REG, 0, 2),
1005	.get_sr = sun8i_i2s_get_sr_wss,	1005	.get_sr = sun4i_i2s_get_sr,
1006	.get_wss = sun8i_i2s_get_sr_wss,	1006	.get_wss = sun4i_i2s_get_wss,
1007	};	1007	};
1008		1008
1009	static int sun4i_i2s_init_regmap_fields(struct device *dev,	1009	static int sun4i_i2s_init_regmap_fields(struct device *dev,

sound/soc/ti/davinci-mcasp.c+36−10

 {
 	u32 bit;
-	for_each_set_bit(bit, &mcasp->pdir, PIN_BIT_AFSR) {
+	for_each_set_bit(bit, &mcasp->pdir, PIN_BIT_AMUTE) {
 		if (enable)
 			mcasp_set_bits(mcasp, DAVINCI_MCASP_PDIR_REG, BIT(bit));
 		else
 	if (mcasp_is_synchronous(mcasp)) {
 		mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXHCLKRST);
 		mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXCLKRST);
+		mcasp_set_clk_pdir(mcasp, true);
 	}
 	/* Activate serializer(s) */
 	return ret;
 }
+static int davinci_mcasp_hw_rule_slot_width(struct snd_pcm_hw_params *params,
+					    struct snd_pcm_hw_rule *rule)
+{
+	struct davinci_mcasp_ruledata *rd = rule->private;
+	struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
+	struct snd_mask nfmt;
+	int i, slot_width;
+	snd_mask_none(&nfmt);
+	slot_width = rd->mcasp->slot_width;
+	for (i = 0; i <= SNDRV_PCM_FORMAT_LAST; i++) {
+		if (snd_mask_test(fmt, i)) {
+			if (snd_pcm_format_width(i) <= slot_width) {
+				snd_mask_set(&nfmt, i);
+			}
+		}
+	}
+	return snd_mask_refine(fmt, &nfmt);
+}
 static const unsigned int davinci_mcasp_dai_rates[] = {
 	8000, 11025, 16000, 22050, 32000, 44100, 48000, 64000,
 	88200, 96000, 176400, 192000,
 	struct davinci_mcasp_ruledata *ruledata =
 					&mcasp->ruledata[substream->stream];
 	u32 max_channels = 0;
-	int i, dir;
+	int i, dir, ret;
 	int tdm_slots = mcasp->tdm_slots;
 	/* Do not allow more then one stream per direction */
 			max_channels++;
 	}
 	ruledata->serializers = max_channels;
+	ruledata->mcasp = mcasp;
 	max_channels *= tdm_slots;
 	/*
 	 * If the already active stream has less channels than the calculated
 				   0, SNDRV_PCM_HW_PARAM_CHANNELS,
 				   &mcasp->chconstr[substream->stream]);
-	if (mcasp->slot_width)
+	if (mcasp->slot_width) {
-		snd_pcm_hw_constraint_minmax(substream->runtime,
+		/* Only allow formats require <= slot_width bits on the bus */
-					     SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
+		ret = snd_pcm_hw_rule_add(substream->runtime, 0,
-					     8, mcasp->slot_width);
+					  SNDRV_PCM_HW_PARAM_FORMAT,
+					  davinci_mcasp_hw_rule_slot_width,
+					  ruledata,
+					  SNDRV_PCM_HW_PARAM_FORMAT, -1);
+		if (ret)
+			return ret;
+	}
 	/*
 	 * If we rely on implicit BCLK divider setting we should
 	 * set constraints based on what we can provide.
 	 */
 	if (mcasp->bclk_master && mcasp->bclk_div == 0 && mcasp->sysclk_freq) {
-		int ret;
-		ruledata->mcasp = mcasp;
 		ret = snd_pcm_hw_rule_add(substream->runtime, 0,
 					  SNDRV_PCM_HW_PARAM_RATE,
 					  davinci_mcasp_hw_rule_rate,

sound/sound_core.c+2−1

@@ -275,7 +275,8 @@ retry: · 274 unmodified lines
275	goto retry;	275	goto retry;
276	}	276	}
277	spin_unlock(&sound_loader_lock);	277	spin_unlock(&sound_loader_lock);
278	return -EBUSY;	278	r = -EBUSY;
		279	goto fail;
279	}	280	}
280	}	281	}
281		282

sound/usb/hiface/pcm.c+8−3

 		ret = hiface_pcm_init_urb(&rt->out_urbs[i], chip, OUT_EP,
 				    hiface_pcm_out_urb_handler);
 		if (ret < 0)
-			return ret;
+			goto error;
 	}
 	ret = snd_pcm_new(chip->card, "USB-SPDIF Audio", 0, 1, 0, &pcm);
 	if (ret < 0) {
-		kfree(rt);
 		dev_err(&chip->dev->dev, "Cannot create pcm instance\n");
-		return ret;
+		goto error;
 	}
 	pcm->private_data = rt;
 	chip->pcm = rt;
 	return 0;
+error:
+	for (i = 0; i < PCM_N_URBS; i++)
+		kfree(rt->out_urbs[i].buffer);
+	kfree(rt);
+	return ret;
 }

sound/usb/mixer.c+29−8

 	unsigned char *buffer;
 	unsigned int buflen;
 	DECLARE_BITMAP(unitbitmap, MAX_ID_ELEMS);
+	DECLARE_BITMAP(termbitmap, MAX_ID_ELEMS);
 	struct usb_audio_term oterm;
 	const struct usbmix_name_map *map;
 	const struct usbmix_selector_map *selector_map;
 		return -EINVAL;
 	if (!desc->bNrInPins)
 		return -EINVAL;
+	if (desc->bLength < sizeof(*desc) + desc->bNrInPins)
+		return -EINVAL;
 	switch (state->mixer->protocol) {
 	case UAC_VERSION_1:
  * parse the source unit recursively until it reaches to a terminal
  * or a branched unit.
  */
-static int check_input_term(struct mixer_build *state, int id,
+static int __check_input_term(struct mixer_build *state, int id,
 			    struct usb_audio_term *term)
 {
 	int protocol = state->mixer->protocol;
 	int err;
 	void *p1;
+	unsigned char *hdr;
 	memset(term, 0, sizeof(*term));
-	while ((p1 = find_audio_control_unit(state, id)) != NULL) {
+	for (;;) {
-		unsigned char *hdr = p1;
+		/* a loop in the terminal chain? */
+		if (test_and_set_bit(id, state->termbitmap))
+			return -EINVAL;
+		p1 = find_audio_control_unit(state, id);
+		if (!p1)
+			break;
+		hdr = p1;
 		term->id = id;
 		if (protocol == UAC_VERSION_1 || protocol == UAC_VERSION_2) {
 					/* call recursively to verify that the
 					 * referenced clock entity is valid */
-					err = check_input_term(state, d->bCSourceID, term);
+					err = __check_input_term(state, d->bCSourceID, term);
 					if (err < 0)
 						return err;
 			case UAC2_CLOCK_SELECTOR: {
 				struct uac_selector_unit_descriptor *d = p1;
 				/* call recursively to retrieve the channel info */
-				err = check_input_term(state, d->baSourceID[0], term);
+				err = __check_input_term(state, d->baSourceID[0], term);
 				if (err < 0)
 					return err;
 				term->type = UAC3_SELECTOR_UNIT << 16; /* virtual type */
 				/* call recursively to verify that the
 				 * referenced clock entity is valid */
-				err = check_input_term(state, d->bCSourceID, term);
+				err = __check_input_term(state, d->bCSourceID, term);
 				if (err < 0)
 					return err;
 			case UAC3_CLOCK_SELECTOR: {
 				struct uac_selector_unit_descriptor *d = p1;
 				/* call recursively to retrieve the channel info */
-				err = check_input_term(state, d->baSourceID[0], term);
+				err = __check_input_term(state, d->baSourceID[0], term);
 				if (err < 0)
 					return err;
 				term->type = UAC3_SELECTOR_UNIT << 16; /* virtual type */
 					return -EINVAL;
 				/* call recursively to retrieve the channel info */
-				err = check_input_term(state, d->baSourceID[0], term);
+				err = __check_input_term(state, d->baSourceID[0], term);
 				if (err < 0)
 					return err;
 	return -ENODEV;
 }
+static int check_input_term(struct mixer_build *state, int id,
+			    struct usb_audio_term *term)
+{
+	memset(term, 0, sizeof(*term));
+	memset(state->termbitmap, 0, sizeof(state->termbitmap));
+	return __check_input_term(state, id, term);
+}
 /*
  * Feature Unit
  */

sound/usb/stream.c+1−0

@@ -1043,6 +1043,7 @@ found_clock: · 1042 unmodified lines
1043		1043
1044	pd = kzalloc(sizeof(*pd), GFP_KERNEL);	1044	pd = kzalloc(sizeof(*pd), GFP_KERNEL);
1045	if (!pd) {	1045	if (!pd) {
		1046	kfree(fp->chmap);
1046	kfree(fp->rate_table);	1047	kfree(fp->rate_table);
1047	kfree(fp);	1048	kfree(fp);
1048	return NULL;	1049	return NULL;

tools/bpf/bpftool/common.c+6−2

 	if (err)
 		return err;
-	return bpf_obj_pin(fd, name);
+	err = bpf_obj_pin(fd, name);
+	if (err)
+		p_err("can't pin the object (%s): %s", name, strerror(errno));
+	return err;
 }
 int do_pin_any(int argc, char **argv, int (*get_fd_by_id)(__u32))
 	fd = get_fd_by_id(id);
 	if (fd < 0) {
-		p_err("can't get prog by id (%u): %s", id, strerror(errno));
+		p_err("can't open object by id (%u): %s", id, strerror(errno));
 		return -1;
 	}

tools/hv/hv_get_dhcp_info.sh+1−1

@@ -13,7 +13,7 @@ · 12 unmodified lines
13	# the script prints the string "Disabled" to stdout.	13	# the script prints the string "Disabled" to stdout.
14	#	14	#
15	# Each Distro is expected to implement this script in a distro specific	15	# Each Distro is expected to implement this script in a distro specific
16	# fashion. For instance on Distros that ship with Network Manager enabled,	16	# fashion. For instance, on Distros that ship with Network Manager enabled,
17	# this script can be based on the Network Manager APIs for retrieving DHCP	17	# this script can be based on the Network Manager APIs for retrieving DHCP
18	# information.	18	# information.
19		19

tools/hv/hv_kvp_daemon.c+5−3

 	/*
-	 * Gather the DNS  state.
+	 * Gather the DNS state.
 	 * Since there is no standard way to get this information
 	 * across various distributions of interest; we just invoke
 	 * an external script that needs to be ported across distros
 	char *start;
 	/*
-	 * in_buf has sequence of characters that are seperated by
+	 * in_buf has sequence of characters that are separated by
 	 * the character ';'. The last sequence does not have the
 	 * terminating ";" character.
 	 */
 			daemonize = 0;
 			break;
 		case 'h':
+			print_usage(argv);
+			exit(0);
 		default:
 			print_usage(argv);
 			exit(EXIT_FAILURE);
 		case KVP_OP_GET_IP_INFO:
 			kvp_ip_val = &hv_msg->body.kvp_ip_val;
-			error =  kvp_mac_to_ip(kvp_ip_val);
+			error = kvp_mac_to_ip(kvp_ip_val);
 			if (error)
 				hv_msg->error = error;

tools/hv/hv_set_ifconfig.sh+1−1

@@ -12,7 +12,7 @@ · 11 unmodified lines
12	# be used to configure the interface.	12	# be used to configure the interface.
13	#	13	#
14	# Each Distro is expected to implement this script in a distro specific	14	# Each Distro is expected to implement this script in a distro specific
15	# fashion. For instance on Distros that ship with Network Manager enabled,	15	# fashion. For instance, on Distros that ship with Network Manager enabled,
16	# this script can be based on the Network Manager APIs for configuring the	16	# this script can be based on the Network Manager APIs for configuring the
17	# interface.	17	# interface.
18	#	18	#

tools/hv/hv_vss_daemon.c+3−1

 	 * If a partition is mounted more than once, only the first
 	 * FREEZE/THAW can succeed and the later ones will get
 	 * EBUSY/EINVAL respectively: there could be 2 cases:
-	 * 1) a user may mount the same partition to differnt directories
+	 * 1) a user may mount the same partition to different directories
 	 *  by mistake or on purpose;
 	 * 2) The subvolume of btrfs appears to have the same partition
 	 * mounted more than once.
 			daemonize = 0;
 			break;
 		case 'h':
+			print_usage(argv);
+			exit(0);
 		default:
 			print_usage(argv);
 			exit(EXIT_FAILURE);

tools/hv/lsvmbus+42−33

@@ -4,10 +4,10 @@ · 3 unmodified lines
4	import os	4	import os
5	from optparse import OptionParser	5	from optparse import OptionParser
6		6
		7	help_msg = "print verbose messages. Try -vv, -vvv for more verbose messages"
7	parser = OptionParser()	8	parser = OptionParser()
8	parser.add_option("-v", "--verbose", dest="verbose",	9	parser.add_option(
9	help="print verbose messages. Try -vv, -vvv for \	10	"-v", "--verbose", dest="verbose", help=help_msg, action="count")
10	more verbose messages", action="count")
11		11
12	(options, args) = parser.parse_args()	12	(options, args) = parser.parse_args()
13		13
@@ -21,27 +21,28 @@ if not os.path.isdir(vmbus_sys_path): · 7 unmodified lines
21	exit(-1)	21	exit(-1)
22		22
23	vmbus_dev_dict = {	23	vmbus_dev_dict = {
24	'{0e0b6031-5213-4934-818b-38d90ced39db}' : '[Operating system shutdown]',	24	'{0e0b6031-5213-4934-818b-38d90ced39db}': '[Operating system shutdown]',
25	'{9527e630-d0ae-497b-adce-e80ab0175caf}' : '[Time Synchronization]',	25	'{9527e630-d0ae-497b-adce-e80ab0175caf}': '[Time Synchronization]',
26	'{57164f39-9115-4e78-ab55-382f3bd5422d}' : '[Heartbeat]',	26	'{57164f39-9115-4e78-ab55-382f3bd5422d}': '[Heartbeat]',
27	'{a9a0f4e7-5a45-4d96-b827-8a841e8c03e6}' : '[Data Exchange]',	27	'{a9a0f4e7-5a45-4d96-b827-8a841e8c03e6}': '[Data Exchange]',
28	'{35fa2e29-ea23-4236-96ae-3a6ebacba440}' : '[Backup (volume checkpoint)]',	28	'{35fa2e29-ea23-4236-96ae-3a6ebacba440}': '[Backup (volume checkpoint)]',
29	'{34d14be3-dee4-41c8-9ae7-6b174977c192}' : '[Guest services]',	29	'{34d14be3-dee4-41c8-9ae7-6b174977c192}': '[Guest services]',
30	'{525074dc-8985-46e2-8057-a307dc18a502}' : '[Dynamic Memory]',	30	'{525074dc-8985-46e2-8057-a307dc18a502}': '[Dynamic Memory]',
31	'{cfa8b69e-5b4a-4cc0-b98b-8ba1a1f3f95a}' : 'Synthetic mouse',	31	'{cfa8b69e-5b4a-4cc0-b98b-8ba1a1f3f95a}': 'Synthetic mouse',
32	'{f912ad6d-2b17-48ea-bd65-f927a61c7684}' : 'Synthetic keyboard',	32	'{f912ad6d-2b17-48ea-bd65-f927a61c7684}': 'Synthetic keyboard',
33	'{da0a7802-e377-4aac-8e77-0558eb1073f8}' : 'Synthetic framebuffer adapter',	33	'{da0a7802-e377-4aac-8e77-0558eb1073f8}': 'Synthetic framebuffer adapter',
34	'{f8615163-df3e-46c5-913f-f2d2f965ed0e}' : 'Synthetic network adapter',	34	'{f8615163-df3e-46c5-913f-f2d2f965ed0e}': 'Synthetic network adapter',
35	'{32412632-86cb-44a2-9b5c-50d1417354f5}' : 'Synthetic IDE Controller',	35	'{32412632-86cb-44a2-9b5c-50d1417354f5}': 'Synthetic IDE Controller',
36	'{ba6163d9-04a1-4d29-b605-72e2ffb1dc7f}' : 'Synthetic SCSI Controller',	36	'{ba6163d9-04a1-4d29-b605-72e2ffb1dc7f}': 'Synthetic SCSI Controller',
37	'{2f9bcc4a-0069-4af3-b76b-6fd0be528cda}' : 'Synthetic fiber channel adapter',	37	'{2f9bcc4a-0069-4af3-b76b-6fd0be528cda}': 'Synthetic fiber channel adapter',
38	'{8c2eaf3d-32a7-4b09-ab99-bd1f1c86b501}' : 'Synthetic RDMA adapter',	38	'{8c2eaf3d-32a7-4b09-ab99-bd1f1c86b501}': 'Synthetic RDMA adapter',
39	'{44c4f61d-4444-4400-9d52-802e27ede19f}' : 'PCI Express pass-through',	39	'{44c4f61d-4444-4400-9d52-802e27ede19f}': 'PCI Express pass-through',
40	'{276aacf4-ac15-426c-98dd-7521ad3f01fe}' : '[Reserved system device]',	40	'{276aacf4-ac15-426c-98dd-7521ad3f01fe}': '[Reserved system device]',
41	'{f8e65716-3cb3-4a06-9a60-1889c5cccab5}' : '[Reserved system device]',	41	'{f8e65716-3cb3-4a06-9a60-1889c5cccab5}': '[Reserved system device]',
42	'{3375baf4-9e15-4b30-b765-67acb10d607b}' : '[Reserved system device]',	42	'{3375baf4-9e15-4b30-b765-67acb10d607b}': '[Reserved system device]',
43	}	43	}
44		44
		45
45	def get_vmbus_dev_attr(dev_name, attr):	46	def get_vmbus_dev_attr(dev_name, attr):
46	try:	47	try:
47	f = open('%s/%s/%s' % (vmbus_sys_path, dev_name, attr), 'r')	48	f = open('%s/%s/%s' % (vmbus_sys_path, dev_name, attr), 'r')
@@ -52,6 +53,7 @@ def get_vmbus_dev_attr(dev_name, attr): · 4 unmodified lines
52		53
53	return lines	54	return lines
54		55
		56
55	class VMBus_Dev:	57	class VMBus_Dev:
56	pass	58	pass
57		59
@@ -66,12 +68,13 @@ for f in os.listdir(vmbus_sys_path): · 8 unmodified lines
66		68
67	chn_vp_mapping = get_vmbus_dev_attr(f, 'channel_vp_mapping')	69	chn_vp_mapping = get_vmbus_dev_attr(f, 'channel_vp_mapping')
68	chn_vp_mapping = [c.strip() for c in chn_vp_mapping]	70	chn_vp_mapping = [c.strip() for c in chn_vp_mapping]
69	chn_vp_mapping = sorted(chn_vp_mapping,	71	chn_vp_mapping = sorted(
70	key = lambda c : int(c.split(':')[0]))	72	chn_vp_mapping, key=lambda c: int(c.split(':')[0]))
71		73
72	chn_vp_mapping = ['\tRel_ID=%s, target_cpu=%s' %	74	chn_vp_mapping = [
73	(c.split(':')[0], c.split(':')[1])	75	'\tRel_ID=%s, target_cpu=%s' %
74	for c in chn_vp_mapping]	76	(c.split(':')[0], c.split(':')[1]) for c in chn_vp_mapping
		77	]
75	d = VMBus_Dev()	78	d = VMBus_Dev()
76	d.sysfs_path = '%s/%s' % (vmbus_sys_path, f)	79	d.sysfs_path = '%s/%s' % (vmbus_sys_path, f)
77	d.vmbus_id = vmbus_id	80	d.vmbus_id = vmbus_id
@@ -85,7 +88,7 @@ for f in os.listdir(vmbus_sys_path): · 7 unmodified lines
85	vmbus_dev_list.append(d)	88	vmbus_dev_list.append(d)
86		89
87		90
88	vmbus_dev_list = sorted(vmbus_dev_list, key = lambda d : int(d.vmbus_id))	91	vmbus_dev_list = sorted(vmbus_dev_list, key=lambda d: int(d.vmbus_id))
89		92
90	format0 = '%2s: %s'	93	format0 = '%2s: %s'
91	format1 = '%2s: Class_ID = %s - %s\n%s'	94	format1 = '%2s: Class_ID = %s - %s\n%s'
@@ -95,9 +98,15 @@ for d in vmbus_dev_list: · 3 unmodified lines
95	if verbose == 0:	98	if verbose == 0:
96	print(('VMBUS ID ' + format0) % (d.vmbus_id, d.dev_desc))	99	print(('VMBUS ID ' + format0) % (d.vmbus_id, d.dev_desc))
97	elif verbose == 1:	100	elif verbose == 1:
98	print (('VMBUS ID ' + format1) % \	101	print(
99	(d.vmbus_id, d.class_id, d.dev_desc, d.chn_vp_mapping))	102	('VMBUS ID ' + format1) %
		103	(d.vmbus_id, d.class_id, d.dev_desc, d.chn_vp_mapping)
		104	)
100	else:	105	else:
101	print (('VMBUS ID ' + format2) % \	106	print(
102	(d.vmbus_id, d.class_id, d.dev_desc, \	107	('VMBUS ID ' + format2) %
103	d.device_id, d.sysfs_path, d.chn_vp_mapping))	108	(
		109	d.vmbus_id, d.class_id, d.dev_desc,
		110	d.device_id, d.sysfs_path, d.chn_vp_mapping
		111	)
		112	)

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

@@ -1467,8 +1467,8 @@ union bpf_attr { · 1466 unmodified lines
1467	* If no cookie has been set yet, generate a new cookie. Once	1467	* If no cookie has been set yet, generate a new cookie. Once
1468	* generated, the socket cookie remains stable for the life of the	1468	* generated, the socket cookie remains stable for the life of the
1469	* socket. This helper can be useful for monitoring per socket	1469	* socket. This helper can be useful for monitoring per socket
1470	* networking traffic statistics as it provides a unique socket	1470	* networking traffic statistics as it provides a global socket
1471	* identifier per namespace.	1471	* identifier that can be assumed unique.
1472	* Return	1472	* Return
1473	* A 8-byte long non-decreasing number on success, or 0 if the	1473	* A 8-byte long non-decreasing number on success, or 0 if the
1474	* socket field is missing inside skb.	1474	* socket field is missing inside skb.

tools/lib/bpf/libbpf.c+18−15

@@ -187,7 +187,6 @@ struct bpf_program { · 186 unmodified lines
187	bpf_program_clear_priv_t clear_priv;	187	bpf_program_clear_priv_t clear_priv;
188		188
189	enum bpf_attach_type expected_attach_type;	189	enum bpf_attach_type expected_attach_type;
190	int btf_fd;
191	void *func_info;	190	void *func_info;
192	__u32 func_info_rec_size;	191	__u32 func_info_rec_size;
193	__u32 func_info_cnt;	192	__u32 func_info_cnt;
@@ -318,7 +317,6 @@ void bpf_program__unload(struct bpf_program *prog) · 124 unmodified lines
318	prog->instances.nr = -1;	317	prog->instances.nr = -1;
319	zfree(&prog->instances.fds);	318	zfree(&prog->instances.fds);
320		319
321	zclose(prog->btf_fd);
322	zfree(&prog->func_info);	320	zfree(&prog->func_info);
323	zfree(&prog->line_info);	321	zfree(&prog->line_info);
324	}	322	}
@@ -397,7 +395,6 @@ bpf_program__init(void data, size_t size, char section_name, int idx, · 72 unmodified lines
397	prog->instances.fds = NULL;	395	prog->instances.fds = NULL;
398	prog->instances.nr = -1;	396	prog->instances.nr = -1;
399	prog->type = BPF_PROG_TYPE_UNSPEC;	397	prog->type = BPF_PROG_TYPE_UNSPEC;
400	prog->btf_fd = -1;
401		398
402	return 0;	399	return 0;
403	errout:	400	errout:
@@ -2296,9 +2293,6 @@ bpf_program_reloc_btf_ext(struct bpf_program prog, struct bpf_object obj, · 1892 unmodified lines
2296	prog->line_info_rec_size = btf_ext__line_info_rec_size(obj->btf_ext);	2293	prog->line_info_rec_size = btf_ext__line_info_rec_size(obj->btf_ext);
2297	}	2294	}
2298		2295
2299	if (!insn_offset)
2300	prog->btf_fd = btf__fd(obj->btf);
2301
2302	return 0;	2296	return 0;
2303	}	2297	}
2304		2298
@@ -3366,7 +3360,7 @@ load_program(struct bpf_program prog, struct bpf_insn insns, int insns_cnt, · 1061 unmodified lines
3366	char *cp, errmsg[STRERR_BUFSIZE];	3360	char *cp, errmsg[STRERR_BUFSIZE];
3367	int log_buf_size = BPF_LOG_BUF_SIZE;	3361	int log_buf_size = BPF_LOG_BUF_SIZE;
3368	char *log_buf;	3362	char *log_buf;
3369	int ret;	3363	int btf_fd, ret;
3370		3364
3371	if (!insns \|\| !insns_cnt)	3365	if (!insns \|\| !insns_cnt)
3372	return -EINVAL;	3366	return -EINVAL;
@@ -3381,7 +3375,12 @@ load_program(struct bpf_program prog, struct bpf_insn insns, int insns_cnt, · 8 unmodified lines
3381	load_attr.license = license;	3375	load_attr.license = license;
3382	load_attr.kern_version = kern_version;	3376	load_attr.kern_version = kern_version;
3383	load_attr.prog_ifindex = prog->prog_ifindex;	3377	load_attr.prog_ifindex = prog->prog_ifindex;
3384	load_attr.prog_btf_fd = prog->btf_fd >= 0 ? prog->btf_fd : 0;	3378	/* if .BTF.ext was loaded, kernel supports associated BTF for prog */
		3379	if (prog->obj->btf_ext)
		3380	btf_fd = bpf_object__btf_fd(prog->obj);
		3381	else
		3382	btf_fd = -1;
		3383	load_attr.prog_btf_fd = btf_fd >= 0 ? btf_fd : 0;
3385	load_attr.func_info = prog->func_info;	3384	load_attr.func_info = prog->func_info;
3386	load_attr.func_info_rec_size = prog->func_info_rec_size;	3385	load_attr.func_info_rec_size = prog->func_info_rec_size;
3387	load_attr.func_info_cnt = prog->func_info_cnt;	3386	load_attr.func_info_cnt = prog->func_info_cnt;
@@ -5903,13 +5902,15 @@ int libbpf_num_possible_cpus(void) · 2515 unmodified lines
5903	static const char *fcpu = "/sys/devices/system/cpu/possible";	5902	static const char *fcpu = "/sys/devices/system/cpu/possible";
5904	int len = 0, n = 0, il = 0, ir = 0;	5903	int len = 0, n = 0, il = 0, ir = 0;
5905	unsigned int start = 0, end = 0;	5904	unsigned int start = 0, end = 0;
		5905	int tmp_cpus = 0;
5906	static int cpus;	5906	static int cpus;
5907	char buf[128];	5907	char buf[128];
5908	int error = 0;	5908	int error = 0;
5909	int fd = -1;	5909	int fd = -1;
5910		5910
5911	if (cpus > 0)	5911	tmp_cpus = READ_ONCE(cpus);
5912	return cpus;	5912	if (tmp_cpus > 0)
		5913	return tmp_cpus;
5913		5914
5914	fd = open(fcpu, O_RDONLY);	5915	fd = open(fcpu, O_RDONLY);
5915	if (fd < 0) {	5916	if (fd < 0) {
@@ -5932,7 +5933,7 @@ int libbpf_num_possible_cpus(void) · 16 unmodified lines
5932	}	5933	}
5933	buf[len] = '\0';	5934	buf[len] = '\0';
5934		5935
5935	for (ir = 0, cpus = 0; ir <= len; ir++) {	5936	for (ir = 0, tmp_cpus = 0; ir <= len; ir++) {
5936	/* Each sub string separated by ',' has format \d+-\d+ or \d+ */	5937	/* Each sub string separated by ',' has format \d+-\d+ or \d+ */
5937	if (buf[ir] == ',' \|\| buf[ir] == '\0') {	5938	if (buf[ir] == ',' \|\| buf[ir] == '\0') {
5938	buf[ir] = '\0';	5939	buf[ir] = '\0';
@@ -5944,13 +5945,15 @@ int libbpf_num_possible_cpus(void) · 5 unmodified lines
5944	} else if (n == 1) {	5945	} else if (n == 1) {
5945	end = start;	5946	end = start;
5946	}	5947	}
5947	cpus += end - start + 1;	5948	tmp_cpus += end - start + 1;
5948	il = ir + 1;	5949	il = ir + 1;
5949	}	5950	}
5950	}	5951	}
5951	if (cpus <= 0) {	5952	if (tmp_cpus <= 0) {
5952	pr_warning("Invalid #CPUs %d from %s\n", cpus, fcpu);	5953	pr_warning("Invalid #CPUs %d from %s\n", tmp_cpus, fcpu);
5953	return -EINVAL;	5954	return -EINVAL;
5954	}	5955	}
5955	return cpus;	5956
		5957	WRITE_ONCE(cpus, tmp_cpus);
		5958	return tmp_cpus;
5956	}	5959	}

tools/perf/Documentation/Makefile+1−1

@@ -242,7 +242,7 @@ $(OUTPUT)doc.dep : $(wildcard *.txt) build-docdep.perl · 241 unmodified lines
242	$(PERL_PATH) ./build-docdep.perl >$@+ $(QUIET_STDERR) && \	242	$(PERL_PATH) ./build-docdep.perl >$@+ $(QUIET_STDERR) && \
243	mv $@+ $@	243	mv $@+ $@
244		244
245	-include $(OUPTUT)doc.dep	245	-include $(OUTPUT)doc.dep
246		246
247	_cmds_txt = cmds-ancillaryinterrogators.txt \	247	_cmds_txt = cmds-ancillaryinterrogators.txt \
248	cmds-ancillarymanipulators.txt \	248	cmds-ancillarymanipulators.txt \

tools/perf/arch/s390/util/machine.c+30−1

@@ -6,8 +6,9 @@ · 5 unmodified lines
6	#include "machine.h"	6	#include "machine.h"
7	#include "api/fs/fs.h"	7	#include "api/fs/fs.h"
8	#include "debug.h"	8	#include "debug.h"
		9	#include "symbol.h"
9		10
10	int arch__fix_module_text_start(u64 start, const char name)	11	int arch__fix_module_text_start(u64 start, u64 size, const char *name)
11	{	12	{
12	u64 m_start = *start;	13	u64 m_start = *start;
13	char path[PATH_MAX];	14	char path[PATH_MAX];
@@ -17,7 +18,35 @@ int arch__fix_module_text_start(u64 start, const char name) · 3 unmodified lines
17	if (sysfs__read_ull(path, (unsigned long long *)start) < 0) {	18	if (sysfs__read_ull(path, (unsigned long long *)start) < 0) {
18	pr_debug2("Using module %s start:%#lx\n", path, m_start);	19	pr_debug2("Using module %s start:%#lx\n", path, m_start);
19	*start = m_start;	20	*start = m_start;
		21	} else {
		22	/* Successful read of the modules segment text start address.
		23	* Calculate difference between module start address
		24	* in memory and module text segment start address.
		25	* For example module load address is 0x3ff8011b000
		26	* (from /proc/modules) and module text segment start
		27	* address is 0x3ff8011b870 (from file above).
		28	*
		29	* Adjust the module size and subtract the GOT table
		30	* size located at the beginning of the module.
		31	*/
		32	size -= (start - m_start);
20	}	33	}
21		34
22	return 0;	35	return 0;
23	}	36	}
		37
		38	/* On s390 kernel text segment start is located at very low memory addresses,
		39	* for example 0x10000. Modules are located at very high memory addresses,
		40	* for example 0x3ff xxxx xxxx. The gap between end of kernel text segment
		41	* and beginning of first module's text segment is very big.
		42	* Therefore do not fill this gap and do not assign it to the kernel dso map.
		43	*/
		44	void arch__symbols__fixup_end(struct symbol p, struct symbol c)
		45	{
		46	if (strchr(p->name, '[') == NULL && strchr(c->name, '['))
		47	/* Last kernel symbol mapped to end of page */
		48	p->end = roundup(p->end, page_size);
		49	else
		50	p->end = c->start;
		51	pr_debug4("%s sym:%s end:%#lx\n", __func__, p->name, p->end);
		52	}

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

@@ -379,8 +379,10 @@ static u8 *alloc_data(ssize_t bytes0, int map_flags, · 378 unmodified lines
379		379
380	/* Allocate and initialize all memory on CPU#0: */	380	/* Allocate and initialize all memory on CPU#0: */
381	if (init_cpu0) {	381	if (init_cpu0) {
382	orig_mask = bind_to_node(0);	382	int node = numa_node_of_cpu(0);
383	bind_to_memnode(0);	383
		384	orig_mask = bind_to_node(node);
		385	bind_to_memnode(node);
384	}	386	}
385		387
386	bytes = bytes0 + HPSIZE;	388	bytes = bytes0 + HPSIZE;

tools/perf/builtin-ftrace.c+1−1

@@ -173,7 +173,7 @@ static int set_tracing_cpumask(struct cpu_map *cpumap) · 172 unmodified lines
173	int last_cpu;	173	int last_cpu;
174		174
175	last_cpu = cpu_map__cpu(cpumap, cpumap->nr - 1);	175	last_cpu = cpu_map__cpu(cpumap, cpumap->nr - 1);
176	mask_size = (last_cpu + 3) / 4 + 1;	176	mask_size = last_cpu / 4 + 2; /* one more byte for EOS */
177	mask_size += last_cpu / 32; /* ',' is needed for every 32th cpus */	177	mask_size += last_cpu / 32; /* ',' is needed for every 32th cpus */
178		178
179	cpumask = malloc(mask_size);	179	cpumask = malloc(mask_size);

tools/perf/pmu-events/jevents.c+1−0

@@ -453,6 +453,7 @@ static struct fixed { · 452 unmodified lines
453	{ "inst_retired.any_p", "event=0xc0" },	453	{ "inst_retired.any_p", "event=0xc0" },
454	{ "cpu_clk_unhalted.ref", "event=0x0,umask=0x03" },	454	{ "cpu_clk_unhalted.ref", "event=0x0,umask=0x03" },
455	{ "cpu_clk_unhalted.thread", "event=0x3c" },	455	{ "cpu_clk_unhalted.thread", "event=0x3c" },
		456	{ "cpu_clk_unhalted.core", "event=0x3c" },
456	{ "cpu_clk_unhalted.thread_any", "event=0x3c,any=1" },	457	{ "cpu_clk_unhalted.thread_any", "event=0x3c,any=1" },
457	{ NULL, NULL},	458	{ NULL, NULL},
458	};	459	};

tools/perf/ui/browser.c+5−4

 // SPDX-License-Identifier: GPL-2.0
-#include "../string2.h"
+#include "../util/util.h"
-#include "../config.h"
+#include "../util/string2.h"
-#include "../../perf.h"
+#include "../util/config.h"
+#include "../perf.h"
 #include "libslang.h"
 #include "ui.h"
 #include "util.h"
 #include "browser.h"
 #include "helpline.h"
 #include "keysyms.h"
-#include "../color.h"
+#include "../util/color.h"
 #include <linux/ctype.h>
 #include <linux/zalloc.h>

tools/perf/ui/tui/progress.c+1−1

@@ -1,6 +1,6 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	#include <linux/kernel.h>	2	#include <linux/kernel.h>
3	#include "../cache.h"	3	#include "../../util/cache.h"
4	#include "../progress.h"	4	#include "../progress.h"
5	#include "../libslang.h"	5	#include "../libslang.h"
6	#include "../ui.h"	6	#include "../ui.h"

tools/perf/util/annotate.c+1−1

@@ -1122,7 +1122,7 @@ static int disasm_line__parse(char line, const char namep, char *rawp) · 1121 unmodified lines
1122	goto out;	1122	goto out;
1123		1123
1124	(*rawp)[0] = tmp;	1124	(*rawp)[0] = tmp;
1125	rawp = skip_spaces(rawp);	1125	rawp = strim(rawp);
1126		1126
1127	return 0;	1127	return 0;
1128		1128

tools/perf/util/cpumap.c+4−1

 	unsigned char *bitmap;
 	int last_cpu = cpu_map__cpu(map, map->nr - 1);
-	bitmap = zalloc((last_cpu + 7) / 8);
+	if (buf == NULL)
+		return 0;
+	bitmap = zalloc(last_cpu / 8 + 1);
 	if (bitmap == NULL) {
 		buf[0] = '\0';
 		return 0;

tools/perf/util/machine.c+2−1

 	return map_groups__set_modules_path_dir(&machine->kmaps, modules_path, 0);
 }
 int __weak arch__fix_module_text_start(u64 *start __maybe_unused,
+				u64 *size __maybe_unused,
 				const char *name __maybe_unused)
 {
 	return 0;
 	struct machine *machine = arg;
 	struct map *map;
-	if (arch__fix_module_text_start(&start, name) < 0)
+	if (arch__fix_module_text_start(&start, &size, name) < 0)
 		return -1;
 	map = machine__findnew_module_map(machine, start, name);

tools/perf/util/machine.h+1−1

@@ -222,7 +222,7 @@ struct symbol machine__find_kernel_symbol_by_name(struct machine machine, · 221 unmodified lines
222		222
223	struct map machine__findnew_module_map(struct machine machine, u64 start,	223	struct map machine__findnew_module_map(struct machine machine, u64 start,
224	const char *filename);	224	const char *filename);
225	int arch__fix_module_text_start(u64 start, const char name);	225	int arch__fix_module_text_start(u64 start, u64 size, const char *name);
226		226
227	int machine__load_kallsyms(struct machine machine, const char filename);	227	int machine__load_kallsyms(struct machine machine, const char filename);
228		228

tools/perf/util/symbol.c+6−1

 	return tail - str;
 }
+void __weak arch__symbols__fixup_end(struct symbol *p, struct symbol *c)
+{
+	p->end = c->start;
+}
 const char * __weak arch__normalize_symbol_name(const char *name)
 {
 	return name;
 		curr = rb_entry(nd, struct symbol, rb_node);
 		if (prev->end == prev->start && prev->end != curr->start)
-			prev->end = curr->start;
+			arch__symbols__fixup_end(prev, curr);
 	}
 	/* Last entry */

tools/perf/util/symbol.h+1−0

@@ -288,6 +288,7 @@ const char arch__normalize_symbol_name(const char name); · 287 unmodified lines
288	#define SYMBOL_A 0	288	#define SYMBOL_A 0
289	#define SYMBOL_B 1	289	#define SYMBOL_B 1
290		290
		291	void arch__symbols__fixup_end(struct symbol p, struct symbol c);
291	int arch__compare_symbol_names(const char namea, const char nameb);	292	int arch__compare_symbol_names(const char namea, const char nameb);
292	int arch__compare_symbol_names_n(const char namea, const char nameb,	293	int arch__compare_symbol_names_n(const char namea, const char nameb,
293	unsigned int n);	294	unsigned int n);

tools/perf/util/thread.c+11−1

 struct comm *thread__exec_comm(const struct thread *thread)
 {
-	struct comm *comm, *last = NULL;
+	struct comm *comm, *last = NULL, *second_last = NULL;
 	list_for_each_entry(comm, &thread->comm_list, list) {
 		if (comm->exec)
 			return comm;
+		second_last = last;
 		last = comm;
 	}
+	/*
+	 * 'last' with no start time might be the parent's comm of a synthesized
+	 * thread (created by processing a synthesized fork event). For a main
+	 * thread, that is very probably wrong. Prefer a later comm to avoid
+	 * that case.
+	 */
+	if (second_last && !last->start && thread->pid_ == thread->tid)
+		return second_last;
 	return last;
 }

tools/testing/selftests/bpf/verifier/loops1.c+28−0

@@ -159,3 +159,31 @@ · 158 unmodified lines
159	.errstr = "loop detected",	159	.errstr = "loop detected",
160	.prog_type = BPF_PROG_TYPE_TRACEPOINT,	160	.prog_type = BPF_PROG_TYPE_TRACEPOINT,
161	},	161	},
		162	{
		163	"not-taken loop with back jump to 1st insn",
		164	.insns = {
		165	BPF_MOV64_IMM(BPF_REG_0, 123),
		166	BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 4, -2),
		167	BPF_EXIT_INSN(),
		168	},
		169	.result = ACCEPT,
		170	.prog_type = BPF_PROG_TYPE_XDP,
		171	.retval = 123,
		172	},
		173	{
		174	"taken loop with back jump to 1st insn",
		175	.insns = {
		176	BPF_MOV64_IMM(BPF_REG_1, 10),
		177	BPF_MOV64_IMM(BPF_REG_2, 0),
		178	BPF_RAW_INSN(BPF_JMP \| BPF_CALL, 0, 1, 0, 1),
		179	BPF_EXIT_INSN(),
		180	BPF_ALU64_REG(BPF_ADD, BPF_REG_2, BPF_REG_1),
		181	BPF_ALU64_IMM(BPF_SUB, BPF_REG_1, 1),
		182	BPF_JMP_IMM(BPF_JNE, BPF_REG_1, 0, -3),
		183	BPF_MOV64_REG(BPF_REG_0, BPF_REG_2),
		184	BPF_EXIT_INSN(),
		185	},
		186	.result = ACCEPT,
		187	.prog_type = BPF_PROG_TYPE_XDP,
		188	.retval = 55,
		189	},

tools/testing/selftests/kvm/.gitignore+2−1

+/s390x/sync_regs_test
 /x86_64/cr4_cpuid_sync_test
 /x86_64/evmcs_test
 /x86_64/hyperv_cpuid
-/x86_64/kvm_create_max_vcpus
 /x86_64/mmio_warning_test
 /x86_64/platform_info_test
 /x86_64/set_sregs_test
 /x86_64/vmx_tsc_adjust_test
 /clear_dirty_log_test
 /dirty_log_test
+/kvm_create_max_vcpus

tools/testing/selftests/kvm/config+3−0

@@ -0,0 +1,3 @@
	1	CONFIG_KVM=y
	2	CONFIG_KVM_INTEL=y
	3	CONFIG_KVM_AMD=y

tools/testing/selftests/net/tcp_fastopen_backup_key.sh+1−1

@@ -30,7 +30,7 @@ do_test() { · 29 unmodified lines
30	ip netns exec "${NETNS}" ./tcp_fastopen_backup_key "$1"	30	ip netns exec "${NETNS}" ./tcp_fastopen_backup_key "$1"
31	val=$(ip netns exec "${NETNS}" nstat -az \| \	31	val=$(ip netns exec "${NETNS}" nstat -az \| \
32	grep TcpExtTCPFastOpenPassiveFail \| awk '{print $2}')	32	grep TcpExtTCPFastOpenPassiveFail \| awk '{print $2}')
33	if [ $val -ne 0 ]; then	33	if [ "$val" != 0 ]; then
34	echo "FAIL: TcpExtTCPFastOpenPassiveFail non-zero"	34	echo "FAIL: TcpExtTCPFastOpenPassiveFail non-zero"
35	return 1	35	return 1
36	fi	36	fi

tools/testing/selftests/netfilter/nft_flowtable.sh+48−0

@@ -321,4 +321,52 @@ else · 320 unmodified lines
321	ip netns exec nsr1 nft list ruleset	321	ip netns exec nsr1 nft list ruleset
322	fi	322	fi
323		323
		324	KEY_SHA="0x"$(ps -xaf \| sha1sum \| cut -d " " -f 1)
		325	KEY_AES="0x"$(ps -xaf \| md5sum \| cut -d " " -f 1)
		326	SPI1=$RANDOM
		327	SPI2=$RANDOM
		328
		329	if [ $SPI1 -eq $SPI2 ]; then
		330	SPI2=$((SPI2+1))
		331	fi
		332
		333	do_esp() {
		334	local ns=$1
		335	local me=$2
		336	local remote=$3
		337	local lnet=$4
		338	local rnet=$5
		339	local spi_out=$6
		340	local spi_in=$7
		341
		342	ip -net $ns xfrm state add src $remote dst $me proto esp spi $spi_in enc aes $KEY_AES auth sha1 $KEY_SHA mode tunnel sel src $rnet dst $lnet
		343	ip -net $ns xfrm state add src $me dst $remote proto esp spi $spi_out enc aes $KEY_AES auth sha1 $KEY_SHA mode tunnel sel src $lnet dst $rnet
		344
		345	# to encrypt packets as they go out (includes forwarded packets that need encapsulation)
		346	ip -net $ns xfrm policy add src $lnet dst $rnet dir out tmpl src $me dst $remote proto esp mode tunnel priority 1 action allow
		347	# to fwd decrypted packets after esp processing:
		348	ip -net $ns xfrm policy add src $rnet dst $lnet dir fwd tmpl src $remote dst $me proto esp mode tunnel priority 1 action allow
		349
		350	}
		351
		352	do_esp nsr1 192.168.10.1 192.168.10.2 10.0.1.0/24 10.0.2.0/24 $SPI1 $SPI2
		353
		354	do_esp nsr2 192.168.10.2 192.168.10.1 10.0.2.0/24 10.0.1.0/24 $SPI2 $SPI1
		355
		356	ip netns exec nsr1 nft delete table ip nat
		357
		358	# restore default routes
		359	ip -net ns2 route del 192.168.10.1 via 10.0.2.1
		360	ip -net ns2 route add default via 10.0.2.1
		361	ip -net ns2 route add default via dead:2::1
		362
		363	test_tcp_forwarding ns1 ns2
		364	if [ $? -eq 0 ] ;then
		365	echo "PASS: ipsec tunnel mode for ns1/ns2"
		366	else
		367	echo "FAIL: ipsec tunnel mode for ns1/ns2"
		368	ip netns exec nsr1 nft list ruleset 1>&2
		369	ip netns exec nsr1 cat /proc/net/xfrm_stat 1>&2
		370	fi
		371
324	exit $ret	372	exit $ret

tools/testing/selftests/tc-testing/tc-tests/actions/skbedit.json+47−0

@@ -670,5 +670,52 @@ · 669 unmodified lines
670	"teardown": [	670	"teardown": [
671	"$TC actions flush action skbedit"	671	"$TC actions flush action skbedit"
672	]	672	]
		673	},
		674	{
		675	"id": "630c",
		676	"name": "Add batch of 32 skbedit actions with all parameters and cookie",
		677	"category": [
		678	"actions",
		679	"skbedit"
		680	],
		681	"setup": [
		682	[
		683	"$TC actions flush action skbedit",
		684	0,
		685	1,
		686	255
		687	]
		688	],
		689	"cmdUnderTest": "bash -c \"for i in \\`seq 1 32\\`; do cmd=\\\"action skbedit queue_mapping 2 priority 10 mark 7/0xaabbccdd ptype host inheritdsfield index \\$i cookie aabbccddeeff112233445566778800a1 \\\"; args=\"\\$args\\$cmd\"; done && $TC actions add \\$args\"",
		690	"expExitCode": "0",
		691	"verifyCmd": "$TC actions list action skbedit",
		692	"matchPattern": "^[ \t]+index [0-9]+ ref",
		693	"matchCount": "32",
		694	"teardown": [
		695	"$TC actions flush action skbedit"
		696	]
		697	},
		698	{
		699	"id": "706d",
		700	"name": "Delete batch of 32 skbedit actions with all parameters",
		701	"category": [
		702	"actions",
		703	"skbedit"
		704	],
		705	"setup": [
		706	[
		707	"$TC actions flush action skbedit",
		708	0,
		709	1,
		710	255
		711	],
		712	"bash -c \"for i in \\`seq 1 32\\`; do cmd=\\\"action skbedit queue_mapping 2 priority 10 mark 7/0xaabbccdd ptype host inheritdsfield index \\$i \\\"; args=\\\"\\$args\\$cmd\\\"; done && $TC actions add \\$args\""
		713	],
		714	"cmdUnderTest": "bash -c \"for i in \\`seq 1 32\\`; do cmd=\\\"action skbedit index \\$i \\\"; args=\"\\$args\\$cmd\"; done && $TC actions del \\$args\"",
		715	"expExitCode": "0",
		716	"verifyCmd": "$TC actions list action skbedit",
		717	"matchPattern": "^[ \t]+index [0-9]+ ref",
		718	"matchCount": "0",
		719	"teardown": []
673	}	720	}
674	]	721	]

virt/kvm/arm/arm.c+13−5

 	return ret;
 }
-bool kvm_arch_has_vcpu_debugfs(void)
-{
-	return false;
-}
 int kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu)
 {
 	return 0;
 void kvm_arch_vcpu_blocking(struct kvm_vcpu *vcpu)
 {
+	/*
+	 * If we're about to block (most likely because we've just hit a
+	 * WFI), we need to sync back the state of the GIC CPU interface
+	 * so that we have the lastest PMR and group enables. This ensures
+	 * that kvm_arch_vcpu_runnable has up-to-date data to decide
+	 * whether we have pending interrupts.
+	 */
+	preempt_disable();
+	kvm_vgic_vmcr_sync(vcpu);
+	preempt_enable();
 	kvm_vgic_v4_enable_doorbell(vcpu);
 }
 	/* Set up the timer */
 	kvm_timer_vcpu_init(vcpu);
+	kvm_pmu_vcpu_init(vcpu);
 	kvm_arm_reset_debug_ptr(vcpu);
 	return kvm_vgic_vcpu_init(vcpu);

virt/kvm/arm/hyp/vgic-v3-sr.c+8−0

 	case 7:
 		cpu_if->vgic_ap0r[3] = __vgic_v3_read_ap0rn(3);
 		cpu_if->vgic_ap0r[2] = __vgic_v3_read_ap0rn(2);
+		/* Fall through */
 	case 6:
 		cpu_if->vgic_ap0r[1] = __vgic_v3_read_ap0rn(1);
+		/* Fall through */
 	default:
 		cpu_if->vgic_ap0r[0] = __vgic_v3_read_ap0rn(0);
 	}
 	case 7:
 		cpu_if->vgic_ap1r[3] = __vgic_v3_read_ap1rn(3);
 		cpu_if->vgic_ap1r[2] = __vgic_v3_read_ap1rn(2);
+		/* Fall through */
 	case 6:
 		cpu_if->vgic_ap1r[1] = __vgic_v3_read_ap1rn(1);
+		/* Fall through */
 	default:
 		cpu_if->vgic_ap1r[0] = __vgic_v3_read_ap1rn(0);
 	}
 	case 7:
 		__vgic_v3_write_ap0rn(cpu_if->vgic_ap0r[3], 3);
 		__vgic_v3_write_ap0rn(cpu_if->vgic_ap0r[2], 2);
+		/* Fall through */
 	case 6:
 		__vgic_v3_write_ap0rn(cpu_if->vgic_ap0r[1], 1);
+		/* Fall through */
 	default:
 		__vgic_v3_write_ap0rn(cpu_if->vgic_ap0r[0], 0);
 	}
 	case 7:
 		__vgic_v3_write_ap1rn(cpu_if->vgic_ap1r[3], 3);
 		__vgic_v3_write_ap1rn(cpu_if->vgic_ap1r[2], 2);
+		/* Fall through */
 	case 6:
 		__vgic_v3_write_ap1rn(cpu_if->vgic_ap1r[1], 1);
+		/* Fall through */
 	default:
 		__vgic_v3_write_ap1rn(cpu_if->vgic_ap1r[0], 0);
 	}

virt/kvm/arm/pmu.c+15−3

 	kvm_pmu_release_perf_event(pmc);
 }
+/**
+ * kvm_pmu_vcpu_init - assign pmu counter idx for cpu
+ * @vcpu: The vcpu pointer
+ *
+ */
+void kvm_pmu_vcpu_init(struct kvm_vcpu *vcpu)
+{
+	int i;
+	struct kvm_pmu *pmu = &vcpu->arch.pmu;
+	for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i++)
+		pmu->pmc[i].idx = i;
+}
 /**
  * kvm_pmu_vcpu_reset - reset pmu state for cpu
  * @vcpu: The vcpu pointer
 	int i;
 	struct kvm_pmu *pmu = &vcpu->arch.pmu;
-	for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i++) {
+	for (i = 0; i < ARMV8_PMU_MAX_COUNTERS; i++)
 		kvm_pmu_stop_counter(vcpu, &pmu->pmc[i]);
-		pmu->pmc[i].idx = i;
-	}
 	bitmap_zero(vcpu->arch.pmu.chained, ARMV8_PMU_MAX_COUNTER_PAIRS);
 }

virt/kvm/arm/vgic/vgic-mmio.c+16−0

@@ -113,6 +113,22 @@ void vgic_mmio_write_senable(struct kvm_vcpu *vcpu, · 112 unmodified lines
113	struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);	113	struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
114		114
115	raw_spin_lock_irqsave(&irq->irq_lock, flags);	115	raw_spin_lock_irqsave(&irq->irq_lock, flags);
		116	if (vgic_irq_is_mapped_level(irq)) {
		117	bool was_high = irq->line_level;
		118
		119	/*
		120	* We need to update the state of the interrupt because
		121	* the guest might have changed the state of the device
		122	* while the interrupt was disabled at the VGIC level.
		123	*/
		124	irq->line_level = vgic_get_phys_line_level(irq);
		125	/*
		126	* Deactivate the physical interrupt so the GIC will let
		127	* us know when it is asserted again.
		128	*/
		129	if (!irq->active && was_high && !irq->line_level)
		130	vgic_irq_set_phys_active(irq, false);
		131	}
116	irq->enabled = true;	132	irq->enabled = true;
117	vgic_queue_irq_unlock(vcpu->kvm, irq, flags);	133	vgic_queue_irq_unlock(vcpu->kvm, irq, flags);
118		134

virt/kvm/arm/vgic/vgic-v2.c+8−1

 		       kvm_vgic_global_state.vctrl_base + GICH_APR);
 }
-void vgic_v2_put(struct kvm_vcpu *vcpu)
+void vgic_v2_vmcr_sync(struct kvm_vcpu *vcpu)
 {
 	struct vgic_v2_cpu_if *cpu_if = &vcpu->arch.vgic_cpu.vgic_v2;
 	cpu_if->vgic_vmcr = readl_relaxed(kvm_vgic_global_state.vctrl_base + GICH_VMCR);
+}
+void vgic_v2_put(struct kvm_vcpu *vcpu)
+{
+	struct vgic_v2_cpu_if *cpu_if = &vcpu->arch.vgic_cpu.vgic_v2;
+	vgic_v2_vmcr_sync(vcpu);
 	cpu_if->vgic_apr = readl_relaxed(kvm_vgic_global_state.vctrl_base + GICH_APR);
 }

virt/kvm/arm/vgic/vgic-v3.c+6−1

 		__vgic_v3_activate_traps(vcpu);
 }
-void vgic_v3_put(struct kvm_vcpu *vcpu)
+void vgic_v3_vmcr_sync(struct kvm_vcpu *vcpu)
 {
 	struct vgic_v3_cpu_if *cpu_if = &vcpu->arch.vgic_cpu.vgic_v3;
 	if (likely(cpu_if->vgic_sre))
 		cpu_if->vgic_vmcr = kvm_call_hyp_ret(__vgic_v3_read_vmcr);
+}
+void vgic_v3_put(struct kvm_vcpu *vcpu)
+{
+	vgic_v3_vmcr_sync(vcpu);
 	kvm_call_hyp(__vgic_v3_save_aprs, vcpu);

virt/kvm/arm/vgic/vgic.c+11−0

@@ -919,6 +919,17 @@ void kvm_vgic_put(struct kvm_vcpu *vcpu) · 918 unmodified lines
919	vgic_v3_put(vcpu);	919	vgic_v3_put(vcpu);
920	}	920	}
921		921
		922	void kvm_vgic_vmcr_sync(struct kvm_vcpu *vcpu)
		923	{
		924	if (unlikely(!irqchip_in_kernel(vcpu->kvm)))
		925	return;
		926
		927	if (kvm_vgic_global_state.type == VGIC_V2)
		928	vgic_v2_vmcr_sync(vcpu);
		929	else
		930	vgic_v3_vmcr_sync(vcpu);
		931	}
		932
922	int kvm_vgic_vcpu_pending_irq(struct kvm_vcpu *vcpu)	933	int kvm_vgic_vcpu_pending_irq(struct kvm_vcpu *vcpu)
923	{	934	{
924	struct vgic_cpu *vgic_cpu = &vcpu->arch.vgic_cpu;	935	struct vgic_cpu *vgic_cpu = &vcpu->arch.vgic_cpu;

virt/kvm/arm/vgic/vgic.h+2−0

 void vgic_v2_init_lrs(void);
 void vgic_v2_load(struct kvm_vcpu *vcpu);
 void vgic_v2_put(struct kvm_vcpu *vcpu);
+void vgic_v2_vmcr_sync(struct kvm_vcpu *vcpu);
 void vgic_v2_save_state(struct kvm_vcpu *vcpu);
 void vgic_v2_restore_state(struct kvm_vcpu *vcpu);
 void vgic_v3_load(struct kvm_vcpu *vcpu);
 void vgic_v3_put(struct kvm_vcpu *vcpu);
+void vgic_v3_vmcr_sync(struct kvm_vcpu *vcpu);
 bool vgic_has_its(struct kvm *kvm);
 int kvm_vgic_register_its_device(void);

virt/kvm/kvm_main.c+36−25

 	if (!kvm_is_reserved_pfn(pfn)) {
 		struct page *page = pfn_to_page(pfn);
-		if (!PageReserved(page))
+		SetPageDirty(page);
-			SetPageDirty(page);
 	}
 }
 EXPORT_SYMBOL_GPL(kvm_set_pfn_dirty);
 #endif
 }
+/*
+ * Unlike kvm_arch_vcpu_runnable, this function is called outside
+ * a vcpu_load/vcpu_put pair.  However, for most architectures
+ * kvm_arch_vcpu_runnable does not require vcpu_load.
+ */
+bool __weak kvm_arch_dy_runnable(struct kvm_vcpu *vcpu)
+{
+	return kvm_arch_vcpu_runnable(vcpu);
+}
+static bool vcpu_dy_runnable(struct kvm_vcpu *vcpu)
+{
+	if (kvm_arch_dy_runnable(vcpu))
+		return true;
+#ifdef CONFIG_KVM_ASYNC_PF
+	if (!list_empty_careful(&vcpu->async_pf.done))
+		return true;
+#endif
+	return false;
+}
 void kvm_vcpu_on_spin(struct kvm_vcpu *me, bool yield_to_kernel_mode)
 {
 	struct kvm *kvm = me->kvm;
 				continue;
 			if (vcpu == me)
 				continue;
-			if (swait_active(&vcpu->wq) && !kvm_arch_vcpu_runnable(vcpu))
+			if (swait_active(&vcpu->wq) && !vcpu_dy_runnable(vcpu))
 				continue;
-			if (yield_to_kernel_mode && !kvm_arch_vcpu_in_kernel(vcpu))
+			if (READ_ONCE(vcpu->preempted) && yield_to_kernel_mode &&
+				!kvm_arch_vcpu_in_kernel(vcpu))
 				continue;
 			if (!kvm_vcpu_eligible_for_directed_yield(vcpu))
 				continue;
 	return anon_inode_getfd(name, &kvm_vcpu_fops, vcpu, O_RDWR | O_CLOEXEC);
 }
-static int kvm_create_vcpu_debugfs(struct kvm_vcpu *vcpu)
+static void kvm_create_vcpu_debugfs(struct kvm_vcpu *vcpu)
 {
+#ifdef __KVM_HAVE_ARCH_VCPU_DEBUGFS
 	char dir_name[ITOA_MAX_LEN * 2];
-	int ret;
-	if (!kvm_arch_has_vcpu_debugfs())
-		return 0;
 	if (!debugfs_initialized())
-		return 0;
+		return;
 	snprintf(dir_name, sizeof(dir_name), "vcpu%d", vcpu->vcpu_id);
 	vcpu->debugfs_dentry = debugfs_create_dir(dir_name,
-								vcpu->kvm->debugfs_dentry);
+						  vcpu->kvm->debugfs_dentry);
-	if (!vcpu->debugfs_dentry)
-		return -ENOMEM;
-	ret = kvm_arch_create_vcpu_debugfs(vcpu);
-	if (ret < 0) {
-		debugfs_remove_recursive(vcpu->debugfs_dentry);
-		return ret;
-	}
-	return 0;
+	kvm_arch_create_vcpu_debugfs(vcpu);
+#endif
 }
 /*
 	if (r)
 		goto vcpu_destroy;
-	r = kvm_create_vcpu_debugfs(vcpu);
+	kvm_create_vcpu_debugfs(vcpu);
-	if (r)
-		goto vcpu_destroy;
 	mutex_lock(&kvm->lock);
 	if (kvm_get_vcpu_by_id(kvm, id)) {
 {
 	struct kvm_vcpu *vcpu = preempt_notifier_to_vcpu(pn);
-	vcpu->preempted = false;
+	WRITE_ONCE(vcpu->preempted, false);
 	WRITE_ONCE(vcpu->ready, false);
 	kvm_arch_sched_in(vcpu, cpu);
 	struct kvm_vcpu *vcpu = preempt_notifier_to_vcpu(pn);
 	if (current->state == TASK_RUNNING) {
-		vcpu->preempted = true;
+		WRITE_ONCE(vcpu->preempted, true);
 		WRITE_ONCE(vcpu->ready, true);
 	}
 	kvm_arch_vcpu_put(vcpu);

@@ -130,19 +130,19 @@ static int dw_edma_pcie_probe(struct pci_dev *pdev, · 129 unmodified lines
130	chip->id = pdev->devfn;	130	chip->id = pdev->devfn;
131	chip->irq = pdev->irq;	131	chip->irq = pdev->irq;
132		132
133	dw->rg_region.vaddr = (dma_addr_t)pcim_iomap_table(pdev)[pdata->rg_bar];	133	dw->rg_region.vaddr = pcim_iomap_table(pdev)[pdata->rg_bar];
134	dw->rg_region.vaddr += pdata->rg_off;	134	dw->rg_region.vaddr += pdata->rg_off;
135	dw->rg_region.paddr = pdev->resource[pdata->rg_bar].start;	135	dw->rg_region.paddr = pdev->resource[pdata->rg_bar].start;
136	dw->rg_region.paddr += pdata->rg_off;	136	dw->rg_region.paddr += pdata->rg_off;
137	dw->rg_region.sz = pdata->rg_sz;	137	dw->rg_region.sz = pdata->rg_sz;
138		138
139	dw->ll_region.vaddr = (dma_addr_t)pcim_iomap_table(pdev)[pdata->ll_bar];	139	dw->ll_region.vaddr = pcim_iomap_table(pdev)[pdata->ll_bar];
140	dw->ll_region.vaddr += pdata->ll_off;	140	dw->ll_region.vaddr += pdata->ll_off;
141	dw->ll_region.paddr = pdev->resource[pdata->ll_bar].start;	141	dw->ll_region.paddr = pdev->resource[pdata->ll_bar].start;
142	dw->ll_region.paddr += pdata->ll_off;	142	dw->ll_region.paddr += pdata->ll_off;
143	dw->ll_region.sz = pdata->ll_sz;	143	dw->ll_region.sz = pdata->ll_sz;
144		144
145	dw->dt_region.vaddr = (dma_addr_t)pcim_iomap_table(pdev)[pdata->dt_bar];	145	dw->dt_region.vaddr = pcim_iomap_table(pdev)[pdata->dt_bar];
146	dw->dt_region.vaddr += pdata->dt_off;	146	dw->dt_region.vaddr += pdata->dt_off;
147	dw->dt_region.paddr = pdev->resource[pdata->dt_bar].start;	147	dw->dt_region.paddr = pdev->resource[pdata->dt_bar].start;
148	dw->dt_region.paddr += pdata->dt_off;	148	dw->dt_region.paddr += pdata->dt_off;
@@ -158,17 +158,17 @@ static int dw_edma_pcie_probe(struct pci_dev *pdev, · 9 unmodified lines
158	pci_dbg(pdev, "Mode:\t%s\n",	158	pci_dbg(pdev, "Mode:\t%s\n",
159	dw->mode == EDMA_MODE_LEGACY ? "Legacy" : "Unroll");	159	dw->mode == EDMA_MODE_LEGACY ? "Legacy" : "Unroll");
160		160
161	pci_dbg(pdev, "Registers:\tBAR=%u, off=0x%.8lx, sz=0x%zx bytes, addr(v=%pa, p=%pa)\n",	161	pci_dbg(pdev, "Registers:\tBAR=%u, off=0x%.8lx, sz=0x%zx bytes, addr(v=%p, p=%pa)\n",
162	pdata->rg_bar, pdata->rg_off, pdata->rg_sz,	162	pdata->rg_bar, pdata->rg_off, pdata->rg_sz,
163	&dw->rg_region.vaddr, &dw->rg_region.paddr);	163	dw->rg_region.vaddr, &dw->rg_region.paddr);
164		164
165	pci_dbg(pdev, "L. List:\tBAR=%u, off=0x%.8lx, sz=0x%zx bytes, addr(v=%pa, p=%pa)\n",	165	pci_dbg(pdev, "L. List:\tBAR=%u, off=0x%.8lx, sz=0x%zx bytes, addr(v=%p, p=%pa)\n",
166	pdata->ll_bar, pdata->ll_off, pdata->ll_sz,	166	pdata->ll_bar, pdata->ll_off, pdata->ll_sz,
167	&dw->ll_region.vaddr, &dw->ll_region.paddr);	167	dw->ll_region.vaddr, &dw->ll_region.paddr);
168		168
169	pci_dbg(pdev, "Data:\tBAR=%u, off=0x%.8lx, sz=0x%zx bytes, addr(v=%pa, p=%pa)\n",	169	pci_dbg(pdev, "Data:\tBAR=%u, off=0x%.8lx, sz=0x%zx bytes, addr(v=%p, p=%pa)\n",
170	pdata->dt_bar, pdata->dt_off, pdata->dt_sz,	170	pdata->dt_bar, pdata->dt_off, pdata->dt_sz,
171	&dw->dt_region.vaddr, &dw->dt_region.paddr);	171	dw->dt_region.vaddr, &dw->dt_region.paddr);
172		172
173	pci_dbg(pdev, "Nr. IRQs:\t%u\n", dw->nr_irqs);	173	pci_dbg(pdev, "Nr. IRQs:\t%u\n", dw->nr_irqs);
174		174

@@ -141,7 +141,7 @@ static void rxrpc_end_rx_phase(struct rxrpc_call *call, rxrpc_serial_t serial) · 140 unmodified lines
141	ASSERTCMP(call->rx_hard_ack, ==, call->rx_top);	141	ASSERTCMP(call->rx_hard_ack, ==, call->rx_top);
142		142
143	if (call->state == RXRPC_CALL_CLIENT_RECV_REPLY) {	143	if (call->state == RXRPC_CALL_CLIENT_RECV_REPLY) {
144	rxrpc_propose_ACK(call, RXRPC_ACK_IDLE, 0, serial, false, true,	144	rxrpc_propose_ACK(call, RXRPC_ACK_IDLE, serial, false, true,
145	rxrpc_propose_ack_terminal_ack);	145	rxrpc_propose_ack_terminal_ack);
146	//rxrpc_send_ack_packet(call, false, NULL);	146	//rxrpc_send_ack_packet(call, false, NULL);
147	}	147	}
@@ -159,7 +159,7 @@ static void rxrpc_end_rx_phase(struct rxrpc_call *call, rxrpc_serial_t serial) · 11 unmodified lines
159	call->state = RXRPC_CALL_SERVER_ACK_REQUEST;	159	call->state = RXRPC_CALL_SERVER_ACK_REQUEST;
160	call->expect_req_by = jiffies + MAX_JIFFY_OFFSET;	160	call->expect_req_by = jiffies + MAX_JIFFY_OFFSET;
161	write_unlock_bh(&call->state_lock);	161	write_unlock_bh(&call->state_lock);
162	rxrpc_propose_ACK(call, RXRPC_ACK_DELAY, 0, serial, false, true,	162	rxrpc_propose_ACK(call, RXRPC_ACK_DELAY, serial, false, true,
163	rxrpc_propose_ack_processing_op);	163	rxrpc_propose_ack_processing_op);
164	break;	164	break;
165	default:	165	default:
@@ -212,7 +212,7 @@ static void rxrpc_rotate_rx_window(struct rxrpc_call *call) · 46 unmodified lines
212	if (after_eq(hard_ack, call->ackr_consumed + 2) \|\|	212	if (after_eq(hard_ack, call->ackr_consumed + 2) \|\|
213	after_eq(top, call->ackr_seen + 2) \|\|	213	after_eq(top, call->ackr_seen + 2) \|\|
214	(hard_ack == top && after(hard_ack, call->ackr_consumed)))	214	(hard_ack == top && after(hard_ack, call->ackr_consumed)))
215	rxrpc_propose_ACK(call, RXRPC_ACK_DELAY, 0, serial,	215	rxrpc_propose_ACK(call, RXRPC_ACK_DELAY, serial,
216	true, true,	216	true, true,
217	rxrpc_propose_ack_rotate_rx);	217	rxrpc_propose_ack_rotate_rx);
218	if (call->ackr_reason && call->ackr_reason != RXRPC_ACK_DELAY)	218	if (call->ackr_reason && call->ackr_reason != RXRPC_ACK_DELAY)