lael-labs/linux

Documentation/admin-guide/device-mapper/dm-integrity.rst+9−6

@@ -182,12 +182,15 @@ fix_padding · 181 unmodified lines
182	space-efficient. If this option is not present, large padding is	182	space-efficient. If this option is not present, large padding is
183	used - that is for compatibility with older kernels.	183	used - that is for compatibility with older kernels.
184		184
185		185	allow_discards
186	The journal mode (D/J), buffer_sectors, journal_watermark, commit_time can	186	Allow block discard requests (a.k.a. TRIM) for the integrity device.
187	be changed when reloading the target (load an inactive table and swap the	187	Discards are only allowed to devices using internal hash.
188	tables with suspend and resume). The other arguments should not be changed	188
189	when reloading the target because the layout of disk data depend on them	189	The journal mode (D/J), buffer_sectors, journal_watermark, commit_time and
190	and the reloaded target would be non-functional.	190	allow_discards can be changed when reloading the target (load an inactive
		191	table and swap the tables with suspend and resume). The other arguments
		192	should not be changed when reloading the target because the layout of disk
		193	data depend on them and the reloaded target would be non-functional.
191		194
192		195
193	The layout of the formatted block device:	196	The layout of the formatted block device:

Documentation/devicetree/bindings/dma/socionext,uniphier-xdmac.yaml+3−4

     const: socionext,uniphier-xdmac
   reg:
-    items:
+    maxItems: 1
-      - description: XDMAC base register region (offset and length)
-      - description: XDMAC extension register region (offset and length)
   interrupts:
     maxItems: 1
   - reg
   - interrupts
   - "#dma-cells"
+  - dma-channels
 examples:
   - |
     xdmac: dma-controller@5fc10000 {
         compatible = "socionext,uniphier-xdmac";
-        reg = <0x5fc10000 0x1000>, <0x5fc20000 0x800>;
+        reg = <0x5fc10000 0x5300>;
         interrupts = <0 188 4>;
         #dma-cells = <2>;
         dma-channels = <16>;

MAINTAINERS+1−1

@@ -3657,7 +3657,7 @@ L: linux-btrfs@vger.kernel.org · 3656 unmodified lines
3657	S: Maintained	3657	S: Maintained
3658	W: http://btrfs.wiki.kernel.org/	3658	W: http://btrfs.wiki.kernel.org/
3659	Q: http://patchwork.kernel.org/project/linux-btrfs/list/	3659	Q: http://patchwork.kernel.org/project/linux-btrfs/list/
3660	T: git git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs.git	3660	T: git git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux.git
3661	F: Documentation/filesystems/btrfs.rst	3661	F: Documentation/filesystems/btrfs.rst
3662	F: fs/btrfs/	3662	F: fs/btrfs/
3663	F: include/linux/btrfs*	3663	F: include/linux/btrfs*

Makefile+1−1

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

arch/arm64/kernel/vdso/Makefile+1−1

@@ -32,7 +32,7 @@ UBSAN_SANITIZE := n · 31 unmodified lines
32	OBJECT_FILES_NON_STANDARD := y	32	OBJECT_FILES_NON_STANDARD := y
33	KCOV_INSTRUMENT := n	33	KCOV_INSTRUMENT := n
34		34
35	CFLAGS_vgettimeofday.o = -O2 -mcmodel=tiny	35	CFLAGS_vgettimeofday.o = -O2 -mcmodel=tiny -fasynchronous-unwind-tables
36		36
37	ifneq ($(c-gettimeofday-y),)	37	ifneq ($(c-gettimeofday-y),)
38	CFLAGS_vgettimeofday.o += -include $(c-gettimeofday-y)	38	CFLAGS_vgettimeofday.o += -include $(c-gettimeofday-y)

arch/riscv/Kconfig+1−1

@@ -60,7 +60,7 @@ config RISCV · 59 unmodified lines
60	select ARCH_HAS_GIGANTIC_PAGE	60	select ARCH_HAS_GIGANTIC_PAGE
61	select ARCH_HAS_SET_DIRECT_MAP	61	select ARCH_HAS_SET_DIRECT_MAP
62	select ARCH_HAS_SET_MEMORY	62	select ARCH_HAS_SET_MEMORY
63	select ARCH_HAS_STRICT_KERNEL_RWX	63	select ARCH_HAS_STRICT_KERNEL_RWX if MMU
64	select ARCH_WANT_HUGE_PMD_SHARE if 64BIT	64	select ARCH_WANT_HUGE_PMD_SHARE if 64BIT
65	select SPARSEMEM_STATIC if 32BIT	65	select SPARSEMEM_STATIC if 32BIT
66	select ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT if MMU	66	select ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT if MMU

arch/riscv/kernel/sbi.c+10−7

 {
 	sbi_ecall(SBI_EXT_0_1_SHUTDOWN, 0, 0, 0, 0, 0, 0, 0);
 }
-EXPORT_SYMBOL(sbi_set_timer);
+EXPORT_SYMBOL(sbi_shutdown);
 /**
  * sbi_clear_ipi() - Clear any pending IPIs for the calling hart.
 {
 	sbi_ecall(SBI_EXT_0_1_CLEAR_IPI, 0, 0, 0, 0, 0, 0, 0);
 }
-EXPORT_SYMBOL(sbi_shutdown);
+EXPORT_SYMBOL(sbi_clear_ipi);
 /**
  * sbi_set_timer_v01() - Program the timer for next timer event.
 	return result;
 }
+static void sbi_set_power_off(void)
+{
+	pm_power_off = sbi_shutdown;
+}
 #else
 static void __sbi_set_timer_v01(uint64_t stime_value)
 {
 	return 0;
 }
+static void sbi_set_power_off(void) {}
 #endif /* CONFIG_RISCV_SBI_V01 */
 static void __sbi_set_timer_v02(uint64_t stime_value)
 	return __sbi_base_ecall(SBI_EXT_BASE_GET_IMP_VERSION);
 }
-static void sbi_power_off(void)
-{
-	sbi_shutdown();
-}
 int __init sbi_init(void)
 {
 	int ret;
-	pm_power_off = sbi_power_off;
+	sbi_set_power_off();
 	ret = sbi_get_spec_version();
 	if (ret > 0)
 		sbi_spec_version = ret;

arch/riscv/kernel/stacktrace.c+2−2

 #include <linux/stacktrace.h>
 #include <linux/ftrace.h>
+register unsigned long sp_in_global __asm__("sp");
 #ifdef CONFIG_FRAME_POINTER
 struct stackframe {
 	unsigned long ra;
 };
-register unsigned long sp_in_global __asm__("sp");
 void notrace walk_stackframe(struct task_struct *task, struct pt_regs *regs,
 			     bool (*fn)(unsigned long, void *), void *arg)
 {

arch/riscv/kernel/vdso/Makefile+3−3

@@ -33,15 +33,15 @@ $(obj)/vdso.so.dbg: $(src)/vdso.lds $(obj-vdso) FORCE · 32 unmodified lines
33	$(call if_changed,vdsold)	33	$(call if_changed,vdsold)
34		34
35	# We also create a special relocatable object that should mirror the symbol	35	# We also create a special relocatable object that should mirror the symbol
36	# table and layout of the linked DSO. With ld -R we can then refer to	36	# table and layout of the linked DSO. With ld --just-symbols we can then
37	# these symbols in the kernel code rather than hand-coded addresses.	37	# refer to these symbols in the kernel code rather than hand-coded addresses.
38		38
39	SYSCFLAGS_vdso.so.dbg = -shared -s -Wl,-soname=linux-vdso.so.1 \	39	SYSCFLAGS_vdso.so.dbg = -shared -s -Wl,-soname=linux-vdso.so.1 \
40	-Wl,--build-id -Wl,--hash-style=both	40	-Wl,--build-id -Wl,--hash-style=both
41	$(obj)/vdso-dummy.o: $(src)/vdso.lds $(obj)/rt_sigreturn.o FORCE	41	$(obj)/vdso-dummy.o: $(src)/vdso.lds $(obj)/rt_sigreturn.o FORCE
42	$(call if_changed,vdsold)	42	$(call if_changed,vdsold)
43		43
44	LDFLAGS_vdso-syms.o := -r -R	44	LDFLAGS_vdso-syms.o := -r --just-symbols
45	$(obj)/vdso-syms.o: $(obj)/vdso-dummy.o FORCE	45	$(obj)/vdso-syms.o: $(obj)/vdso-dummy.o FORCE
46	$(call if_changed,ld)	46	$(call if_changed,ld)
47		47

arch/s390/lib/uaccess.c+4−0

 {
 	mm_segment_t old_fs;
 	unsigned long asce, cr;
+	unsigned long flags;
 	old_fs = current->thread.mm_segment;
 	if (old_fs & 1)
 		return old_fs;
+	/* protect against a concurrent page table upgrade */
+	local_irq_save(flags);
 	current->thread.mm_segment |= 1;
 	asce = S390_lowcore.kernel_asce;
 	if (likely(old_fs == USER_DS)) {
 		__ctl_load(asce, 7, 7);
 		set_cpu_flag(CIF_ASCE_SECONDARY);
 	}
+	local_irq_restore(flags);
 	return old_fs;
 }
 EXPORT_SYMBOL(enable_sacf_uaccess);

arch/s390/mm/pgalloc.c+14−2

@@ -70,8 +70,20 @@ static void __crst_table_upgrade(void *arg) · 69 unmodified lines
70	{	70	{
71	struct mm_struct *mm = arg;	71	struct mm_struct *mm = arg;
72		72
73	if (current->active_mm == mm)	73	/* we must change all active ASCEs to avoid the creation of new TLBs */
74	set_user_asce(mm);	74	if (current->active_mm == mm) {
		75	S390_lowcore.user_asce = mm->context.asce;
		76	if (current->thread.mm_segment == USER_DS) {
		77	__ctl_load(S390_lowcore.user_asce, 1, 1);
		78	/* Mark user-ASCE present in CR1 */
		79	clear_cpu_flag(CIF_ASCE_PRIMARY);
		80	}
		81	if (current->thread.mm_segment == USER_DS_SACF) {
		82	__ctl_load(S390_lowcore.user_asce, 7, 7);
		83	/* enable_sacf_uaccess does all or nothing */
		84	WARN_ON(!test_cpu_flag(CIF_ASCE_SECONDARY));
		85	}
		86	}
75	__tlb_flush_local();	87	__tlb_flush_local();
76	}	88	}
77		89

arch/x86/hyperv/hv_init.c+10−2

 	struct page *pg;
 	input_arg = (void **)this_cpu_ptr(hyperv_pcpu_input_arg);
-	pg = alloc_page(GFP_KERNEL);
+	/* hv_cpu_init() can be called with IRQs disabled from hv_resume() */
+	pg = alloc_page(irqs_disabled() ? GFP_ATOMIC : GFP_KERNEL);
 	if (unlikely(!pg))
 		return -ENOMEM;
 	*input_arg = page_address(pg);
 static int hv_suspend(void)
 {
 	union hv_x64_msr_hypercall_contents hypercall_msr;
+	int ret;
 	/*
 	 * Reset the hypercall page as it is going to be invalidated
 	hypercall_msr.enable = 0;
 	wrmsrl(HV_X64_MSR_HYPERCALL, hypercall_msr.as_uint64);
-	return 0;
+	ret = hv_cpu_die(0);
+	return ret;
 }
 static void hv_resume(void)
 {
 	union hv_x64_msr_hypercall_contents hypercall_msr;
+	int ret;
+	ret = hv_cpu_init(0);
+	WARN_ON(ret);
 	/* Re-enable the hypercall page */
 	rdmsrl(HV_X64_MSR_HYPERCALL, hypercall_msr.as_uint64);
 	hv_hypercall_pg_saved = NULL;
 }
+/* Note: when the ops are called, only CPU0 is online and IRQs are disabled. */
 static struct syscore_ops hv_syscore_ops = {
 	.suspend	= hv_suspend,
 	.resume		= hv_resume,

arch/x86/include/asm/mshyperv.h+2−0

@@ -35,6 +35,8 @@ typedef int (*hyperv_fill_flush_list_func)( · 34 unmodified lines
35	rdmsrl(HV_X64_MSR_SINT0 + int_num, val)	35	rdmsrl(HV_X64_MSR_SINT0 + int_num, val)
36	#define hv_set_synint_state(int_num, val) \	36	#define hv_set_synint_state(int_num, val) \
37	wrmsrl(HV_X64_MSR_SINT0 + int_num, val)	37	wrmsrl(HV_X64_MSR_SINT0 + int_num, val)
		38	#define hv_recommend_using_aeoi() \
		39	(!(ms_hyperv.hints & HV_DEPRECATING_AEOI_RECOMMENDED))
38		40
39	#define hv_get_crash_ctl(val) \	41	#define hv_get_crash_ctl(val) \
40	rdmsrl(HV_X64_MSR_CRASH_CTL, val)	42	rdmsrl(HV_X64_MSR_CRASH_CTL, val)

block/partitions/core.c+1−1

@@ -496,7 +496,7 @@ int blk_drop_partitions(struct gendisk disk, struct block_device bdev) · 495 unmodified lines
496		496
497	if (!disk_part_scan_enabled(disk))	497	if (!disk_part_scan_enabled(disk))
498	return 0;	498	return 0;
499	if (bdev->bd_part_count \|\| bdev->bd_openers > 1)	499	if (bdev->bd_part_count)
500	return -EBUSY;	500	return -EBUSY;
501	res = invalidate_partition(disk, 0);	501	res = invalidate_partition(disk, 0);
502	if (res)	502	if (res)

drivers/acpi/device_pm.c+2−2

@@ -273,13 +273,13 @@ int acpi_device_set_power(struct acpi_device *device, int state) · 272 unmodified lines
273	end:	273	end:
274	if (result) {	274	if (result) {
275	dev_warn(&device->dev, "Failed to change power state to %s\n",	275	dev_warn(&device->dev, "Failed to change power state to %s\n",
276	acpi_power_state_string(state));	276	acpi_power_state_string(target_state));
277	} else {	277	} else {
278	device->power.state = target_state;	278	device->power.state = target_state;
279	ACPI_DEBUG_PRINT((ACPI_DB_INFO,	279	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
280	"Device [%s] transitioned to %s\n",	280	"Device [%s] transitioned to %s\n",
281	device->pnp.bus_id,	281	device->pnp.bus_id,
282	acpi_power_state_string(state)));	282	acpi_power_state_string(target_state)));
283	}	283	}
284		284
285	return result;	285	return result;

drivers/cpufreq/intel_pstate.c+1−1

@@ -1059,7 +1059,7 @@ static ssize_t store_no_turbo(struct kobject a, struct kobj_attribute b, · 1058 unmodified lines
1059		1059
1060	update_turbo_state();	1060	update_turbo_state();
1061	if (global.turbo_disabled) {	1061	if (global.turbo_disabled) {
1062	pr_warn("Turbo disabled by BIOS or unavailable on processor\n");	1062	pr_notice_once("Turbo disabled by BIOS or unavailable on processor\n");
1063	mutex_unlock(&intel_pstate_limits_lock);	1063	mutex_unlock(&intel_pstate_limits_lock);
1064	mutex_unlock(&intel_pstate_driver_lock);	1064	mutex_unlock(&intel_pstate_driver_lock);
1065	return -EPERM;	1065	return -EPERM;

drivers/crypto/caam/caamalg.c+7−3

 	struct caam_drv_private_jr *jrp = dev_get_drvdata(jrdev);
 	struct aead_edesc *edesc;
 	int ecode = 0;
+	bool has_bklog;
 	dev_dbg(jrdev, "%s %d: err 0x%x\n", __func__, __LINE__, err);
 	edesc = rctx->edesc;
+	has_bklog = edesc->bklog;
 	if (err)
 		ecode = caam_jr_strstatus(jrdev, err);
 	 * If no backlog flag, the completion of the request is done
 	 * by CAAM, not crypto engine.
 	 */
-	if (!edesc->bklog)
+	if (!has_bklog)
 		aead_request_complete(req, ecode);
 	else
 		crypto_finalize_aead_request(jrp->engine, req, ecode);
 	struct caam_drv_private_jr *jrp = dev_get_drvdata(jrdev);
 	int ivsize = crypto_skcipher_ivsize(skcipher);
 	int ecode = 0;
+	bool has_bklog;
 	dev_dbg(jrdev, "%s %d: err 0x%x\n", __func__, __LINE__, err);
 	edesc = rctx->edesc;
+	has_bklog = edesc->bklog;
 	if (err)
 		ecode = caam_jr_strstatus(jrdev, err);
 	 * If no backlog flag, the completion of the request is done
 	 * by CAAM, not crypto engine.
 	 */
-	if (!edesc->bklog)
+	if (!has_bklog)
 		skcipher_request_complete(req, ecode);
 	else
 		crypto_finalize_skcipher_request(jrp->engine, req, ecode);
 	if (ivsize || mapped_dst_nents > 1)
 		sg_to_sec4_set_last(edesc->sec4_sg + dst_sg_idx +
-				    mapped_dst_nents);
+				    mapped_dst_nents - 1 + !!ivsize);
 	if (sec4_sg_bytes) {
 		edesc->sec4_sg_dma = dma_map_single(jrdev, edesc->sec4_sg,

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

 	struct caam_hash_state *state = ahash_request_ctx(req);
 	struct caam_hash_ctx *ctx = crypto_ahash_ctx(ahash);
 	int ecode = 0;
+	bool has_bklog;
 	dev_dbg(jrdev, "%s %d: err 0x%x\n", __func__, __LINE__, err);
 	edesc = state->edesc;
+	has_bklog = edesc->bklog;
 	if (err)
 		ecode = caam_jr_strstatus(jrdev, err);
 	 * If no backlog flag, the completion of the request is done
 	 * by CAAM, not crypto engine.
 	 */
-	if (!edesc->bklog)
+	if (!has_bklog)
 		req->base.complete(&req->base, ecode);
 	else
 		crypto_finalize_hash_request(jrp->engine, req, ecode);
 	struct caam_hash_state *state = ahash_request_ctx(req);
 	int digestsize = crypto_ahash_digestsize(ahash);
 	int ecode = 0;
+	bool has_bklog;
 	dev_dbg(jrdev, "%s %d: err 0x%x\n", __func__, __LINE__, err);
 	edesc = state->edesc;
+	has_bklog = edesc->bklog;
 	if (err)
 		ecode = caam_jr_strstatus(jrdev, err);
 	 * If no backlog flag, the completion of the request is done
 	 * by CAAM, not crypto engine.
 	 */
-	if (!edesc->bklog)
+	if (!has_bklog)
 		req->base.complete(&req->base, ecode);
 	else
 		crypto_finalize_hash_request(jrp->engine, req, ecode);

drivers/crypto/caam/caampkc.c+6−2

 	struct caam_drv_private_jr *jrp = dev_get_drvdata(dev);
 	struct rsa_edesc *edesc;
 	int ecode = 0;
+	bool has_bklog;
 	if (err)
 		ecode = caam_jr_strstatus(dev, err);
 	edesc = req_ctx->edesc;
+	has_bklog = edesc->bklog;
 	rsa_pub_unmap(dev, edesc, req);
 	rsa_io_unmap(dev, edesc, req);
 	 * If no backlog flag, the completion of the request is done
 	 * by CAAM, not crypto engine.
 	 */
-	if (!edesc->bklog)
+	if (!has_bklog)
 		akcipher_request_complete(req, ecode);
 	else
 		crypto_finalize_akcipher_request(jrp->engine, req, ecode);
 	struct caam_rsa_req_ctx *req_ctx = akcipher_request_ctx(req);
 	struct rsa_edesc *edesc;
 	int ecode = 0;
+	bool has_bklog;
 	if (err)
 		ecode = caam_jr_strstatus(dev, err);
 	edesc = req_ctx->edesc;
+	has_bklog = edesc->bklog;
 	switch (key->priv_form) {
 	case FORM1:
 	 * If no backlog flag, the completion of the request is done
 	 * by CAAM, not crypto engine.
 	 */
-	if (!edesc->bklog)
+	if (!has_bklog)
 		akcipher_request_complete(req, ecode);
 	else
 		crypto_finalize_akcipher_request(jrp->engine, req, ecode);

drivers/dma-buf/dma-buf.c+4−3

 		return ret;
-	case DMA_BUF_SET_NAME:
+	case DMA_BUF_SET_NAME_A:
+	case DMA_BUF_SET_NAME_B:
 		return dma_buf_set_name(dmabuf, (const char __user *)arg);
 	default:
  * calls attach() of dma_buf_ops to allow device-specific attach functionality
  * @dmabuf:		[in]	buffer to attach device to.
  * @dev:		[in]	device to be attached.
- * @importer_ops	[in]	importer operations for the attachment
+ * @importer_ops:	[in]	importer operations for the attachment
- * @importer_priv	[in]	importer private pointer for the attachment
+ * @importer_priv:	[in]	importer private pointer for the attachment
  *
  * Returns struct dma_buf_attachment pointer for this attachment. Attachments
  * must be cleaned up by calling dma_buf_detach().

drivers/dma/Kconfig+2−1

@@ -241,7 +241,8 @@ config FSL_RAID · 240 unmodified lines
241		241
242	config HISI_DMA	242	config HISI_DMA
243	tristate "HiSilicon DMA Engine support"	243	tristate "HiSilicon DMA Engine support"
244	depends on ARM64 \|\| (COMPILE_TEST && PCI_MSI)	244	depends on ARM64 \|\| COMPILE_TEST
		245	depends on PCI_MSI
245	select DMA_ENGINE	246	select DMA_ENGINE
246	select DMA_VIRTUAL_CHANNELS	247	select DMA_VIRTUAL_CHANNELS
247	help	248	help

drivers/dma/dmaengine.c+26−34

 	struct dma_chan_dev *chan_dev;
 	chan_dev = container_of(dev, typeof(*chan_dev), device);
-	if (atomic_dec_and_test(chan_dev->idr_ref)) {
-		ida_free(&dma_ida, chan_dev->dev_id);
-		kfree(chan_dev->idr_ref);
-	}
 	kfree(chan_dev);
 }
 }
 static int __dma_async_device_channel_register(struct dma_device *device,
-					       struct dma_chan *chan,
+					       struct dma_chan *chan)
-					       int chan_id)
 {
 	int rc = 0;
-	int chancnt = device->chancnt;
-	atomic_t *idr_ref;
-	struct dma_chan *tchan;
-	tchan = list_first_entry_or_null(&device->channels,
-					 struct dma_chan, device_node);
-	if (!tchan)
-		return -ENODEV;
-	if (tchan->dev) {
-		idr_ref = tchan->dev->idr_ref;
-	} else {
-		idr_ref = kmalloc(sizeof(*idr_ref), GFP_KERNEL);
-		if (!idr_ref)
-			return -ENOMEM;
-		atomic_set(idr_ref, 0);
-	}
 	chan->local = alloc_percpu(typeof(*chan->local));
 	if (!chan->local)
 	 * When the chan_id is a negative value, we are dynamically adding
 	 * the channel. Otherwise we are static enumerating.
 	 */
-	chan->chan_id = chan_id < 0 ? chancnt : chan_id;
+	mutex_lock(&device->chan_mutex);
+	chan->chan_id = ida_alloc(&device->chan_ida, GFP_KERNEL);
+	mutex_unlock(&device->chan_mutex);
+	if (chan->chan_id < 0) {
+		pr_err("%s: unable to alloc ida for chan: %d\n",
+		       __func__, chan->chan_id);
+		goto err_out;
+	}
 	chan->dev->device.class = &dma_devclass;
 	chan->dev->device.parent = device->dev;
 	chan->dev->chan = chan;
-	chan->dev->idr_ref = idr_ref;
 	chan->dev->dev_id = device->dev_id;
-	atomic_inc(idr_ref);
 	dev_set_name(&chan->dev->device, "dma%dchan%d",
 		     device->dev_id, chan->chan_id);
 	rc = device_register(&chan->dev->device);
 	if (rc)
-		goto err_out;
+		goto err_out_ida;
 	chan->client_count = 0;
-	device->chancnt = chan->chan_id + 1;
+	device->chancnt++;
 	return 0;
+ err_out_ida:
+	mutex_lock(&device->chan_mutex);
+	ida_free(&device->chan_ida, chan->chan_id);
+	mutex_unlock(&device->chan_mutex);
  err_out:
 	free_percpu(chan->local);
 	kfree(chan->dev);
-	if (atomic_dec_return(idr_ref) == 0)
-		kfree(idr_ref);
 	return rc;
 }
 {
 	int rc;
-	rc = __dma_async_device_channel_register(device, chan, -1);
+	rc = __dma_async_device_channel_register(device, chan);
 	if (rc < 0)
 		return rc;
 	device->chancnt--;
 	chan->dev->chan = NULL;
 	mutex_unlock(&dma_list_mutex);
+	mutex_lock(&device->chan_mutex);
+	ida_free(&device->chan_ida, chan->chan_id);
+	mutex_unlock(&device->chan_mutex);
 	device_unregister(&chan->dev->device);
 	free_percpu(chan->local);
 }
  */
 int dma_async_device_register(struct dma_device *device)
 {
-	int rc, i = 0;
+	int rc;
 	struct dma_chan* chan;
 	if (!device)
 	if (rc != 0)
 		return rc;
+	mutex_init(&device->chan_mutex);
+	ida_init(&device->chan_ida);
 	/* represent channels in sysfs. Probably want devs too */
 	list_for_each_entry(chan, &device->channels, device_node) {
-		rc = __dma_async_device_channel_register(device, chan, i++);
+		rc = __dma_async_device_channel_register(device, chan);
 		if (rc < 0)
 			goto err_out;
 	}
 	 */
 	dma_cap_set(DMA_PRIVATE, device->cap_mask);
 	dma_channel_rebalance();
+	ida_free(&dma_ida, device->dev_id);
 	dma_device_put(device);
 	mutex_unlock(&dma_list_mutex);
 }

drivers/dma/dmatest.c+3−3

@@ -240,7 +240,7 @@ static bool is_threaded_test_run(struct dmatest_info *info) · 239 unmodified lines
240	struct dmatest_thread *thread;	240	struct dmatest_thread *thread;
241		241
242	list_for_each_entry(thread, &dtc->threads, node) {	242	list_for_each_entry(thread, &dtc->threads, node) {
243	if (!thread->done)	243	if (!thread->done && !thread->pending)
244	return true;	244	return true;
245	}	245	}
246	}	246	}
@@ -662,8 +662,8 @@ static int dmatest_func(void *data) · 415 unmodified lines
662	flags = DMA_CTRL_ACK \| DMA_PREP_INTERRUPT;	662	flags = DMA_CTRL_ACK \| DMA_PREP_INTERRUPT;
663		663
664	ktime = ktime_get();	664	ktime = ktime_get();
665	while (!kthread_should_stop()	665	while (!(kthread_should_stop() \|\|
666	&& !(params->iterations && total_tests >= params->iterations)) {	666	(params->iterations && total_tests >= params->iterations))) {
667	struct dma_async_tx_descriptor *tx = NULL;	667	struct dma_async_tx_descriptor *tx = NULL;
668	struct dmaengine_unmap_data *um;	668	struct dmaengine_unmap_data *um;
669	dma_addr_t *dsts;	669	dma_addr_t *dsts;

drivers/dma/mmp_tdma.c+4−1

 		gen_pool_free(gpool, (unsigned long)tdmac->desc_arr,
 				size);
 	tdmac->desc_arr = NULL;
+	if (tdmac->status == DMA_ERROR)
+		tdmac->status = DMA_COMPLETE;
 	return;
 }
 	if (!desc)
 		goto err_out;
-	mmp_tdma_config_write(chan, direction, &tdmac->slave_config);
+	if (mmp_tdma_config_write(chan, direction, &tdmac->slave_config))
+		goto err_out;
 	while (buf < buf_len) {
 		desc = &tdmac->desc_arr[i];

drivers/dma/pch_dma.c+1−1

 	}
 	pci_set_master(pdev);
+	pd->dma.dev = &pdev->dev;
 	err = request_irq(pdev->irq, pd_irq, IRQF_SHARED, DRV_NAME, pd);
 	if (err) {
 		goto err_free_irq;
 	}
-	pd->dma.dev = &pdev->dev;
 	INIT_LIST_HEAD(&pd->dma.channels);

drivers/dma/tegra20-apb-dma.c+9−0

 static void tegra_dma_synchronize(struct dma_chan *dc)
 {
 	struct tegra_dma_channel *tdc = to_tegra_dma_chan(dc);
+	int err;
+	err = pm_runtime_get_sync(tdc->tdma->dev);
+	if (err < 0) {
+		dev_err(tdc2dev(tdc), "Failed to synchronize DMA: %d\n", err);
+		return;
+	}
 	/*
 	 * CPU, which handles interrupt, could be busy in
 	wait_event(tdc->wq, tegra_dma_eoc_interrupt_deasserted(tdc));
 	tasklet_kill(&tdc->tasklet);
+	pm_runtime_put(tdc->tdma->dev);
 }
 static unsigned int tegra_dma_sg_bytes_xferred(struct tegra_dma_channel *tdc,

drivers/dma/ti/k3-psil.c+1−0

@@ -27,6 +27,7 @@ struct psil_endpoint_config *psil_get_ep_config(u32 thread_id) · 26 unmodified lines
27	soc_ep_map = &j721e_ep_map;	27	soc_ep_map = &j721e_ep_map;
28	} else {	28	} else {
29	pr_err("PSIL: No compatible machine found for map\n");	29	pr_err("PSIL: No compatible machine found for map\n");
		30	mutex_unlock(&ep_map_mutex);
30	return ERR_PTR(-ENOTSUPP);	31	return ERR_PTR(-ENOTSUPP);
31	}	32	}
32	pr_debug("%s: Using map for %s\n", __func__, soc_ep_map->name);	33	pr_debug("%s: Using map for %s\n", __func__, soc_ep_map->name);

drivers/dma/xilinx/xilinx_dma.c+10−10

@@ -1230,16 +1230,16 @@ static enum dma_status xilinx_dma_tx_status(struct dma_chan *dchan, · 1229 unmodified lines
1230	return ret;	1230	return ret;
1231		1231
1232	spin_lock_irqsave(&chan->lock, flags);	1232	spin_lock_irqsave(&chan->lock, flags);
1233		1233	if (!list_empty(&chan->active_list)) {
1234	desc = list_last_entry(&chan->active_list,	1234	desc = list_last_entry(&chan->active_list,
1235	struct xilinx_dma_tx_descriptor, node);	1235	struct xilinx_dma_tx_descriptor, node);
1236	/*	1236	/*
1237	* VDMA and simple mode do not support residue reporting, so the	1237	* VDMA and simple mode do not support residue reporting, so the
1238	* residue field will always be 0.	1238	* residue field will always be 0.
1239	*/	1239	*/
1240	if (chan->has_sg && chan->xdev->dma_config->dmatype != XDMA_TYPE_VDMA)	1240	if (chan->has_sg && chan->xdev->dma_config->dmatype != XDMA_TYPE_VDMA)
1241	residue = xilinx_dma_get_residue(chan, desc);	1241	residue = xilinx_dma_get_residue(chan, desc);
1242		1242	}
1243	spin_unlock_irqrestore(&chan->lock, flags);	1243	spin_unlock_irqrestore(&chan->lock, flags);
1244		1244
1245	dma_set_residue(txstate, residue);	1245	dma_set_residue(txstate, residue);

drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c+2−1

  * - 3.34.0 - Non-DC can flip correctly between buffers with different pitches
  * - 3.35.0 - Add drm_amdgpu_info_device::tcc_disabled_mask
  * - 3.36.0 - Allow reading more status registers on si/cik
+ * - 3.37.0 - L2 is invalidated before SDMA IBs, needed for correctness
  */
 #define KMS_DRIVER_MAJOR	3
-#define KMS_DRIVER_MINOR	36
+#define KMS_DRIVER_MINOR	37
 #define KMS_DRIVER_PATCHLEVEL	0
 int amdgpu_vram_limit = 0;

drivers/gpu/drm/amd/amdgpu/navi10_sdma_pkt_open.h+16−0

@@ -73,6 +73,22 @@ · 72 unmodified lines
73	#define SDMA_OP_AQL_COPY 0	73	#define SDMA_OP_AQL_COPY 0
74	#define SDMA_OP_AQL_BARRIER_OR 0	74	#define SDMA_OP_AQL_BARRIER_OR 0
75		75
		76	#define SDMA_GCR_RANGE_IS_PA (1 << 18)
		77	#define SDMA_GCR_SEQ(x) (((x) & 0x3) << 16)
		78	#define SDMA_GCR_GL2_WB (1 << 15)
		79	#define SDMA_GCR_GL2_INV (1 << 14)
		80	#define SDMA_GCR_GL2_DISCARD (1 << 13)
		81	#define SDMA_GCR_GL2_RANGE(x) (((x) & 0x3) << 11)
		82	#define SDMA_GCR_GL2_US (1 << 10)
		83	#define SDMA_GCR_GL1_INV (1 << 9)
		84	#define SDMA_GCR_GLV_INV (1 << 8)
		85	#define SDMA_GCR_GLK_INV (1 << 7)
		86	#define SDMA_GCR_GLK_WB (1 << 6)
		87	#define SDMA_GCR_GLM_INV (1 << 5)
		88	#define SDMA_GCR_GLM_WB (1 << 4)
		89	#define SDMA_GCR_GL1_RANGE(x) (((x) & 0x3) << 2)
		90	#define SDMA_GCR_GLI_INV(x) (((x) & 0x3) << 0)
		91
76	/define for op field/	92	/define for op field/
77	#define SDMA_PKT_HEADER_op_offset 0	93	#define SDMA_PKT_HEADER_op_offset 0
78	#define SDMA_PKT_HEADER_op_mask 0x000000FF	94	#define SDMA_PKT_HEADER_op_mask 0x000000FF

drivers/gpu/drm/amd/amdgpu/sdma_v5_0.c+13−1

 	unsigned vmid = AMDGPU_JOB_GET_VMID(job);
 	uint64_t csa_mc_addr = amdgpu_sdma_get_csa_mc_addr(ring, vmid);
+	/* Invalidate L2, because if we don't do it, we might get stale cache
+	 * lines from previous IBs.
+	 */
+	amdgpu_ring_write(ring, SDMA_PKT_HEADER_OP(SDMA_OP_GCR_REQ));
+	amdgpu_ring_write(ring, 0);
+	amdgpu_ring_write(ring, (SDMA_GCR_GL2_INV |
+				 SDMA_GCR_GL2_WB |
+				 SDMA_GCR_GLM_INV |
+				 SDMA_GCR_GLM_WB) << 16);
+	amdgpu_ring_write(ring, 0xffffff80);
+	amdgpu_ring_write(ring, 0xffff);
 	/* An IB packet must end on a 8 DW boundary--the next dword
 	 * must be on a 8-dword boundary. Our IB packet below is 6
 	 * dwords long, thus add x number of NOPs, such that, in
 		SOC15_FLUSH_GPU_TLB_NUM_WREG * 3 +
 		SOC15_FLUSH_GPU_TLB_NUM_REG_WAIT * 6 * 2 +
 		10 + 10 + 10, /* sdma_v5_0_ring_emit_fence x3 for user fence, vm fence */
-	.emit_ib_size = 7 + 6, /* sdma_v5_0_ring_emit_ib */
+	.emit_ib_size = 5 + 7 + 6, /* sdma_v5_0_ring_emit_ib */
 	.emit_ib = sdma_v5_0_ring_emit_ib,
 	.emit_fence = sdma_v5_0_ring_emit_fence,
 	.emit_pipeline_sync = sdma_v5_0_ring_emit_pipeline_sync,

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c+29−9

 			  const union dc_tiling_info *tiling_info,
 			  const uint64_t info,
 			  struct dc_plane_dcc_param *dcc,
-			  struct dc_plane_address *address)
+			  struct dc_plane_address *address,
+			  bool force_disable_dcc)
 {
 	struct dc *dc = adev->dm.dc;
 	struct dc_dcc_surface_param input;
 	memset(&input, 0, sizeof(input));
 	memset(&output, 0, sizeof(output));
+	if (force_disable_dcc)
+		return 0;
 	if (!offset)
 		return 0;
 			     union dc_tiling_info *tiling_info,
 			     struct plane_size *plane_size,
 			     struct dc_plane_dcc_param *dcc,
-			     struct dc_plane_address *address)
+			     struct dc_plane_address *address,
+			     bool force_disable_dcc)
 {
 	const struct drm_framebuffer *fb = &afb->base;
 	int ret;
 		ret = fill_plane_dcc_attributes(adev, afb, format, rotation,
 						plane_size, tiling_info,
-						tiling_flags, dcc, address);
+						tiling_flags, dcc, address,
+						force_disable_dcc);
 		if (ret)
 			return ret;
 	}
 			    const struct drm_plane_state *plane_state,
 			    const uint64_t tiling_flags,
 			    struct dc_plane_info *plane_info,
-			    struct dc_plane_address *address)
+			    struct dc_plane_address *address,
+			    bool force_disable_dcc)
 {
 	const struct drm_framebuffer *fb = plane_state->fb;
 	const struct amdgpu_framebuffer *afb =
 					   plane_info->rotation, tiling_flags,
 					   &plane_info->tiling_info,
 					   &plane_info->plane_size,
-					   &plane_info->dcc, address);
+					   &plane_info->dcc, address,
+					   force_disable_dcc);
 	if (ret)
 		return ret;
 	struct dc_plane_info plane_info;
 	uint64_t tiling_flags;
 	int ret;
+	bool force_disable_dcc = false;
 	ret = fill_dc_scaling_info(plane_state, &scaling_info);
 	if (ret)
 	if (ret)
 		return ret;
+	force_disable_dcc = adev->asic_type == CHIP_RAVEN && adev->in_suspend;
 	ret = fill_dc_plane_info_and_addr(adev, plane_state, tiling_flags,
 					  &plane_info,
-					  &dc_plane_state->address);
+					  &dc_plane_state->address,
+					  force_disable_dcc);
 	if (ret)
 		return ret;
 	uint64_t tiling_flags;
 	uint32_t domain;
 	int r;
+	bool force_disable_dcc = false;
 	dm_plane_state_old = to_dm_plane_state(plane->state);
 	dm_plane_state_new = to_dm_plane_state(new_state);
 			dm_plane_state_old->dc_state != dm_plane_state_new->dc_state) {
 		struct dc_plane_state *plane_state = dm_plane_state_new->dc_state;
+		force_disable_dcc = adev->asic_type == CHIP_RAVEN && adev->in_suspend;
 		fill_plane_buffer_attributes(
 			adev, afb, plane_state->format, plane_state->rotation,
 			tiling_flags, &plane_state->tiling_info,
 			&plane_state->plane_size, &plane_state->dcc,
-			&plane_state->address);
+			&plane_state->address,
+			force_disable_dcc);
 	}
 	return 0;
 		fill_dc_plane_info_and_addr(
 			dm->adev, new_plane_state, tiling_flags,
 			&bundle->plane_infos[planes_count],
-			&bundle->flip_addrs[planes_count].address);
+			&bundle->flip_addrs[planes_count].address,
+			false);
+		DRM_DEBUG_DRIVER("plane: id=%d dcc_en=%d\n",
+				 new_plane_state->plane->index,
+				 bundle->plane_infos[planes_count].dcc.enable);
 		bundle->surface_updates[planes_count].plane_info =
 			&bundle->plane_infos[planes_count];
 				ret = fill_dc_plane_info_and_addr(
 					dm->adev, new_plane_state, tiling_flags,
 					plane_info,
-					&flip_addr->address);
+					&flip_addr->address,
+					false);
 				if (ret)
 					goto cleanup;

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

@@ -2908,6 +2908,12 @@ bool dc_link_handle_hpd_rx_irq(struct dc_link link, union hpd_irq_data out_hpd · 2907 unmodified lines
2908	sizeof(hpd_irq_dpcd_data),	2908	sizeof(hpd_irq_dpcd_data),
2909	"Status: ");	2909	"Status: ");
2910		2910
		2911	for (i = 0; i < MAX_PIPES; i++) {
		2912	pipe_ctx = &link->dc->current_state->res_ctx.pipe_ctx[i];
		2913	if (pipe_ctx && pipe_ctx->stream && pipe_ctx->stream->link == link)
		2914	link->dc->hwss.blank_stream(pipe_ctx);
		2915	}
		2916
2911	for (i = 0; i < MAX_PIPES; i++) {	2917	for (i = 0; i < MAX_PIPES; i++) {
2912	pipe_ctx = &link->dc->current_state->res_ctx.pipe_ctx[i];	2918	pipe_ctx = &link->dc->current_state->res_ctx.pipe_ctx[i];
2913	if (pipe_ctx && pipe_ctx->stream && pipe_ctx->stream->link == link)	2919	if (pipe_ctx && pipe_ctx->stream && pipe_ctx->stream->link == link)
@@ -2927,6 +2933,12 @@ bool dc_link_handle_hpd_rx_irq(struct dc_link link, union hpd_irq_data out_hpd · 13 unmodified lines
2927	if (pipe_ctx->stream->signal == SIGNAL_TYPE_DISPLAY_PORT_MST)	2933	if (pipe_ctx->stream->signal == SIGNAL_TYPE_DISPLAY_PORT_MST)
2928	dc_link_reallocate_mst_payload(link);	2934	dc_link_reallocate_mst_payload(link);
2929		2935
		2936	for (i = 0; i < MAX_PIPES; i++) {
		2937	pipe_ctx = &link->dc->current_state->res_ctx.pipe_ctx[i];
		2938	if (pipe_ctx && pipe_ctx->stream && pipe_ctx->stream->link == link)
		2939	link->dc->hwss.unblank_stream(pipe_ctx, &previous_link_settings);
		2940	}
		2941
2930	status = false;	2942	status = false;
2931	if (out_link_loss)	2943	if (out_link_loss)
2932	*out_link_loss = true;	2944	*out_link_loss = true;
@@ -4227,6 +4239,21 @@ void dp_set_fec_enable(struct dc_link *link, bool enable) · 1294 unmodified lines
4227	void dpcd_set_source_specific_data(struct dc_link *link)	4239	void dpcd_set_source_specific_data(struct dc_link *link)
4228	{	4240	{
4229	const uint32_t post_oui_delay = 30; // 30ms	4241	const uint32_t post_oui_delay = 30; // 30ms
		4242	uint8_t dspc = 0;
		4243	enum dc_status ret = DC_ERROR_UNEXPECTED;
		4244
		4245	ret = core_link_read_dpcd(link, DP_DOWN_STREAM_PORT_COUNT, &dspc,
		4246	sizeof(dspc));
		4247
		4248	if (ret != DC_OK) {
		4249	DC_LOG_ERROR("Error in DP aux read transaction,"
		4250	" not writing source specific data\n");
		4251	return;
		4252	}
		4253
		4254	/* Return if OUI unsupported */
		4255	if (!(dspc & DP_OUI_SUPPORT))
		4256	return;
4230		4257
4231	if (!link->dc->vendor_signature.is_valid) {	4258	if (!link->dc->vendor_signature.is_valid) {
4232	struct dpcd_amd_signature amd_signature;	4259	struct dpcd_amd_signature amd_signature;

drivers/gpu/drm/amd/display/dc/core/dc_stream.c+4−36

@@ -231,34 +231,6 @@ struct dc_stream_status *dc_stream_get_status( · 230 unmodified lines
231	return dc_stream_get_status_from_state(dc->current_state, stream);	231	return dc_stream_get_status_from_state(dc->current_state, stream);
232	}	232	}
233		233
234	static void delay_cursor_until_vupdate(struct pipe_ctx pipe_ctx, struct dc dc)
235	{
236	#if defined(CONFIG_DRM_AMD_DC_DCN)
237	unsigned int vupdate_line;
238	unsigned int lines_to_vupdate, us_to_vupdate, vpos, nvpos;
239	struct dc_stream_state *stream = pipe_ctx->stream;
240	unsigned int us_per_line;
241
242	if (stream->ctx->asic_id.chip_family == FAMILY_RV &&
243	ASICREV_IS_RAVEN(stream->ctx->asic_id.hw_internal_rev)) {
244
245	vupdate_line = dc->hwss.get_vupdate_offset_from_vsync(pipe_ctx);
246	if (!dc_stream_get_crtc_position(dc, &stream, 1, &vpos, &nvpos))
247	return;
248
249	if (vpos >= vupdate_line)
250	return;
251
252	us_per_line = stream->timing.h_total * 10000 / stream->timing.pix_clk_100hz;
253	lines_to_vupdate = vupdate_line - vpos;
254	us_to_vupdate = lines_to_vupdate * us_per_line;
255
256	/* 70 us is a conservative estimate of cursor update time*/
257	if (us_to_vupdate < 70)
258	udelay(us_to_vupdate);
259	}
260	#endif
261	}
262		234
263	/**	235	/**
264	* dc_stream_set_cursor_attributes() - Update cursor attributes and set cursor surface address	236	* dc_stream_set_cursor_attributes() - Update cursor attributes and set cursor surface address
@@ -298,9 +270,7 @@ bool dc_stream_set_cursor_attributes( · 33 unmodified lines
298		270
299	if (!pipe_to_program) {	271	if (!pipe_to_program) {
300	pipe_to_program = pipe_ctx;	272	pipe_to_program = pipe_ctx;
301		273	dc->hwss.cursor_lock(dc, pipe_to_program, true);
302	delay_cursor_until_vupdate(pipe_ctx, dc);
303	dc->hwss.pipe_control_lock(dc, pipe_to_program, true);
304	}	274	}
305		275
306	dc->hwss.set_cursor_attribute(pipe_ctx);	276	dc->hwss.set_cursor_attribute(pipe_ctx);
@@ -309,7 +279,7 @@ bool dc_stream_set_cursor_attributes( · 2 unmodified lines
309	}	279	}
310		280
311	if (pipe_to_program)	281	if (pipe_to_program)
312	dc->hwss.pipe_control_lock(dc, pipe_to_program, false);	282	dc->hwss.cursor_lock(dc, pipe_to_program, false);
313		283
314	return true;	284	return true;
315	}	285	}
@@ -349,16 +319,14 @@ bool dc_stream_set_cursor_position( · 33 unmodified lines
349		319
350	if (!pipe_to_program) {	320	if (!pipe_to_program) {
351	pipe_to_program = pipe_ctx;	321	pipe_to_program = pipe_ctx;
352		322	dc->hwss.cursor_lock(dc, pipe_to_program, true);
353	delay_cursor_until_vupdate(pipe_ctx, dc);
354	dc->hwss.pipe_control_lock(dc, pipe_to_program, true);
355	}	323	}
356		324
357	dc->hwss.set_cursor_position(pipe_ctx);	325	dc->hwss.set_cursor_position(pipe_ctx);
358	}	326	}
359		327
360	if (pipe_to_program)	328	if (pipe_to_program)
361	dc->hwss.pipe_control_lock(dc, pipe_to_program, false);	329	dc->hwss.cursor_lock(dc, pipe_to_program, false);
362		330
363	return true;	331	return true;
364	}	332	}

drivers/gpu/drm/amd/display/dc/dce110/dce110_hw_sequencer.c+1−0

@@ -2757,6 +2757,7 @@ static const struct hw_sequencer_funcs dce110_funcs = { · 2756 unmodified lines
2757	.disable_plane = dce110_power_down_fe,	2757	.disable_plane = dce110_power_down_fe,
2758	.pipe_control_lock = dce_pipe_control_lock,	2758	.pipe_control_lock = dce_pipe_control_lock,
2759	.interdependent_update_lock = NULL,	2759	.interdependent_update_lock = NULL,
		2760	.cursor_lock = dce_pipe_control_lock,
2760	.prepare_bandwidth = dce110_prepare_bandwidth,	2761	.prepare_bandwidth = dce110_prepare_bandwidth,
2761	.optimize_bandwidth = dce110_optimize_bandwidth,	2762	.optimize_bandwidth = dce110_optimize_bandwidth,
2762	.set_drr = set_drr,	2763	.set_drr = set_drr,

drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hw_sequencer.c+10−0

@@ -1625,6 +1625,16 @@ void dcn10_pipe_control_lock( · 1624 unmodified lines
1625	hws->funcs.verify_allow_pstate_change_high(dc);	1625	hws->funcs.verify_allow_pstate_change_high(dc);
1626	}	1626	}
1627		1627
		1628	void dcn10_cursor_lock(struct dc dc, struct pipe_ctx pipe, bool lock)
		1629	{
		1630	/* cursor lock is per MPCC tree, so only need to lock one pipe per stream */
		1631	if (!pipe \|\| pipe->top_pipe)
		1632	return;
		1633
		1634	dc->res_pool->mpc->funcs->cursor_lock(dc->res_pool->mpc,
		1635	pipe->stream_res.opp->inst, lock);
		1636	}
		1637
1628	static bool wait_for_reset_trigger_to_occur(	1638	static bool wait_for_reset_trigger_to_occur(
1629	struct dc_context *dc_ctx,	1639	struct dc_context *dc_ctx,
1630	struct timing_generator *tg)	1640	struct timing_generator *tg)

drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hw_sequencer.h+1−0

@@ -49,6 +49,7 @@ void dcn10_pipe_control_lock( · 48 unmodified lines
49	struct dc *dc,	49	struct dc *dc,
50	struct pipe_ctx *pipe,	50	struct pipe_ctx *pipe,
51	bool lock);	51	bool lock);
		52	void dcn10_cursor_lock(struct dc dc, struct pipe_ctx pipe, bool lock);
52	void dcn10_blank_pixel_data(	53	void dcn10_blank_pixel_data(
53	struct dc *dc,	54	struct dc *dc,
54	struct pipe_ctx *pipe_ctx,	55	struct pipe_ctx *pipe_ctx,

drivers/gpu/drm/amd/display/dc/dcn10/dcn10_init.c+1−0

@@ -50,6 +50,7 @@ static const struct hw_sequencer_funcs dcn10_funcs = { · 49 unmodified lines
50	.disable_audio_stream = dce110_disable_audio_stream,	50	.disable_audio_stream = dce110_disable_audio_stream,
51	.disable_plane = dcn10_disable_plane,	51	.disable_plane = dcn10_disable_plane,
52	.pipe_control_lock = dcn10_pipe_control_lock,	52	.pipe_control_lock = dcn10_pipe_control_lock,
		53	.cursor_lock = dcn10_cursor_lock,
53	.interdependent_update_lock = dcn10_lock_all_pipes,	54	.interdependent_update_lock = dcn10_lock_all_pipes,
54	.prepare_bandwidth = dcn10_prepare_bandwidth,	55	.prepare_bandwidth = dcn10_prepare_bandwidth,
55	.optimize_bandwidth = dcn10_optimize_bandwidth,	56	.optimize_bandwidth = dcn10_optimize_bandwidth,

drivers/gpu/drm/amd/display/dc/dcn10/dcn10_mpc.c+15−0

 	REG_SET(MPCC_TOP_SEL[mpcc_id], 0, MPCC_TOP_SEL, dpp_id);
 	REG_SET(MPCC_OPP_ID[mpcc_id], 0, MPCC_OPP_ID, tree->opp_id);
+	/* Configure VUPDATE lock set for this MPCC to map to the OPP */
+	REG_SET(MPCC_UPDATE_LOCK_SEL[mpcc_id], 0, MPCC_UPDATE_LOCK_SEL, tree->opp_id);
 	/* update mpc tree mux setting */
 	if (tree->opp_list == insert_above_mpcc) {
 		/* insert the toppest mpcc */
 		REG_SET(MPCC_TOP_SEL[mpcc_id], 0, MPCC_TOP_SEL, 0xf);
 		REG_SET(MPCC_BOT_SEL[mpcc_id], 0, MPCC_BOT_SEL, 0xf);
 		REG_SET(MPCC_OPP_ID[mpcc_id],  0, MPCC_OPP_ID,  0xf);
+		REG_SET(MPCC_UPDATE_LOCK_SEL[mpcc_id], 0, MPCC_UPDATE_LOCK_SEL, 0xf);
 		/* mark this mpcc as not in use */
 		mpc10->mpcc_in_use_mask &= ~(1 << mpcc_id);
 		REG_SET(MPCC_TOP_SEL[mpcc_id], 0, MPCC_TOP_SEL, 0xf);
 		REG_SET(MPCC_BOT_SEL[mpcc_id], 0, MPCC_BOT_SEL, 0xf);
 		REG_SET(MPCC_OPP_ID[mpcc_id],  0, MPCC_OPP_ID,  0xf);
+		REG_SET(MPCC_UPDATE_LOCK_SEL[mpcc_id], 0, MPCC_UPDATE_LOCK_SEL, 0xf);
 	}
 }
 		REG_SET(MPCC_TOP_SEL[mpcc_id], 0, MPCC_TOP_SEL, 0xf);
 		REG_SET(MPCC_BOT_SEL[mpcc_id], 0, MPCC_BOT_SEL, 0xf);
 		REG_SET(MPCC_OPP_ID[mpcc_id],  0, MPCC_OPP_ID,  0xf);
+		REG_SET(MPCC_UPDATE_LOCK_SEL[mpcc_id], 0, MPCC_UPDATE_LOCK_SEL, 0xf);
 		mpc1_init_mpcc(&(mpc->mpcc_array[mpcc_id]), mpcc_id);
 	}
 	REG_SET(MPCC_TOP_SEL[mpcc_id], 0, MPCC_TOP_SEL, 0xf);
 	REG_SET(MPCC_BOT_SEL[mpcc_id], 0, MPCC_BOT_SEL, 0xf);
 	REG_SET(MPCC_OPP_ID[mpcc_id],  0, MPCC_OPP_ID,  0xf);
+	REG_SET(MPCC_UPDATE_LOCK_SEL[mpcc_id], 0, MPCC_UPDATE_LOCK_SEL, 0xf);
 	mpc1_init_mpcc(&(mpc->mpcc_array[mpcc_id]), mpcc_id);
 			MPCC_BUSY, &s->busy);
 }
+void mpc1_cursor_lock(struct mpc *mpc, int opp_id, bool lock)
+{
+	struct dcn10_mpc *mpc10 = TO_DCN10_MPC(mpc);
+	REG_SET(CUR[opp_id], 0, CUR_VUPDATE_LOCK_SET, lock ? 1 : 0);
+}
 static const struct mpc_funcs dcn10_mpc_funcs = {
 	.read_mpcc_state = mpc1_read_mpcc_state,
 	.insert_plane = mpc1_insert_plane,
 	.assert_mpcc_idle_before_connect = mpc1_assert_mpcc_idle_before_connect,
 	.init_mpcc_list_from_hw = mpc1_init_mpcc_list_from_hw,
 	.update_blending = mpc1_update_blending,
+	.cursor_lock = mpc1_cursor_lock,
 	.set_denorm = NULL,
 	.set_denorm_clamp = NULL,
 	.set_output_csc = NULL,

drivers/gpu/drm/amd/display/dc/dcn10/dcn10_mpc.h+14−6

 	SRII(MPCC_BG_G_Y, MPCC, inst),\
 	SRII(MPCC_BG_R_CR, MPCC, inst),\
 	SRII(MPCC_BG_B_CB, MPCC, inst),\
-	SRII(MPCC_BG_B_CB, MPCC, inst),\
+	SRII(MPCC_SM_CONTROL, MPCC, inst),\
-	SRII(MPCC_SM_CONTROL, MPCC, inst)
+	SRII(MPCC_UPDATE_LOCK_SEL, MPCC, inst)
 #define MPC_OUT_MUX_COMMON_REG_LIST_DCN1_0(inst) \
-	SRII(MUX, MPC_OUT, inst)
+	SRII(MUX, MPC_OUT, inst),\
+	VUPDATE_SRII(CUR, VUPDATE_LOCK_SET, inst)
 #define MPC_COMMON_REG_VARIABLE_LIST \
 	uint32_t MPCC_TOP_SEL[MAX_MPCC]; \
 	uint32_t MPCC_BG_R_CR[MAX_MPCC]; \
 	uint32_t MPCC_BG_B_CB[MAX_MPCC]; \
 	uint32_t MPCC_SM_CONTROL[MAX_MPCC]; \
-	uint32_t MUX[MAX_OPP];
+	uint32_t MUX[MAX_OPP]; \
+	uint32_t MPCC_UPDATE_LOCK_SEL[MAX_MPCC]; \
+	uint32_t CUR[MAX_OPP];
 #define MPC_COMMON_MASK_SH_LIST_DCN1_0(mask_sh)\
 	SF(MPCC0_MPCC_TOP_SEL, MPCC_TOP_SEL, mask_sh),\
 	SF(MPCC0_MPCC_SM_CONTROL, MPCC_SM_FIELD_ALT, mask_sh),\
 	SF(MPCC0_MPCC_SM_CONTROL, MPCC_SM_FORCE_NEXT_FRAME_POL, mask_sh),\
 	SF(MPCC0_MPCC_SM_CONTROL, MPCC_SM_FORCE_NEXT_TOP_POL, mask_sh),\
-	SF(MPC_OUT0_MUX, MPC_OUT_MUX, mask_sh)
+	SF(MPC_OUT0_MUX, MPC_OUT_MUX, mask_sh),\
+	SF(MPCC0_MPCC_UPDATE_LOCK_SEL, MPCC_UPDATE_LOCK_SEL, mask_sh)
 #define MPC_REG_FIELD_LIST(type) \
 	type MPCC_TOP_SEL;\
 	type MPCC_SM_FIELD_ALT;\
 	type MPCC_SM_FORCE_NEXT_FRAME_POL;\
 	type MPCC_SM_FORCE_NEXT_TOP_POL;\
-	type MPC_OUT_MUX;
+	type MPC_OUT_MUX;\
+	type MPCC_UPDATE_LOCK_SEL;\
+	type CUR_VUPDATE_LOCK_SET;
 struct dcn_mpc_registers {
 	MPC_COMMON_REG_VARIABLE_LIST
 		int mpcc_inst,
 		struct mpcc_state *s);
+void mpc1_cursor_lock(struct mpc *mpc, int opp_id, bool lock);
 #endif

drivers/gpu/drm/amd/display/dc/dcn10/dcn10_resource.c+12−2

 	.reg_name[id] = BASE(mm ## block ## id ## _ ## reg_name ## _BASE_IDX) + \
 					mm ## block ## id ## _ ## reg_name
+#define VUPDATE_SRII(reg_name, block, id)\
+	.reg_name[id] = BASE(mm ## reg_name ## 0 ## _ ## block ## id ## _BASE_IDX) + \
+					mm ## reg_name ## 0 ## _ ## block ## id
+/* set field/register/bitfield name */
+#define SFRB(field_name, reg_name, bitfield, post_fix)\
+	.field_name = reg_name ## __ ## bitfield ## post_fix
 /* NBIO */
 #define NBIO_BASE_INNER(seg) \
 	NBIF_BASE__INST0_SEG ## seg
 };
 static const struct dcn_mpc_shift mpc_shift = {
-	MPC_COMMON_MASK_SH_LIST_DCN1_0(__SHIFT)
+	MPC_COMMON_MASK_SH_LIST_DCN1_0(__SHIFT),\
+	SFRB(CUR_VUPDATE_LOCK_SET, CUR0_VUPDATE_LOCK_SET0, CUR0_VUPDATE_LOCK_SET, __SHIFT)
 };
 static const struct dcn_mpc_mask mpc_mask = {
-	MPC_COMMON_MASK_SH_LIST_DCN1_0(_MASK),
+	MPC_COMMON_MASK_SH_LIST_DCN1_0(_MASK),\
+	SFRB(CUR_VUPDATE_LOCK_SET, CUR0_VUPDATE_LOCK_SET0, CUR0_VUPDATE_LOCK_SET, _MASK)
 };
 #define tg_regs(id)\

drivers/gpu/drm/amd/display/dc/dcn20/dcn20_hwseq.c+2−1

@@ -2294,7 +2294,8 @@ void dcn20_fpga_init_hw(struct dc *dc) · 2293 unmodified lines
2294		2294
2295	REG_UPDATE(DCHUBBUB_GLOBAL_TIMER_CNTL, DCHUBBUB_GLOBAL_TIMER_REFDIV, 2);	2295	REG_UPDATE(DCHUBBUB_GLOBAL_TIMER_CNTL, DCHUBBUB_GLOBAL_TIMER_REFDIV, 2);
2296	REG_UPDATE(DCHUBBUB_GLOBAL_TIMER_CNTL, DCHUBBUB_GLOBAL_TIMER_ENABLE, 1);	2296	REG_UPDATE(DCHUBBUB_GLOBAL_TIMER_CNTL, DCHUBBUB_GLOBAL_TIMER_ENABLE, 1);
2297	REG_WRITE(REFCLK_CNTL, 0);	2297	if (REG(REFCLK_CNTL))
		2298	REG_WRITE(REFCLK_CNTL, 0);
2298	//	2299	//
2299		2300
2300		2301

drivers/gpu/drm/amd/display/dc/dcn20/dcn20_init.c+1−0

@@ -52,6 +52,7 @@ static const struct hw_sequencer_funcs dcn20_funcs = { · 51 unmodified lines
52	.disable_plane = dcn20_disable_plane,	52	.disable_plane = dcn20_disable_plane,
53	.pipe_control_lock = dcn20_pipe_control_lock,	53	.pipe_control_lock = dcn20_pipe_control_lock,
54	.interdependent_update_lock = dcn10_lock_all_pipes,	54	.interdependent_update_lock = dcn10_lock_all_pipes,
		55	.cursor_lock = dcn10_cursor_lock,
55	.prepare_bandwidth = dcn20_prepare_bandwidth,	56	.prepare_bandwidth = dcn20_prepare_bandwidth,
56	.optimize_bandwidth = dcn20_optimize_bandwidth,	57	.optimize_bandwidth = dcn20_optimize_bandwidth,
57	.update_bandwidth = dcn20_update_bandwidth,	58	.update_bandwidth = dcn20_update_bandwidth,

drivers/gpu/drm/amd/display/dc/dcn20/dcn20_mpc.c+1−0

@@ -545,6 +545,7 @@ const struct mpc_funcs dcn20_mpc_funcs = { · 544 unmodified lines
545	.mpc_init = mpc1_mpc_init,	545	.mpc_init = mpc1_mpc_init,
546	.mpc_init_single_inst = mpc1_mpc_init_single_inst,	546	.mpc_init_single_inst = mpc1_mpc_init_single_inst,
547	.update_blending = mpc2_update_blending,	547	.update_blending = mpc2_update_blending,
		548	.cursor_lock = mpc1_cursor_lock,
548	.get_mpcc_for_dpp = mpc2_get_mpcc_for_dpp,	549	.get_mpcc_for_dpp = mpc2_get_mpcc_for_dpp,
549	.wait_for_idle = mpc2_assert_idle_mpcc,	550	.wait_for_idle = mpc2_assert_idle_mpcc,
550	.assert_mpcc_idle_before_connect = mpc2_assert_mpcc_idle_before_connect,	551	.assert_mpcc_idle_before_connect = mpc2_assert_mpcc_idle_before_connect,

drivers/gpu/drm/amd/display/dc/dcn20/dcn20_mpc.h+2−1

@@ -179,7 +179,8 @@ · 178 unmodified lines
179	SF(MPC_OUT0_DENORM_CLAMP_G_Y, MPC_OUT_DENORM_CLAMP_MAX_G_Y, mask_sh),\	179	SF(MPC_OUT0_DENORM_CLAMP_G_Y, MPC_OUT_DENORM_CLAMP_MAX_G_Y, mask_sh),\
180	SF(MPC_OUT0_DENORM_CLAMP_G_Y, MPC_OUT_DENORM_CLAMP_MIN_G_Y, mask_sh),\	180	SF(MPC_OUT0_DENORM_CLAMP_G_Y, MPC_OUT_DENORM_CLAMP_MIN_G_Y, mask_sh),\
181	SF(MPC_OUT0_DENORM_CLAMP_B_CB, MPC_OUT_DENORM_CLAMP_MAX_B_CB, mask_sh),\	181	SF(MPC_OUT0_DENORM_CLAMP_B_CB, MPC_OUT_DENORM_CLAMP_MAX_B_CB, mask_sh),\
182	SF(MPC_OUT0_DENORM_CLAMP_B_CB, MPC_OUT_DENORM_CLAMP_MIN_B_CB, mask_sh)	182	SF(MPC_OUT0_DENORM_CLAMP_B_CB, MPC_OUT_DENORM_CLAMP_MIN_B_CB, mask_sh),\
		183	SF(CUR_VUPDATE_LOCK_SET0, CUR_VUPDATE_LOCK_SET, mask_sh)
183		184
184	/*	185	/*
185	* DCN2 MPC_OCSC debug status register:	186	* DCN2 MPC_OCSC debug status register:

drivers/gpu/drm/amd/display/dc/dcn20/dcn20_resource.c+4−0

 	.block ## _ ## reg_name[id] = BASE(mm ## block ## id ## _ ## reg_name ## _BASE_IDX) + \
 					mm ## block ## id ## _ ## reg_name
+#define VUPDATE_SRII(reg_name, block, id)\
+	.reg_name[id] = BASE(mm ## reg_name ## _ ## block ## id ## _BASE_IDX) + \
+					mm ## reg_name ## _ ## block ## id
 /* NBIO */
 #define NBIO_BASE_INNER(seg) \
 	NBIO_BASE__INST0_SEG ## seg

drivers/gpu/drm/amd/display/dc/dcn21/dcn21_init.c+1−0

@@ -53,6 +53,7 @@ static const struct hw_sequencer_funcs dcn21_funcs = { · 52 unmodified lines
53	.disable_plane = dcn20_disable_plane,	53	.disable_plane = dcn20_disable_plane,
54	.pipe_control_lock = dcn20_pipe_control_lock,	54	.pipe_control_lock = dcn20_pipe_control_lock,
55	.interdependent_update_lock = dcn10_lock_all_pipes,	55	.interdependent_update_lock = dcn10_lock_all_pipes,
		56	.cursor_lock = dcn10_cursor_lock,
56	.prepare_bandwidth = dcn20_prepare_bandwidth,	57	.prepare_bandwidth = dcn20_prepare_bandwidth,
57	.optimize_bandwidth = dcn20_optimize_bandwidth,	58	.optimize_bandwidth = dcn20_optimize_bandwidth,
58	.update_bandwidth = dcn20_update_bandwidth,	59	.update_bandwidth = dcn20_update_bandwidth,

drivers/gpu/drm/amd/display/dc/dcn21/dcn21_resource.c+33−44

@@ -284,7 +284,7 @@ struct _vcs_dpi_soc_bounding_box_st dcn2_1_soc = { · 283 unmodified lines
284	.dram_channel_width_bytes = 4,	284	.dram_channel_width_bytes = 4,
285	.fabric_datapath_to_dcn_data_return_bytes = 32,	285	.fabric_datapath_to_dcn_data_return_bytes = 32,
286	.dcn_downspread_percent = 0.5,	286	.dcn_downspread_percent = 0.5,
287	.downspread_percent = 0.5,	287	.downspread_percent = 0.38,
288	.dram_page_open_time_ns = 50.0,	288	.dram_page_open_time_ns = 50.0,
289	.dram_rw_turnaround_time_ns = 17.5,	289	.dram_rw_turnaround_time_ns = 17.5,
290	.dram_return_buffer_per_channel_bytes = 8192,	290	.dram_return_buffer_per_channel_bytes = 8192,
@@ -340,6 +340,10 @@ struct _vcs_dpi_soc_bounding_box_st dcn2_1_soc = { · 49 unmodified lines
340	.block ## _ ## reg_name[id] = BASE(mm ## block ## id ## _ ## reg_name ## _BASE_IDX) + \	340	.block ## _ ## reg_name[id] = BASE(mm ## block ## id ## _ ## reg_name ## _BASE_IDX) + \
341	mm ## block ## id ## _ ## reg_name	341	mm ## block ## id ## _ ## reg_name
342		342
		343	#define VUPDATE_SRII(reg_name, block, id)\
		344	.reg_name[id] = BASE(mm ## reg_name ## _ ## block ## id ## _BASE_IDX) + \
		345	mm ## reg_name ## _ ## block ## id
		346
343	/* NBIO */	347	/* NBIO */
344	#define NBIO_BASE_INNER(seg) \	348	#define NBIO_BASE_INNER(seg) \
345	NBIF0_BASE__INST0_SEG ## seg	349	NBIF0_BASE__INST0_SEG ## seg
@@ -1374,64 +1378,49 @@ static void update_bw_bounding_box(struct dc dc, struct clk_bw_params bw_param · 1028 unmodified lines
1374	{	1378	{
1375	struct dcn21_resource_pool *pool = TO_DCN21_RES_POOL(dc->res_pool);	1379	struct dcn21_resource_pool *pool = TO_DCN21_RES_POOL(dc->res_pool);
1376	struct clk_limit_table *clk_table = &bw_params->clk_table;	1380	struct clk_limit_table *clk_table = &bw_params->clk_table;
1377	unsigned int i, j, k;	1381	struct _vcs_dpi_voltage_scaling_st clock_limits[DC__VOLTAGE_STATES];
1378	int closest_clk_lvl;	1382	unsigned int i, j, closest_clk_lvl;
1379		1383
1380	// Default clock levels are used for diags, which may lead to overclocking.	1384	// Default clock levels are used for diags, which may lead to overclocking.
1381	if (!IS_FPGA_MAXIMUS_DC(dc->ctx->dce_environment) && !IS_DIAG_DC(dc->ctx->dce_environment)) {	1385	if (!IS_DIAG_DC(dc->ctx->dce_environment)) {
1382	dcn2_1_ip.max_num_otg = pool->base.res_cap->num_timing_generator;	1386	dcn2_1_ip.max_num_otg = pool->base.res_cap->num_timing_generator;
1383	dcn2_1_ip.max_num_dpp = pool->base.pipe_count;	1387	dcn2_1_ip.max_num_dpp = pool->base.pipe_count;
1384	dcn2_1_soc.num_chans = bw_params->num_channels;	1388	dcn2_1_soc.num_chans = bw_params->num_channels;
1385		1389
1386	/* Vmin: leave lowest DCN clocks, override with dcfclk, fclk, memclk from fuse */	1390	ASSERT(clk_table->num_entries);
1387	dcn2_1_soc.clock_limits[0].state = 0;	1391	for (i = 0; i < clk_table->num_entries; i++) {
1388	dcn2_1_soc.clock_limits[0].dcfclk_mhz = clk_table->entries[0].dcfclk_mhz;	1392	/* loop backwards*/
1389	dcn2_1_soc.clock_limits[0].fabricclk_mhz = clk_table->entries[0].fclk_mhz;	1393	for (closest_clk_lvl = 0, j = dcn2_1_soc.num_states - 1; j >= 0; j--) {
1390	dcn2_1_soc.clock_limits[0].socclk_mhz = clk_table->entries[0].socclk_mhz;
1391	dcn2_1_soc.clock_limits[0].dram_speed_mts = clk_table->entries[0].memclk_mhz * 2;
1392
1393	/*
1394	* Other levels: find closest DCN clocks that fit the given clock limit using dcfclk
1395	* as indicator
1396	*/
1397
1398	closest_clk_lvl = -1;
1399	/* index currently being filled */
1400	k = 1;
1401	for (i = 1; i < clk_table->num_entries; i++) {
1402	/* loop backwards, skip duplicate state*/
1403	for (j = dcn2_1_soc.num_states - 1; j >= k; j--) {
1404	if ((unsigned int) dcn2_1_soc.clock_limits[j].dcfclk_mhz <= clk_table->entries[i].dcfclk_mhz) {	1394	if ((unsigned int) dcn2_1_soc.clock_limits[j].dcfclk_mhz <= clk_table->entries[i].dcfclk_mhz) {
1405	closest_clk_lvl = j;	1395	closest_clk_lvl = j;
1406	break;	1396	break;
1407	}	1397	}
1408	}	1398	}
1409		1399
1410	/* if found a lvl that fits, use the DCN clks from it, if not, go to next clk limit*/	1400	clock_limits[i].state = i;
1411	if (closest_clk_lvl != -1) {	1401	clock_limits[i].dcfclk_mhz = clk_table->entries[i].dcfclk_mhz;
1412	dcn2_1_soc.clock_limits[k].state = i;	1402	clock_limits[i].fabricclk_mhz = clk_table->entries[i].fclk_mhz;
1413	dcn2_1_soc.clock_limits[k].dcfclk_mhz = clk_table->entries[i].dcfclk_mhz;	1403	clock_limits[i].socclk_mhz = clk_table->entries[i].socclk_mhz;
1414	dcn2_1_soc.clock_limits[k].fabricclk_mhz = clk_table->entries[i].fclk_mhz;	1404	clock_limits[i].dram_speed_mts = clk_table->entries[i].memclk_mhz * 2;
1415	dcn2_1_soc.clock_limits[k].socclk_mhz = clk_table->entries[i].socclk_mhz;	1405
1416	dcn2_1_soc.clock_limits[k].dram_speed_mts = clk_table->entries[i].memclk_mhz * 2;	1406	clock_limits[i].dispclk_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].dispclk_mhz;
1417		1407	clock_limits[i].dppclk_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].dppclk_mhz;
1418	dcn2_1_soc.clock_limits[k].dispclk_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].dispclk_mhz;	1408	clock_limits[i].dram_bw_per_chan_gbps = dcn2_1_soc.clock_limits[closest_clk_lvl].dram_bw_per_chan_gbps;
1419	dcn2_1_soc.clock_limits[k].dppclk_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].dppclk_mhz;	1409	clock_limits[i].dscclk_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].dscclk_mhz;
1420	dcn2_1_soc.clock_limits[k].dram_bw_per_chan_gbps = dcn2_1_soc.clock_limits[closest_clk_lvl].dram_bw_per_chan_gbps;	1410	clock_limits[i].dtbclk_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].dtbclk_mhz;
1421	dcn2_1_soc.clock_limits[k].dscclk_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].dscclk_mhz;	1411	clock_limits[i].phyclk_d18_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].phyclk_d18_mhz;
1422	dcn2_1_soc.clock_limits[k].dtbclk_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].dtbclk_mhz;	1412	clock_limits[i].phyclk_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].phyclk_mhz;
1423	dcn2_1_soc.clock_limits[k].phyclk_d18_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].phyclk_d18_mhz;	1413	}
1424	dcn2_1_soc.clock_limits[k].phyclk_mhz = dcn2_1_soc.clock_limits[closest_clk_lvl].phyclk_mhz;	1414	for (i = 0; i < clk_table->num_entries; i++)
1425	k++;	1415	dcn2_1_soc.clock_limits[i] = clock_limits[i];
1426	}	1416	if (clk_table->num_entries) {
		1417	dcn2_1_soc.num_states = clk_table->num_entries;
		1418	/* duplicate last level */
		1419	dcn2_1_soc.clock_limits[dcn2_1_soc.num_states] = dcn2_1_soc.clock_limits[dcn2_1_soc.num_states - 1];
		1420	dcn2_1_soc.clock_limits[dcn2_1_soc.num_states].state = dcn2_1_soc.num_states;
1427	}	1421	}
1428	dcn2_1_soc.num_states = k;
1429	}	1422	}
1430		1423
1431	/* duplicate last level */
1432	dcn2_1_soc.clock_limits[dcn2_1_soc.num_states] = dcn2_1_soc.clock_limits[dcn2_1_soc.num_states - 1];
1433	dcn2_1_soc.clock_limits[dcn2_1_soc.num_states].state = dcn2_1_soc.num_states;
1434
1435	dml_init_instance(&dc->dml, &dcn2_1_soc, &dcn2_1_ip, DML_PROJECT_DCN21);	1424	dml_init_instance(&dc->dml, &dcn2_1_soc, &dcn2_1_ip, DML_PROJECT_DCN21);
1436	}	1425	}
1437		1426

drivers/gpu/drm/amd/display/dc/inc/hw/mpc.h+16−0

@@ -210,6 +210,22 @@ struct mpc_funcs { · 209 unmodified lines
210	struct mpcc_blnd_cfg *blnd_cfg,	210	struct mpcc_blnd_cfg *blnd_cfg,
211	int mpcc_id);	211	int mpcc_id);
212		212
		213	/*
		214	* Lock cursor updates for the specified OPP.
		215	* OPP defines the set of MPCC that are locked together for cursor.
		216	*
		217	* Parameters:
		218	* [in] mpc - MPC context.
		219	* [in] opp_id - The OPP to lock cursor updates on
		220	* [in] lock - lock/unlock the OPP
		221	*
		222	* Return: void
		223	*/
		224	void (*cursor_lock)(
		225	struct mpc *mpc,
		226	int opp_id,
		227	bool lock);
		228
213	struct mpcc* (*get_mpcc_for_dpp)(	229	struct mpcc* (*get_mpcc_for_dpp)(
214	struct mpc_tree *tree,	230	struct mpc_tree *tree,
215	int dpp_id);	231	int dpp_id);

drivers/gpu/drm/amd/display/dc/inc/hw_sequencer.h+1−0

@@ -86,6 +86,7 @@ struct hw_sequencer_funcs { · 85 unmodified lines
86	struct dc_state *context, bool lock);	86	struct dc_state *context, bool lock);
87	void (set_flip_control_gsl)(struct pipe_ctx pipe_ctx,	87	void (set_flip_control_gsl)(struct pipe_ctx pipe_ctx,
88	bool flip_immediate);	88	bool flip_immediate);
		89	void (cursor_lock)(struct dc dc, struct pipe_ctx *pipe, bool lock);
89		90
90	/* Timing Related */	91	/* Timing Related */
91	void (get_position)(struct pipe_ctx *pipe_ctx, int num_pipes,	92	void (get_position)(struct pipe_ctx *pipe_ctx, int num_pipes,

drivers/gpu/drm/amd/powerplay/amd_powerplay.c+5−4

 	if (!hwmgr)
 		return -EINVAL;
-	if (!hwmgr->pm_en || !hwmgr->hwmgr_func->get_asic_baco_capability)
+	if (!(hwmgr->not_vf && amdgpu_dpm) ||
+		!hwmgr->hwmgr_func->get_asic_baco_capability)
 		return 0;
 	mutex_lock(&hwmgr->smu_lock);
 	if (!hwmgr)
 		return -EINVAL;
-	if (!(hwmgr->not_vf && amdgpu_dpm) ||
+	if (!hwmgr->pm_en || !hwmgr->hwmgr_func->get_asic_baco_state)
-		!hwmgr->hwmgr_func->get_asic_baco_state)
 		return 0;
 	mutex_lock(&hwmgr->smu_lock);
 	if (!hwmgr)
 		return -EINVAL;
-	if (!hwmgr->pm_en || !hwmgr->hwmgr_func->set_asic_baco_state)
+	if (!(hwmgr->not_vf && amdgpu_dpm) ||
+		!hwmgr->hwmgr_func->set_asic_baco_state)
 		return 0;
 	mutex_lock(&hwmgr->smu_lock);

drivers/gpu/drm/drm_dp_mst_topology.c+6−2

 	drm_dp_queue_down_tx(mgr, txmsg);
 	ret = drm_dp_mst_wait_tx_reply(mstb, txmsg);
-	if (ret > 0 && txmsg->reply.reply_type == DP_SIDEBAND_REPLY_NAK)
+	if (ret > 0) {
-		ret = -EIO;
+		if (txmsg->reply.reply_type == DP_SIDEBAND_REPLY_NAK)
+			ret = -EIO;
+		else
+			ret = size;
+	}
 	kfree(txmsg);
 fail_put:

drivers/gpu/drm/drm_edid.c+1−1

@@ -5111,7 +5111,7 @@ static struct drm_display_mode drm_mode_displayid_detailed(struct drm_device d · 5110 unmodified lines
5111	struct drm_display_mode *mode;	5111	struct drm_display_mode *mode;
5112	unsigned pixel_clock = (timings->pixel_clock[0] \|	5112	unsigned pixel_clock = (timings->pixel_clock[0] \|
5113	(timings->pixel_clock[1] << 8) \|	5113	(timings->pixel_clock[1] << 8) \|
5114	(timings->pixel_clock[2] << 16));	5114	(timings->pixel_clock[2] << 16)) + 1;
5115	unsigned hactive = (timings->hactive[0] \| timings->hactive[1] << 8) + 1;	5115	unsigned hactive = (timings->hactive[0] \| timings->hactive[1] << 8) + 1;
5116	unsigned hblank = (timings->hblank[0] \| timings->hblank[1] << 8) + 1;	5116	unsigned hblank = (timings->hblank[0] \| timings->hblank[1] << 8) + 1;
5117	unsigned hsync = (timings->hsync[0] \| (timings->hsync[1] & 0x7f) << 8) + 1;	5117	unsigned hsync = (timings->hsync[0] \| (timings->hsync[1] & 0x7f) << 8) + 1;

drivers/gpu/drm/i915/gem/i915_gem_tiling.c+18−2

 			      int tiling_mode, unsigned int stride)
 {
 	struct i915_ggtt *ggtt = &to_i915(obj->base.dev)->ggtt;
-	struct i915_vma *vma;
+	struct i915_vma *vma, *vn;
+	LIST_HEAD(unbind);
 	int ret = 0;
 	if (tiling_mode == I915_TILING_NONE)
 		return 0;
 	mutex_lock(&ggtt->vm.mutex);
+	spin_lock(&obj->vma.lock);
 	for_each_ggtt_vma(vma, obj) {
+		GEM_BUG_ON(vma->vm != &ggtt->vm);
 		if (i915_vma_fence_prepare(vma, tiling_mode, stride))
 			continue;
+		list_move(&vma->vm_link, &unbind);
+	}
+	spin_unlock(&obj->vma.lock);
+	list_for_each_entry_safe(vma, vn, &unbind, vm_link) {
 		ret = __i915_vma_unbind(vma);
-		if (ret)
+		if (ret) {
+			/* Restore the remaining vma on an error */
+			list_splice(&unbind, &ggtt->vm.bound_list);
 			break;
+		}
 	}
 	mutex_unlock(&ggtt->vm.mutex);
 	return ret;
 	}
 	mutex_unlock(&obj->mm.lock);
+	spin_lock(&obj->vma.lock);
 	for_each_ggtt_vma(vma, obj) {
 		vma->fence_size =
 			i915_gem_fence_size(i915, vma->size, tiling, stride);
 		if (vma->fence)
 			vma->fence->dirty = true;
 	}
+	spin_unlock(&obj->vma.lock);
 	obj->tiling_and_stride = tiling | stride;
 	i915_gem_object_unlock(obj);

drivers/gpu/drm/i915/gem/selftests/huge_pages.c+8−4

 		unsigned int page_size = BIT(first);
 		obj = i915_gem_object_create_internal(dev_priv, page_size);
-		if (IS_ERR(obj))
+		if (IS_ERR(obj)) {
-			return PTR_ERR(obj);
+			err = PTR_ERR(obj);
+			goto out_vm;
+		}
 		vma = i915_vma_instance(obj, vm, NULL);
 		if (IS_ERR(vma)) {
 	}
 	obj = i915_gem_object_create_internal(dev_priv, PAGE_SIZE);
-	if (IS_ERR(obj))
+	if (IS_ERR(obj)) {
-		return PTR_ERR(obj);
+		err = PTR_ERR(obj);
+		goto out_vm;
+	}
 	vma = i915_vma_instance(obj, vm, NULL);
 	if (IS_ERR(vma)) {

drivers/gpu/drm/i915/gt/intel_timeline.c+2−0

@@ -521,6 +521,8 @@ int intel_timeline_read_hwsp(struct i915_request *from, · 520 unmodified lines
521		521
522	rcu_read_lock();	522	rcu_read_lock();
523	cl = rcu_dereference(from->hwsp_cacheline);	523	cl = rcu_dereference(from->hwsp_cacheline);
		524	if (i915_request_completed(from)) /* confirm cacheline is valid */
		525	goto unlock;
524	if (unlikely(!i915_active_acquire_if_busy(&cl->active)))	526	if (unlikely(!i915_active_acquire_if_busy(&cl->active)))
525	goto unlock; /* seqno wrapped and completed! */	527	goto unlock; /* seqno wrapped and completed! */
526	if (unlikely(i915_request_completed(from)))	528	if (unlikely(i915_request_completed(from)))

drivers/gpu/drm/i915/i915_irq.c+2−4

 {
 	struct intel_uncore *uncore = &dev_priv->uncore;
-	u32 de_pipe_masked = GEN8_PIPE_CDCLK_CRC_DONE;
+	u32 de_pipe_masked = gen8_de_pipe_fault_mask(dev_priv) |
+		GEN8_PIPE_CDCLK_CRC_DONE;
 	u32 de_pipe_enables;
 	u32 de_port_masked = GEN8_AUX_CHANNEL_A;
 	u32 de_port_enables;
 		de_misc_masked |= GEN8_DE_MISC_GSE;
 	if (INTEL_GEN(dev_priv) >= 9) {
-		de_pipe_masked |= GEN9_DE_PIPE_IRQ_FAULT_ERRORS;
 		de_port_masked |= GEN9_AUX_CHANNEL_B | GEN9_AUX_CHANNEL_C |
 				  GEN9_AUX_CHANNEL_D;
 		if (IS_GEN9_LP(dev_priv))
 			de_port_masked |= BXT_DE_PORT_GMBUS;
-	} else {
-		de_pipe_masked |= GEN8_DE_PIPE_IRQ_FAULT_ERRORS;
 	}
 	if (INTEL_GEN(dev_priv) >= 11)

drivers/gpu/drm/i915/i915_vma.c+6−4

 	GEM_BUG_ON(!IS_ALIGNED(vma->size, I915_GTT_PAGE_SIZE));
+	spin_lock(&obj->vma.lock);
 	if (i915_is_ggtt(vm)) {
 		if (unlikely(overflows_type(vma->size, u32)))
-			goto err_vma;
+			goto err_unlock;
 		vma->fence_size = i915_gem_fence_size(vm->i915, vma->size,
 						      i915_gem_object_get_tiling(obj),
 						      i915_gem_object_get_stride(obj));
 		if (unlikely(vma->fence_size < vma->size || /* overflow */
 			     vma->fence_size > vm->total))
-			goto err_vma;
+			goto err_unlock;
 		GEM_BUG_ON(!IS_ALIGNED(vma->fence_size, I915_GTT_MIN_ALIGNMENT));
 		__set_bit(I915_VMA_GGTT_BIT, __i915_vma_flags(vma));
 	}
-	spin_lock(&obj->vma.lock);
 	rb = NULL;
 	p = &obj->vma.tree.rb_node;
 	while (*p) {
 	return vma;
+err_unlock:
+	spin_unlock(&obj->vma.lock);
 err_vma:
 	i915_vma_free(vma);
 	return ERR_PTR(-E2BIG);

drivers/gpu/drm/qxl/qxl_cmd.c+5−5

@@ -480,9 +480,10 @@ int qxl_hw_surface_alloc(struct qxl_device *qdev, · 479 unmodified lines
480	return ret;	480	return ret;
481		481
482	ret = qxl_release_reserve_list(release, true);	482	ret = qxl_release_reserve_list(release, true);
483	if (ret)	483	if (ret) {
		484	qxl_release_free(qdev, release);
484	return ret;	485	return ret;
485		486	}
486	cmd = (struct qxl_surface_cmd *)qxl_release_map(qdev, release);	487	cmd = (struct qxl_surface_cmd *)qxl_release_map(qdev, release);
487	cmd->type = QXL_SURFACE_CMD_CREATE;	488	cmd->type = QXL_SURFACE_CMD_CREATE;
488	cmd->flags = QXL_SURF_FLAG_KEEP_DATA;	489	cmd->flags = QXL_SURF_FLAG_KEEP_DATA;
@@ -499,8 +500,8 @@ int qxl_hw_surface_alloc(struct qxl_device *qdev, · 10 unmodified lines
499	/* no need to add a release to the fence for this surface bo,	500	/* no need to add a release to the fence for this surface bo,
500	since it is only released when we ask to destroy the surface	501	since it is only released when we ask to destroy the surface
501	and it would never signal otherwise */	502	and it would never signal otherwise */
502	qxl_push_command_ring_release(qdev, release, QXL_CMD_SURFACE, false);
503	qxl_release_fence_buffer_objects(release);	503	qxl_release_fence_buffer_objects(release);
		504	qxl_push_command_ring_release(qdev, release, QXL_CMD_SURFACE, false);
504		505
505	surf->hw_surf_alloc = true;	506	surf->hw_surf_alloc = true;
506	spin_lock(&qdev->surf_id_idr_lock);	507	spin_lock(&qdev->surf_id_idr_lock);
@@ -542,9 +543,8 @@ int qxl_hw_surface_dealloc(struct qxl_device *qdev, · 35 unmodified lines
542	cmd->surface_id = id;	543	cmd->surface_id = id;
543	qxl_release_unmap(qdev, release, &cmd->release_info);	544	qxl_release_unmap(qdev, release, &cmd->release_info);
544		545
545	qxl_push_command_ring_release(qdev, release, QXL_CMD_SURFACE, false);
546
547	qxl_release_fence_buffer_objects(release);	546	qxl_release_fence_buffer_objects(release);
		547	qxl_push_command_ring_release(qdev, release, QXL_CMD_SURFACE, false);
548		548
549	return 0;	549	return 0;
550	}	550	}

drivers/gpu/drm/qxl/qxl_display.c+3−3

 	cmd->u.set.visible = 1;
 	qxl_release_unmap(qdev, release, &cmd->release_info);
-	qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
 	qxl_release_fence_buffer_objects(release);
+	qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
 	return ret;
 	cmd->u.position.y = plane->state->crtc_y + fb->hot_y;
 	qxl_release_unmap(qdev, release, &cmd->release_info);
-	qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
 	qxl_release_fence_buffer_objects(release);
+	qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
 	if (old_cursor_bo != NULL)
 		qxl_bo_unpin(old_cursor_bo);
 	cmd->type = QXL_CURSOR_HIDE;
 	qxl_release_unmap(qdev, release, &cmd->release_info);
-	qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
 	qxl_release_fence_buffer_objects(release);
+	qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
 }
 static void qxl_update_dumb_head(struct qxl_device *qdev,

drivers/gpu/drm/qxl/qxl_draw.c+4−3

@@ -209,9 +209,10 @@ void qxl_draw_dirty_fb(struct qxl_device *qdev, · 208 unmodified lines
209	goto out_release_backoff;	209	goto out_release_backoff;
210		210
211	rects = drawable_set_clipping(qdev, num_clips, clips_bo);	211	rects = drawable_set_clipping(qdev, num_clips, clips_bo);
212	if (!rects)	212	if (!rects) {
		213	ret = -EINVAL;
213	goto out_release_backoff;	214	goto out_release_backoff;
214		215	}
215	drawable = (struct qxl_drawable *)qxl_release_map(qdev, release);	216	drawable = (struct qxl_drawable *)qxl_release_map(qdev, release);
216		217
217	drawable->clip.type = SPICE_CLIP_TYPE_RECTS;	218	drawable->clip.type = SPICE_CLIP_TYPE_RECTS;
@@ -242,8 +243,8 @@ void qxl_draw_dirty_fb(struct qxl_device *qdev, · 24 unmodified lines
242	}	243	}
243	qxl_bo_kunmap(clips_bo);	244	qxl_bo_kunmap(clips_bo);
244		245
245	qxl_push_command_ring_release(qdev, release, QXL_CMD_DRAW, false);
246	qxl_release_fence_buffer_objects(release);	246	qxl_release_fence_buffer_objects(release);
		247	qxl_push_command_ring_release(qdev, release, QXL_CMD_DRAW, false);
247		248
248	out_release_backoff:	249	out_release_backoff:
249	if (ret)	250	if (ret)

drivers/gpu/drm/qxl/qxl_image.c+2−1

 		break;
 	default:
 		DRM_ERROR("unsupported image bit depth\n");
-		return -EINVAL; /* TODO: cleanup */
+		qxl_bo_kunmap_atomic_page(qdev, image_bo, ptr);
+		return -EINVAL;
 	}
 	image->u.bitmap.flags = QXL_BITMAP_TOP_DOWN;
 	image->u.bitmap.x = width;

drivers/gpu/drm/qxl/qxl_ioctl.c+1−4

 			apply_surf_reloc(qdev, &reloc_info[i]);
 	}
+	qxl_release_fence_buffer_objects(release);
 	ret = qxl_push_command_ring_release(qdev, release, cmd->type, true);
-	if (ret)
-		qxl_release_backoff_reserve_list(release);
-	else
-		qxl_release_fence_buffer_objects(release);
 out_free_bos:
 out_free_release:

drivers/gpu/drm/virtio/virtgpu_kms.c+6−11

 		      events_clear, &events_clear);
 }
-static void virtio_gpu_context_destroy(struct virtio_gpu_device *vgdev,
-				      uint32_t ctx_id)
-{
-	virtio_gpu_cmd_context_destroy(vgdev, ctx_id);
-	virtio_gpu_notify(vgdev);
-	ida_free(&vgdev->ctx_id_ida, ctx_id - 1);
-}
 static void virtio_gpu_init_vq(struct virtio_gpu_queue *vgvq,
 			       void (*work_func)(struct work_struct *work))
 {
 void virtio_gpu_driver_postclose(struct drm_device *dev, struct drm_file *file)
 {
 	struct virtio_gpu_device *vgdev = dev->dev_private;
-	struct virtio_gpu_fpriv *vfpriv;
+	struct virtio_gpu_fpriv *vfpriv = file->driver_priv;
 	if (!vgdev->has_virgl_3d)
 		return;
-	vfpriv = file->driver_priv;
+	if (vfpriv->context_created) {
+		virtio_gpu_cmd_context_destroy(vgdev, vfpriv->ctx_id);
+		virtio_gpu_notify(vgdev);
+	}
-	virtio_gpu_context_destroy(vgdev, vfpriv->ctx_id);
+	ida_free(&vgdev->ctx_id_ida, vfpriv->ctx_id - 1);
 	mutex_destroy(&vfpriv->context_lock);
 	kfree(vfpriv);
 	file->driver_priv = NULL;

drivers/hv/hv.c+1−5

 	shared_sint.vector = HYPERVISOR_CALLBACK_VECTOR;
 	shared_sint.masked = false;
-	if (ms_hyperv.hints & HV_DEPRECATING_AEOI_RECOMMENDED)
+	shared_sint.auto_eoi = hv_recommend_using_aeoi();
-		shared_sint.auto_eoi = false;
-	else
-		shared_sint.auto_eoi = true;
 	hv_set_synint_state(VMBUS_MESSAGE_SINT, shared_sint.as_uint64);
 	/* Enable the global synic bit */

drivers/hv/hv_trace.h+2−2

@@ -286,8 +286,8 @@ TRACE_EVENT(vmbus_send_tl_connect_request, · 285 unmodified lines
286	__field(int, ret)	286	__field(int, ret)
287	),	287	),
288	TP_fast_assign(	288	TP_fast_assign(
289	memcpy(__entry->guest_id, &msg->guest_endpoint_id.b, 16);	289	export_guid(__entry->guest_id, &msg->guest_endpoint_id);
290	memcpy(__entry->host_id, &msg->host_service_id.b, 16);	290	export_guid(__entry->host_id, &msg->host_service_id);
291	__entry->ret = ret;	291	__entry->ret = ret;
292	),	292	),
293	TP_printk("sending guest_endpoint_id %pUl, host_service_id %pUl, "	293	TP_printk("sending guest_endpoint_id %pUl, host_service_id %pUl, "

drivers/hv/vmbus_drv.c+34−9

 	return drv->resume(dev);
 }
+#else
+#define vmbus_suspend NULL
+#define vmbus_resume NULL
 #endif /* CONFIG_PM_SLEEP */
 /*
 }
 /*
- * Note: we must use SET_NOIRQ_SYSTEM_SLEEP_PM_OPS rather than
+ * Note: we must use the "noirq" ops: see the comment before vmbus_bus_pm.
- * SET_SYSTEM_SLEEP_PM_OPS: see the comment before vmbus_bus_pm.
+ *
+ * suspend_noirq/resume_noirq are set to NULL to support Suspend-to-Idle: we
+ * shouldn't suspend the vmbus devices upon Suspend-to-Idle, otherwise there
+ * is no way to wake up a Generation-2 VM.
+ *
+ * The other 4 ops are for hibernation.
  */
 static const struct dev_pm_ops vmbus_pm = {
-	SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(vmbus_suspend, vmbus_resume)
+	.suspend_noirq	= NULL,
+	.resume_noirq	= NULL,
+	.freeze_noirq	= vmbus_suspend,
+	.thaw_noirq	= vmbus_resume,
+	.poweroff_noirq	= vmbus_suspend,
+	.restore_noirq	= vmbus_resume,
 };
 /* The one and only one */
 	return 0;
 }
+#else
+#define vmbus_bus_suspend NULL
+#define vmbus_bus_resume NULL
 #endif /* CONFIG_PM_SLEEP */
 static const struct acpi_device_id vmbus_acpi_device_ids[] = {
 MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);
 /*
- * Note: we must use SET_NOIRQ_SYSTEM_SLEEP_PM_OPS rather than
+ * Note: we must use the "no_irq" ops, otherwise hibernation can not work with
- * SET_SYSTEM_SLEEP_PM_OPS, otherwise NIC SR-IOV can not work, because the
+ * PCI device assignment, because "pci_dev_pm_ops" uses the "noirq" ops: in
- * "pci_dev_pm_ops" uses the "noirq" callbacks: in the resume path, the
+ * the resume path, the pci "noirq" restore op runs before "non-noirq" op (see
- * pci "noirq" restore callback runs before "non-noirq" callbacks (see
  * resume_target_kernel() -> dpm_resume_start(), and hibernation_restore() ->
  * dpm_resume_end()). This means vmbus_bus_resume() and the pci-hyperv's
- * resume callback must also run via the "noirq" callbacks.
+ * resume callback must also run via the "noirq" ops.
+ *
+ * Set suspend_noirq/resume_noirq to NULL for Suspend-to-Idle: see the comment
+ * earlier in this file before vmbus_pm.
  */
 static const struct dev_pm_ops vmbus_bus_pm = {
-	SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(vmbus_bus_suspend, vmbus_bus_resume)
+	.suspend_noirq	= NULL,
+	.resume_noirq	= NULL,
+	.freeze_noirq	= vmbus_bus_suspend,
+	.thaw_noirq	= vmbus_bus_resume,
+	.poweroff_noirq	= vmbus_bus_suspend,
+	.restore_noirq	= vmbus_bus_resume
 };
 static struct acpi_driver vmbus_acpi_driver = {

drivers/i2c/busses/i2c-amd-mp2-pci.c+1−1

 	if (!privdata)
 		return -ENOMEM;
+	privdata->pci_dev = pci_dev;
 	rc = amd_mp2_pci_init(privdata, pci_dev);
 	if (rc)
 		return rc;
 	mutex_init(&privdata->c2p_lock);
-	privdata->pci_dev = pci_dev;
 	pm_runtime_set_autosuspend_delay(&pci_dev->dev, 1000);
 	pm_runtime_use_autosuspend(&pci_dev->dev);

drivers/i2c/busses/i2c-aspeed.c+4−1

 	/* Ack all interrupts except for Rx done */
 	writel(irq_received & ~ASPEED_I2CD_INTR_RX_DONE,
 	       bus->base + ASPEED_I2C_INTR_STS_REG);
+	readl(bus->base + ASPEED_I2C_INTR_STS_REG);
 	irq_remaining = irq_received;
 #if IS_ENABLED(CONFIG_I2C_SLAVE)
 			irq_received, irq_handled);
 	/* Ack Rx done */
-	if (irq_received & ASPEED_I2CD_INTR_RX_DONE)
+	if (irq_received & ASPEED_I2CD_INTR_RX_DONE) {
 		writel(ASPEED_I2CD_INTR_RX_DONE,
 		       bus->base + ASPEED_I2C_INTR_STS_REG);
+		readl(bus->base + ASPEED_I2C_INTR_STS_REG);
+	}
 	spin_unlock(&bus->lock);
 	return irq_remaining ? IRQ_NONE : IRQ_HANDLED;
 }

drivers/i2c/busses/i2c-bcm-iproc.c+3−0

 			value = (u8)((val >> S_RX_DATA_SHIFT) & S_RX_DATA_MASK);
 			i2c_slave_event(iproc_i2c->slave,
 					I2C_SLAVE_WRITE_RECEIVED, &value);
+			if (rx_status == I2C_SLAVE_RX_END)
+				i2c_slave_event(iproc_i2c->slave,
+						I2C_SLAVE_STOP, &value);
 		}
 	} else if (status & BIT(IS_S_TX_UNDERRUN_SHIFT)) {
 		/* Master read other than start */

drivers/i2c/busses/i2c-tegra.c+12−24

 	do {
 		u32 status = i2c_readl(i2c_dev, I2C_INT_STATUS);
-		if (status)
+		if (status) {
 			tegra_i2c_isr(i2c_dev->irq, i2c_dev);
-		if (completion_done(complete)) {
+			if (completion_done(complete)) {
-			s64 delta = ktime_ms_delta(ktimeout, ktime);
+				s64 delta = ktime_ms_delta(ktimeout, ktime);
-			return msecs_to_jiffies(delta) ?: 1;
+				return msecs_to_jiffies(delta) ?: 1;
+			}
 		}
 		ktime = ktime_get();
 		disable_irq(i2c_dev->irq);
 		/*
-		 * Under some rare circumstances (like running KASAN +
+		 * There is a chance that completion may happen after IRQ
-		 * NFS root) CPU, which handles interrupt, may stuck in
+		 * synchronization, which is done by disable_irq().
-		 * uninterruptible state for a significant time.  In this
-		 * case we will get timeout if I2C transfer is running on
-		 * a sibling CPU, despite of IRQ being raised.
-		 *
-		 * In order to handle this rare condition, the IRQ status
-		 * needs to be checked after timeout.
 		 */
-		if (ret == 0)
+		if (ret == 0 && completion_done(complete)) {
-			ret = tegra_i2c_poll_completion_timeout(i2c_dev,
+			dev_warn(i2c_dev->dev,
-								complete, 0);
+				 "completion done after timeout\n");
+			ret = 1;
+		}
 	}
 	return ret;
 		time_left = tegra_i2c_wait_completion_timeout(
 				i2c_dev, &i2c_dev->dma_complete, xfer_time);
-		/*
-		 * Synchronize DMA first, since dmaengine_terminate_sync()
-		 * performs synchronization after the transfer's termination
-		 * and we want to get a completion if transfer succeeded.
-		 */
-		dmaengine_synchronize(i2c_dev->msg_read ?
-				      i2c_dev->rx_dma_chan :
-				      i2c_dev->tx_dma_chan);
 		dmaengine_terminate_sync(i2c_dev->msg_read ?
 					 i2c_dev->rx_dma_chan :
 					 i2c_dev->tx_dma_chan);

drivers/infiniband/core/cm.c+14−12

 	ret = xa_alloc_cyclic_irq(&cm.local_id_table, &id, NULL, xa_limit_32b,
 				  &cm.local_id_next, GFP_KERNEL);
-	if (ret)
+	if (ret < 0)
 		goto error;
 	cm_id_priv->id.local_id = (__force __be32)id ^ cm.random_id_operand;
 static void cm_format_rej(struct cm_rej_msg *rej_msg,
 			  struct cm_id_private *cm_id_priv,
-			  enum ib_cm_rej_reason reason,
+			  enum ib_cm_rej_reason reason, void *ari,
-			  void *ari,
+			  u8 ari_length, const void *private_data,
-			  u8 ari_length,
+			  u8 private_data_len, enum ib_cm_state state)
-			  const void *private_data,
-			  u8 private_data_len)
 {
 	lockdep_assert_held(&cm_id_priv->lock);
 	IBA_SET(CM_REJ_REMOTE_COMM_ID, rej_msg,
 		be32_to_cpu(cm_id_priv->id.remote_id));
-	switch(cm_id_priv->id.state) {
+	switch (state) {
 	case IB_CM_REQ_RCVD:
 		IBA_SET(CM_REJ_LOCAL_COMM_ID, rej_msg, be32_to_cpu(0));
 		IBA_SET(CM_REJ_MESSAGE_REJECTED, rej_msg, CM_MSG_RESPONSE_REQ);
 			      cm_id_priv->private_data_len);
 		break;
 	case IB_CM_TIMEWAIT:
-		cm_format_rej((struct cm_rej_msg *) msg->mad, cm_id_priv,
+		cm_format_rej((struct cm_rej_msg *)msg->mad, cm_id_priv,
-			      IB_CM_REJ_STALE_CONN, NULL, 0, NULL, 0);
+			      IB_CM_REJ_STALE_CONN, NULL, 0, NULL, 0,
+			      IB_CM_TIMEWAIT);
 		break;
 	default:
 		goto unlock;
 			      u8 ari_length, const void *private_data,
 			      u8 private_data_len)
 {
+	enum ib_cm_state state = cm_id_priv->id.state;
 	struct ib_mad_send_buf *msg;
 	int ret;
 	    (ari && ari_length > IB_CM_REJ_ARI_LENGTH))
 		return -EINVAL;
-	switch (cm_id_priv->id.state) {
+	switch (state) {
 	case IB_CM_REQ_SENT:
 	case IB_CM_MRA_REQ_RCVD:
 	case IB_CM_REQ_RCVD:
 		if (ret)
 			return ret;
 		cm_format_rej((struct cm_rej_msg *)msg->mad, cm_id_priv, reason,
-			      ari, ari_length, private_data, private_data_len);
+			      ari, ari_length, private_data, private_data_len,
+			      state);
 		break;
 	case IB_CM_REP_SENT:
 	case IB_CM_MRA_REP_RCVD:
 		if (ret)
 			return ret;
 		cm_format_rej((struct cm_rej_msg *)msg->mad, cm_id_priv, reason,
-			      ari, ari_length, private_data, private_data_len);
+			      ari, ari_length, private_data, private_data_len,
+			      state);
 		break;
 	default:
 		pr_debug("%s: local_id %d, cm_id->state: %d\n", __func__,

drivers/infiniband/core/rdma_core.c+4−5

 	 * uverbs_uobject_fd_release(), and the caller is expected to ensure
 	 * that release is never done while a call to lookup is possible.
 	 */
-	if (f->f_op != fd_type->fops) {
+	if (f->f_op != fd_type->fops || uobject->ufile != ufile) {
 		fput(f);
 		return ERR_PTR(-EBADF);
 	}
 	filp = anon_inode_getfile(fd_type->name, fd_type->fops, NULL,
 				  fd_type->flags);
 	if (IS_ERR(filp)) {
+		uverbs_uobject_put(uobj);
 		uobj = ERR_CAST(filp);
-		goto err_uobj;
+		goto err_fd;
 	}
 	uobj->object = filp;
 	uobj->id = new_fd;
 	return uobj;
-err_uobj:
-	uverbs_uobject_put(uobj);
 err_fd:
 	put_unused_fd(new_fd);
 	return uobj;
 			     enum rdma_lookup_mode mode)
 {
 	assert_uverbs_usecnt(uobj, mode);
-	uobj->uapi_object->type_class->lookup_put(uobj, mode);
 	/*
 	 * In order to unlock an object, either decrease its usecnt for
 	 * read access or zero it in case of exclusive access. See
 		break;
 	}
+	uobj->uapi_object->type_class->lookup_put(uobj, mode);
 	/* Pairs with the kref obtained by type->lookup_get */
 	uverbs_uobject_put(uobj);
 }

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

 			ret = mmget_not_zero(mm);
 			if (!ret) {
 				list_del_init(&priv->list);
+				if (priv->entry) {
+					rdma_user_mmap_entry_put(priv->entry);
+					priv->entry = NULL;
+				}
 				mm = NULL;
 				continue;
 			}

drivers/infiniband/hw/i40iw/i40iw_ctrl.c+1−1

@@ -1046,7 +1046,7 @@ i40iw_sc_query_rdma_features(struct i40iw_sc_cqp *cqp, · 1045 unmodified lines
1046	u64 header;	1046	u64 header;
1047		1047
1048	wqe = i40iw_sc_cqp_get_next_send_wqe(cqp, scratch);	1048	wqe = i40iw_sc_cqp_get_next_send_wqe(cqp, scratch);
1049	if (wqe)	1049	if (!wqe)
1050	return I40IW_ERR_RING_FULL;	1050	return I40IW_ERR_RING_FULL;
1051		1051
1052	set_64bit_val(wqe, 32, feat_mem->pa);	1052	set_64bit_val(wqe, 32, feat_mem->pa);

drivers/infiniband/hw/mlx4/main.c+2−1

@@ -1499,8 +1499,9 @@ static int __mlx4_ib_create_default_rules( · 1498 unmodified lines
1499	int i;	1499	int i;
1500		1500
1501	for (i = 0; i < ARRAY_SIZE(pdefault_rules->rules_create_list); i++) {	1501	for (i = 0; i < ARRAY_SIZE(pdefault_rules->rules_create_list); i++) {
		1502	union ib_flow_spec ib_spec = {};
1502	int ret;	1503	int ret;
1503	union ib_flow_spec ib_spec;	1504
1504	switch (pdefault_rules->rules_create_list[i]) {	1505	switch (pdefault_rules->rules_create_list[i]) {
1505	case 0:	1506	case 0:
1506	/* no rule */	1507	/* no rule */

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

@@ -5558,7 +5558,9 @@ static void to_rdma_ah_attr(struct mlx5_ib_dev *ibdev, · 5557 unmodified lines
5558	rdma_ah_set_path_bits(ah_attr, path->grh_mlid & 0x7f);	5558	rdma_ah_set_path_bits(ah_attr, path->grh_mlid & 0x7f);
5559	rdma_ah_set_static_rate(ah_attr,	5559	rdma_ah_set_static_rate(ah_attr,
5560	path->static_rate ? path->static_rate - 5 : 0);	5560	path->static_rate ? path->static_rate - 5 : 0);
5561	if (path->grh_mlid & (1 << 7)) {	5561
		5562	if (path->grh_mlid & (1 << 7) \|\|
		5563	ah_attr->type == RDMA_AH_ATTR_TYPE_ROCE) {
5562	u32 tc_fl = be32_to_cpu(path->tclass_flowlabel);	5564	u32 tc_fl = be32_to_cpu(path->tclass_flowlabel);
5563		5565
5564	rdma_ah_set_grh(ah_attr, NULL,	5566	rdma_ah_set_grh(ah_attr, NULL,

drivers/infiniband/sw/rdmavt/cq.c+2−2

@@ -248,8 +248,8 @@ int rvt_create_cq(struct ib_cq ibcq, const struct ib_cq_init_attr attr, · 247 unmodified lines
248	*/	248	*/
249	if (udata && udata->outlen >= sizeof(__u64)) {	249	if (udata && udata->outlen >= sizeof(__u64)) {
250	cq->ip = rvt_create_mmap_info(rdi, sz, udata, u_wc);	250	cq->ip = rvt_create_mmap_info(rdi, sz, udata, u_wc);
251	if (!cq->ip) {	251	if (IS_ERR(cq->ip)) {
252	err = -ENOMEM;	252	err = PTR_ERR(cq->ip);
253	goto bail_wc;	253	goto bail_wc;
254	}	254	}
255		255

drivers/infiniband/sw/rdmavt/mmap.c+2−2

@@ -154,7 +154,7 @@ done: · 153 unmodified lines
154	* @udata: user data (must be valid!)	154	* @udata: user data (must be valid!)
155	* @obj: opaque pointer to a cq, wq etc	155	* @obj: opaque pointer to a cq, wq etc
156	*	156	*
157	* Return: rvt_mmap struct on success	157	* Return: rvt_mmap struct on success, ERR_PTR on failure
158	*/	158	*/
159	struct rvt_mmap_info rvt_create_mmap_info(struct rvt_dev_info rdi, u32 size,	159	struct rvt_mmap_info rvt_create_mmap_info(struct rvt_dev_info rdi, u32 size,
160	struct ib_udata udata, void obj)	160	struct ib_udata udata, void obj)
@@ -166,7 +166,7 @@ struct rvt_mmap_info rvt_create_mmap_info(struct rvt_dev_info rdi, u32 size, · 5 unmodified lines
166		166
167	ip = kmalloc_node(sizeof(*ip), GFP_KERNEL, rdi->dparms.node);	167	ip = kmalloc_node(sizeof(*ip), GFP_KERNEL, rdi->dparms.node);
168	if (!ip)	168	if (!ip)
169	return ip;	169	return ERR_PTR(-ENOMEM);
170		170
171	size = PAGE_ALIGN(size);	171	size = PAGE_ALIGN(size);
172		172

drivers/infiniband/sw/rdmavt/qp.c+2−2

@@ -1244,8 +1244,8 @@ struct ib_qp rvt_create_qp(struct ib_pd ibpd, · 1243 unmodified lines
1244		1244
1245	qp->ip = rvt_create_mmap_info(rdi, s, udata,	1245	qp->ip = rvt_create_mmap_info(rdi, s, udata,
1246	qp->r_rq.wq);	1246	qp->r_rq.wq);
1247	if (!qp->ip) {	1247	if (IS_ERR(qp->ip)) {
1248	ret = ERR_PTR(-ENOMEM);	1248	ret = ERR_CAST(qp->ip);
1249	goto bail_qpn;	1249	goto bail_qpn;
1250	}	1250	}
1251		1251

drivers/infiniband/sw/rdmavt/srq.c+2−2

@@ -111,8 +111,8 @@ int rvt_create_srq(struct ib_srq ibsrq, struct ib_srq_init_attr srq_init_attr, · 110 unmodified lines
111	u32 s = sizeof(struct rvt_rwq) + srq->rq.size * sz;	111	u32 s = sizeof(struct rvt_rwq) + srq->rq.size * sz;
112		112
113	srq->ip = rvt_create_mmap_info(dev, s, udata, srq->rq.wq);	113	srq->ip = rvt_create_mmap_info(dev, s, udata, srq->rq.wq);
114	if (!srq->ip) {	114	if (IS_ERR(srq->ip)) {
115	ret = -ENOMEM;	115	ret = PTR_ERR(srq->ip);
116	goto bail_wq;	116	goto bail_wq;
117	}	117	}
118		118

drivers/infiniband/sw/siw/siw_qp_tx.c+11−4

 {
 	struct ib_mr *base_mr = (struct ib_mr *)(uintptr_t)sqe->base_mr;
 	struct siw_device *sdev = to_siw_dev(pd->device);
-	struct siw_mem *mem = siw_mem_id2obj(sdev, sqe->rkey  >> 8);
+	struct siw_mem *mem;
 	int rv = 0;
 	siw_dbg_pd(pd, "STag 0x%08x\n", sqe->rkey);
-	if (unlikely(!mem || !base_mr)) {
+	if (unlikely(!base_mr)) {
 		pr_warn("siw: fastreg: STag 0x%08x unknown\n", sqe->rkey);
 		return -EINVAL;
 	}
 	if (unlikely(base_mr->rkey >> 8 != sqe->rkey  >> 8)) {
 		pr_warn("siw: fastreg: STag 0x%08x: bad MR\n", sqe->rkey);
-		rv = -EINVAL;
+		return -EINVAL;
-		goto out;
 	}
+	mem = siw_mem_id2obj(sdev, sqe->rkey  >> 8);
+	if (unlikely(!mem)) {
+		pr_warn("siw: fastreg: STag 0x%08x unknown\n", sqe->rkey);
+		return -EINVAL;
+	}
 	if (unlikely(mem->pd != pd)) {
 		pr_warn("siw: fastreg: PD mismatch\n");
 		rv = -EINVAL;

drivers/iommu/Kconfig+2−2

@@ -362,7 +362,7 @@ config IPMMU_VMSA · 361 unmodified lines
362		362
363	config SPAPR_TCE_IOMMU	363	config SPAPR_TCE_IOMMU
364	bool "sPAPR TCE IOMMU Support"	364	bool "sPAPR TCE IOMMU Support"
365	depends on PPC_POWERNV \|\| PPC_PSERIES \|\| (PPC && COMPILE_TEST)	365	depends on PPC_POWERNV \|\| PPC_PSERIES
366	select IOMMU_API	366	select IOMMU_API
367	help	367	help
368	Enables bits of IOMMU API required by VFIO. The iommu_ops	368	Enables bits of IOMMU API required by VFIO. The iommu_ops
@@ -457,7 +457,7 @@ config S390_AP_IOMMU · 88 unmodified lines
457		457
458	config MTK_IOMMU	458	config MTK_IOMMU
459	bool "MTK IOMMU Support"	459	bool "MTK IOMMU Support"
460	depends on ARM \|\| ARM64 \|\| COMPILE_TEST	460	depends on HAS_DMA
461	depends on ARCH_MEDIATEK \|\| COMPILE_TEST	461	depends on ARCH_MEDIATEK \|\| COMPILE_TEST
462	select ARM_DMA_USE_IOMMU	462	select ARM_DMA_USE_IOMMU
463	select IOMMU_API	463	select IOMMU_API

drivers/iommu/amd_iommu_init.c+1−1

@@ -2936,7 +2936,7 @@ static int __init parse_amd_iommu_intr(char *str) · 2935 unmodified lines
2936	{	2936	{
2937	for (; *str; ++str) {	2937	for (; *str; ++str) {
2938	if (strncmp(str, "legacy", 6) == 0) {	2938	if (strncmp(str, "legacy", 6) == 0) {
2939	amd_iommu_guest_ir = AMD_IOMMU_GUEST_IR_LEGACY;	2939	amd_iommu_guest_ir = AMD_IOMMU_GUEST_IR_LEGACY_GA;
2940	break;	2940	break;
2941	}	2941	}
2942	if (strncmp(str, "vapic", 5) == 0) {	2942	if (strncmp(str, "vapic", 5) == 0) {

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

@@ -371,11 +371,11 @@ int dmar_disabled = 0; · 370 unmodified lines
371	int dmar_disabled = 1;	371	int dmar_disabled = 1;
372	#endif /* CONFIG_INTEL_IOMMU_DEFAULT_ON */	372	#endif /* CONFIG_INTEL_IOMMU_DEFAULT_ON */
373		373
374	#ifdef INTEL_IOMMU_SCALABLE_MODE_DEFAULT_ON	374	#ifdef CONFIG_INTEL_IOMMU_SCALABLE_MODE_DEFAULT_ON
375	int intel_iommu_sm = 1;	375	int intel_iommu_sm = 1;
376	#else	376	#else
377	int intel_iommu_sm;	377	int intel_iommu_sm;
378	#endif /* INTEL_IOMMU_SCALABLE_MODE_DEFAULT_ON */	378	#endif /* CONFIG_INTEL_IOMMU_SCALABLE_MODE_DEFAULT_ON */
379		379
380	int intel_iommu_enabled = 0;	380	int intel_iommu_enabled = 0;
381	EXPORT_SYMBOL_GPL(intel_iommu_enabled);	381	EXPORT_SYMBOL_GPL(intel_iommu_enabled);

drivers/iommu/iommu.c+1−0

@@ -184,6 +184,7 @@ static struct dev_iommu dev_iommu_get(struct device dev) · 183 unmodified lines
184		184
185	static void dev_iommu_free(struct device *dev)	185	static void dev_iommu_free(struct device *dev)
186	{	186	{
		187	iommu_fwspec_free(dev);
187	kfree(dev->iommu);	188	kfree(dev->iommu);
188	dev->iommu = NULL;	189	dev->iommu = NULL;
189	}	190	}

drivers/iommu/qcom_iommu.c+4−1

 	qcom_iommu->dev = dev;
 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-	if (res)
+	if (res) {
 		qcom_iommu->local_base = devm_ioremap_resource(dev, res);
+		if (IS_ERR(qcom_iommu->local_base))
+			return PTR_ERR(qcom_iommu->local_base);
+	}
 	qcom_iommu->iface_clk = devm_clk_get(dev, "iface");
 	if (IS_ERR(qcom_iommu->iface_clk)) {

drivers/md/dm-mpath.c+4−2

 	/* Do we need to select a new pgpath? */
 	pgpath = READ_ONCE(m->current_pgpath);
-	queue_io = test_bit(MPATHF_QUEUE_IO, &m->flags);
+	if (!pgpath || !test_bit(MPATHF_QUEUE_IO, &m->flags))
-	if (!pgpath || !queue_io)
 		pgpath = choose_pgpath(m, bio->bi_iter.bi_size);
+	/* MPATHF_QUEUE_IO might have been cleared by choose_pgpath. */
+	queue_io = test_bit(MPATHF_QUEUE_IO, &m->flags);
 	if ((pgpath && queue_io) ||
 	    (!pgpath && test_bit(MPATHF_QUEUE_IF_NO_PATH, &m->flags))) {
 		/* Queue for the daemon to resubmit */

drivers/md/dm-verity-fec.c+1−1

@@ -435,7 +435,7 @@ int verity_fec_decode(struct dm_verity v, struct dm_verity_io io, · 434 unmodified lines
435	fio->level++;	435	fio->level++;
436		436
437	if (type == DM_VERITY_BLOCK_TYPE_METADATA)	437	if (type == DM_VERITY_BLOCK_TYPE_METADATA)
438	block += v->data_blocks;	438	block = block - v->hash_start + v->data_blocks;
439		439
440	/*	440	/*
441	* For RS(M, N), the continuous FEC data is divided into blocks of N	441	* For RS(M, N), the continuous FEC data is divided into blocks of N

drivers/md/dm-writecache.c+37−15

 	return 0;
 }
+static int writecache_read_metadata(struct dm_writecache *wc, sector_t n_sectors)
+{
+	struct dm_io_region region;
+	struct dm_io_request req;
+	region.bdev = wc->ssd_dev->bdev;
+	region.sector = wc->start_sector;
+	region.count = n_sectors;
+	req.bi_op = REQ_OP_READ;
+	req.bi_op_flags = REQ_SYNC;
+	req.mem.type = DM_IO_VMA;
+	req.mem.ptr.vma = (char *)wc->memory_map;
+	req.client = wc->dm_io;
+	req.notify.fn = NULL;
+	return dm_io(&req, 1, &region, NULL);
+}
 static void writecache_resume(struct dm_target *ti)
 {
 	struct dm_writecache *wc = ti->private;
 	wc_lock(wc);
-	if (WC_MODE_PMEM(wc))
+	if (WC_MODE_PMEM(wc)) {
 		persistent_memory_invalidate_cache(wc->memory_map, wc->memory_map_size);
+	} else {
+		r = writecache_read_metadata(wc, wc->metadata_sectors);
+		if (r) {
+			size_t sb_entries_offset;
+			writecache_error(wc, r, "unable to read metadata: %d", r);
+			sb_entries_offset = offsetof(struct wc_memory_superblock, entries);
+			memset((char *)wc->memory_map + sb_entries_offset, -1,
+			       (wc->metadata_sectors << SECTOR_SHIFT) - sb_entries_offset);
+		}
+	}
 	wc->tree = RB_ROOT;
 	INIT_LIST_HEAD(&wc->lru);
 		ti->error = "Invalid block size";
 		goto bad;
 	}
+	if (wc->block_size < bdev_logical_block_size(wc->dev->bdev) ||
+	    wc->block_size < bdev_logical_block_size(wc->ssd_dev->bdev)) {
+		r = -EINVAL;
+		ti->error = "Block size is smaller than device logical block size";
+		goto bad;
+	}
 	wc->block_size_bits = __ffs(wc->block_size);
 	wc->max_writeback_jobs = MAX_WRITEBACK_JOBS;
 			goto bad;
 		}
 	} else {
-		struct dm_io_region region;
-		struct dm_io_request req;
 		size_t n_blocks, n_metadata_blocks;
 		uint64_t n_bitmap_bits;
 			goto bad;
 		}
-		region.bdev = wc->ssd_dev->bdev;
+		r = writecache_read_metadata(wc, wc->block_size >> SECTOR_SHIFT);
-		region.sector = wc->start_sector;
-		region.count = wc->metadata_sectors;
-		req.bi_op = REQ_OP_READ;
-		req.bi_op_flags = REQ_SYNC;
-		req.mem.type = DM_IO_VMA;
-		req.mem.ptr.vma = (char *)wc->memory_map;
-		req.client = wc->dm_io;
-		req.notify.fn = NULL;
-		r = dm_io(&req, 1, &region, NULL);
 		if (r) {
-			ti->error = "Unable to read metadata";
+			ti->error = "Unable to read first block of metadata";
 			goto bad;
 		}
 	}

drivers/mmc/core/mmc_ops.c+1−1

@@ -878,7 +878,7 @@ static int mmc_send_hpi_cmd(struct mmc_card *card) · 877 unmodified lines
878	* Issued High Priority Interrupt, and check for card status	878	* Issued High Priority Interrupt, and check for card status
879	* until out-of prg-state.	879	* until out-of prg-state.
880	*/	880	*/
881	int mmc_interrupt_hpi(struct mmc_card *card)	881	static int mmc_interrupt_hpi(struct mmc_card *card)
882	{	882	{
883	int err;	883	int err;
884	u32 status;	884	u32 status;

drivers/mmc/host/cqhci.c+10−11

 #include <linux/delay.h>
 #include <linux/highmem.h>
 #include <linux/io.h>
+#include <linux/iopoll.h>
 #include <linux/module.h>
 #include <linux/dma-mapping.h>
 #include <linux/slab.h>
 /* CQHCI is idle and should halt immediately, so set a small timeout */
 #define CQHCI_OFF_TIMEOUT 100
+static u32 cqhci_read_ctl(struct cqhci_host *cq_host)
+{
+	return cqhci_readl(cq_host, CQHCI_CTL);
+}
 static void cqhci_off(struct mmc_host *mmc)
 {
 	struct cqhci_host *cq_host = mmc->cqe_private;
-	ktime_t timeout;
-	bool timed_out;
 	u32 reg;
+	int err;
 	if (!cq_host->enabled || !mmc->cqe_on || cq_host->recovery_halt)
 		return;
 	cqhci_writel(cq_host, CQHCI_HALT, CQHCI_CTL);
-	timeout = ktime_add_us(ktime_get(), CQHCI_OFF_TIMEOUT);
+	err = readx_poll_timeout(cqhci_read_ctl, cq_host, reg,
-	while (1) {
+				 reg & CQHCI_HALT, 0, CQHCI_OFF_TIMEOUT);
-		timed_out = ktime_compare(ktime_get(), timeout) > 0;
+	if (err < 0)
-		reg = cqhci_readl(cq_host, CQHCI_CTL);
-		if ((reg & CQHCI_HALT) || timed_out)
-			break;
-	}
-	if (timed_out)
 		pr_err("%s: cqhci: CQE stuck on\n", mmc_hostname(mmc));
 	else
 		pr_debug("%s: cqhci: CQE off\n", mmc_hostname(mmc));

drivers/mmc/host/meson-mx-sdio.c+1−10

 		meson_mx_mmc_start_cmd(mmc, mrq->cmd);
 }
-static int meson_mx_mmc_card_busy(struct mmc_host *mmc)
-{
-	struct meson_mx_mmc_host *host = mmc_priv(mmc);
-	u32 irqc = readl(host->base + MESON_MX_SDIO_IRQC);
-	return !!(irqc & MESON_MX_SDIO_IRQC_FORCE_DATA_DAT_MASK);
-}
 static void meson_mx_mmc_read_response(struct mmc_host *mmc,
 				       struct mmc_command *cmd)
 {
 static struct mmc_host_ops meson_mx_mmc_ops = {
 	.request		= meson_mx_mmc_request,
 	.set_ios		= meson_mx_mmc_set_ios,
-	.card_busy		= meson_mx_mmc_card_busy,
 	.get_cd			= mmc_gpio_get_cd,
 	.get_ro			= mmc_gpio_get_ro,
 };
 	mmc->f_max = clk_round_rate(host->cfg_div_clk,
 				    clk_get_rate(host->parent_clk));
-	mmc->caps |= MMC_CAP_ERASE | MMC_CAP_CMD23;
+	mmc->caps |= MMC_CAP_ERASE | MMC_CAP_CMD23 | MMC_CAP_WAIT_WHILE_BUSY;
 	mmc->ops = &meson_mx_mmc_ops;
 	ret = mmc_of_parse(mmc);

drivers/mmc/host/sdhci-msm.c+2−0

@@ -2087,6 +2087,8 @@ static int sdhci_msm_probe(struct platform_device *pdev) · 2086 unmodified lines
2087	goto clk_disable;	2087	goto clk_disable;
2088	}	2088	}
2089		2089
		2090	msm_host->mmc->caps \|= MMC_CAP_WAIT_WHILE_BUSY \| MMC_CAP_NEED_RSP_BUSY;
		2091
2090	pm_runtime_get_noresume(&pdev->dev);	2092	pm_runtime_get_noresume(&pdev->dev);
2091	pm_runtime_set_active(&pdev->dev);	2093	pm_runtime_set_active(&pdev->dev);
2092	pm_runtime_enable(&pdev->dev);	2094	pm_runtime_enable(&pdev->dev);

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

@@ -601,6 +601,9 @@ static int intel_select_drive_strength(struct mmc_card *card, · 600 unmodified lines
601	struct sdhci_pci_slot *slot = sdhci_priv(host);	601	struct sdhci_pci_slot *slot = sdhci_priv(host);
602	struct intel_host *intel_host = sdhci_pci_priv(slot);	602	struct intel_host *intel_host = sdhci_pci_priv(slot);
603		603
		604	if (!(mmc_driver_type_mask(intel_host->drv_strength) & card_drv))
		605	return 0;
		606
604	return intel_host->drv_strength;	607	return intel_host->drv_strength;
605	}	608	}
606		609

drivers/mmc/host/sdhci-xenon.c+10−0

@@ -235,6 +235,16 @@ static void xenon_voltage_switch(struct sdhci_host *host) · 234 unmodified lines
235	{	235	{
236	/* Wait for 5ms after set 1.8V signal enable bit */	236	/* Wait for 5ms after set 1.8V signal enable bit */
237	usleep_range(5000, 5500);	237	usleep_range(5000, 5500);
		238
		239	/*
		240	* For some reason the controller's Host Control2 register reports
		241	* the bit representing 1.8V signaling as 0 when read after it was
		242	* written as 1. Subsequent read reports 1.
		243	*
		244	* Since this may cause some issues, do an empty read of the Host
		245	* Control2 register here to circumvent this.
		246	*/
		247	sdhci_readw(host, SDHCI_HOST_CONTROL2);
238	}	248	}
239		249
240	static const struct sdhci_ops sdhci_xenon_ops = {	250	static const struct sdhci_ops sdhci_xenon_ops = {

drivers/nvme/host/core.c+2−0

@@ -3642,6 +3642,8 @@ static void nvme_alloc_ns(struct nvme_ctrl *ctrl, unsigned nsid) · 3641 unmodified lines
3642		3642
3643	return;	3643	return;
3644	out_put_disk:	3644	out_put_disk:
		3645	/* prevent double queue cleanup */
		3646	ns->disk->queue = NULL;
3645	put_disk(ns->disk);	3647	put_disk(ns->disk);
3646	out_unlink_ns:	3648	out_unlink_ns:
3647	mutex_lock(&ctrl->subsys->lock);	3649	mutex_lock(&ctrl->subsys->lock);

drivers/scsi/qla2xxx/qla_os.c+17−18

 	}
 	qla2x00_wait_for_hba_ready(base_vha);
+	/*
+	 * if UNLOADING flag is already set, then continue unload,
+	 * where it was set first.
+	 */
+	if (test_and_set_bit(UNLOADING, &base_vha->dpc_flags))
+		return;
 	if (IS_QLA25XX(ha) || IS_QLA2031(ha) || IS_QLA27XX(ha) ||
 	    IS_QLA28XX(ha)) {
 		if (ha->flags.fw_started)
 	qla2x00_wait_for_sess_deletion(base_vha);
-	/*
-	 * if UNLOAD flag is already set, then continue unload,
-	 * where it was set first.
-	 */
-	if (test_bit(UNLOADING, &base_vha->dpc_flags))
-		return;
-	set_bit(UNLOADING, &base_vha->dpc_flags);
 	qla_nvme_delete(base_vha);
 	dma_free_coherent(&ha->pdev->dev,
 	struct qla_work_evt *e;
 	uint8_t bail;
+	if (test_bit(UNLOADING, &vha->dpc_flags))
+		return NULL;
 	QLA_VHA_MARK_BUSY(vha, bail);
 	if (bail)
 		return NULL;
 	struct pci_dev *pdev = ha->pdev;
 	scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
-	/*
-	 * if UNLOAD flag is already set, then continue unload,
-	 * where it was set first.
-	 */
-	if (test_bit(UNLOADING, &base_vha->dpc_flags))
-		return;
 	ql_log(ql_log_warn, base_vha, 0x015b,
 	    "Disabling adapter.\n");
 		return;
 	}
-	qla2x00_wait_for_sess_deletion(base_vha);
+	/*
+	 * if UNLOADING flag is already set, then continue unload,
+	 * where it was set first.
+	 */
+	if (test_and_set_bit(UNLOADING, &base_vha->dpc_flags))
+		return;
-	set_bit(UNLOADING, &base_vha->dpc_flags);
+	qla2x00_wait_for_sess_deletion(base_vha);
 	qla2x00_delete_all_vps(ha, base_vha);

drivers/scsi/scsi_lib.c+1−0

@@ -2284,6 +2284,7 @@ scsi_device_set_state(struct scsi_device *sdev, enum scsi_device_state state) · 2283 unmodified lines
2284	switch (oldstate) {	2284	switch (oldstate) {
2285	case SDEV_RUNNING:	2285	case SDEV_RUNNING:
2286	case SDEV_CREATED_BLOCK:	2286	case SDEV_CREATED_BLOCK:
		2287	case SDEV_QUIESCE:
2287	case SDEV_OFFLINE:	2288	case SDEV_OFFLINE:
2288	break;	2289	break;
2289	default:	2290	default:

drivers/target/target_core_iblock.c+1−1

@@ -432,7 +432,7 @@ iblock_execute_zero_out(struct block_device bdev, struct se_cmd cmd) · 431 unmodified lines
432	target_to_linux_sector(dev, cmd->t_task_lba),	432	target_to_linux_sector(dev, cmd->t_task_lba),
433	target_to_linux_sector(dev,	433	target_to_linux_sector(dev,
434	sbc_get_write_same_sectors(cmd)),	434	sbc_get_write_same_sectors(cmd)),
435	GFP_KERNEL, false);	435	GFP_KERNEL, BLKDEV_ZERO_NOUNMAP);
436	if (ret)	436	if (ret)
437	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;	437	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
438		438

drivers/tty/hvc/Kconfig+1−1

@@ -88,7 +88,7 @@ config HVC_DCC · 87 unmodified lines
88		88
89	config HVC_RISCV_SBI	89	config HVC_RISCV_SBI
90	bool "RISC-V SBI console support"	90	bool "RISC-V SBI console support"
91	depends on RISCV_SBI	91	depends on RISCV_SBI_V01
92	select HVC_DRIVER	92	select HVC_DRIVER
93	help	93	help
94	This enables support for console output via RISC-V SBI calls, which	94	This enables support for console output via RISC-V SBI calls, which

drivers/tty/serial/Kconfig+1−1

@@ -86,7 +86,7 @@ config SERIAL_EARLYCON_ARM_SEMIHOST · 85 unmodified lines
86		86
87	config SERIAL_EARLYCON_RISCV_SBI	87	config SERIAL_EARLYCON_RISCV_SBI
88	bool "Early console using RISC-V SBI"	88	bool "Early console using RISC-V SBI"
89	depends on RISCV_SBI	89	depends on RISCV_SBI_V01
90	select SERIAL_CORE	90	select SERIAL_CORE
91	select SERIAL_CORE_CONSOLE	91	select SERIAL_CORE_CONSOLE
92	select SERIAL_EARLYCON	92	select SERIAL_EARLYCON

drivers/vfio/vfio_iommu_type1.c+5−5

@@ -342,8 +342,8 @@ static int vaddr_get_pfn(struct mm_struct *mm, unsigned long vaddr, · 341 unmodified lines
342	vma = find_vma_intersection(mm, vaddr, vaddr + 1);	342	vma = find_vma_intersection(mm, vaddr, vaddr + 1);
343		343
344	if (vma && vma->vm_flags & VM_PFNMAP) {	344	if (vma && vma->vm_flags & VM_PFNMAP) {
345	*pfn = ((vaddr - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;	345	if (!follow_pfn(vma, vaddr, pfn) &&
346	if (is_invalid_reserved_pfn(*pfn))	346	is_invalid_reserved_pfn(*pfn))
347	ret = 0;	347	ret = 0;
348	}	348	}
349	done:	349	done:
@@ -555,7 +555,7 @@ static int vfio_iommu_type1_pin_pages(void *iommu_data, · 205 unmodified lines
555	continue;	555	continue;
556	}	556	}
557		557
558	remote_vaddr = dma->vaddr + iova - dma->iova;	558	remote_vaddr = dma->vaddr + (iova - dma->iova);
559	ret = vfio_pin_page_external(dma, remote_vaddr, &phys_pfn[i],	559	ret = vfio_pin_page_external(dma, remote_vaddr, &phys_pfn[i],
560	do_accounting);	560	do_accounting);
561	if (ret)	561	if (ret)
@@ -2345,10 +2345,10 @@ static int vfio_iommu_type1_dma_rw_chunk(struct vfio_iommu *iommu, · 1783 unmodified lines
2345	vaddr = dma->vaddr + offset;	2345	vaddr = dma->vaddr + offset;
2346		2346
2347	if (write)	2347	if (write)
2348	copied = __copy_to_user((void __user )vaddr, data,	2348	copied = copy_to_user((void __user )vaddr, data,
2349	count) ? 0 : count;	2349	count) ? 0 : count;
2350	else	2350	else
2351	copied = __copy_from_user(data, (void __user )vaddr,	2351	copied = copy_from_user(data, (void __user )vaddr,
2352	count) ? 0 : count;	2352	count) ? 0 : count;
2353	if (kthread)	2353	if (kthread)
2354	unuse_mm(mm);	2354	unuse_mm(mm);

fs/btrfs/backref.c+1−1

@@ -391,7 +391,7 @@ static int is_shared_data_backref(struct preftrees *preftrees, u64 bytenr) · 390 unmodified lines
391	struct rb_node **p = &preftrees->direct.root.rb_root.rb_node;	391	struct rb_node **p = &preftrees->direct.root.rb_root.rb_node;
392	struct rb_node *parent = NULL;	392	struct rb_node *parent = NULL;
393	struct prelim_ref *ref = NULL;	393	struct prelim_ref *ref = NULL;
394	struct prelim_ref target = {0};	394	struct prelim_ref target = {};
395	int result;	395	int result;
396		396
397	target.parent = bytenr;	397	target.parent = bytenr;

fs/btrfs/block-group.c+14−6

 	path = btrfs_alloc_path();
 	if (!path) {
 		ret = -ENOMEM;
-		goto out;
+		goto out_put_group;
 	}
 	/*
 		ret = btrfs_orphan_add(trans, BTRFS_I(inode));
 		if (ret) {
 			btrfs_add_delayed_iput(inode);
-			goto out;
+			goto out_put_group;
 		}
 		clear_nlink(inode);
 		/* One for the block groups ref */
 	ret = btrfs_search_slot(trans, tree_root, &key, path, -1, 1);
 	if (ret < 0)
-		goto out;
+		goto out_put_group;
 	if (ret > 0)
 		btrfs_release_path(path);
 	if (ret == 0) {
 		ret = btrfs_del_item(trans, tree_root, path);
 		if (ret)
-			goto out;
+			goto out_put_group;
 		btrfs_release_path(path);
 	}
 	ret = remove_block_group_free_space(trans, block_group);
 	if (ret)
-		goto out;
+		goto out_put_group;
-	btrfs_put_block_group(block_group);
+	/* Once for the block groups rbtree */
 	btrfs_put_block_group(block_group);
 	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
 		/* once for the tree */
 		free_extent_map(em);
 	}
+out_put_group:
+	/* Once for the lookup reference */
+	btrfs_put_block_group(block_group);
 out:
 	if (remove_rsv)
 		btrfs_delayed_refs_rsv_release(fs_info, 1);
 	if (ret)
 		goto err;
 	mutex_unlock(&fs_info->unused_bg_unpin_mutex);
+	if (prev_trans)
+		btrfs_put_transaction(prev_trans);
 	return true;
 err:
 	mutex_unlock(&fs_info->unused_bg_unpin_mutex);
+	if (prev_trans)
+		btrfs_put_transaction(prev_trans);
 	btrfs_dec_block_group_ro(bg);
 	return false;
 }

fs/btrfs/discard.h+1−1

@@ -1,4 +1,4 @@
1	// SPDX-License-Identifier: GPL-2.0	1	/* SPDX-License-Identifier: GPL-2.0 */
2		2
3	#ifndef BTRFS_DISCARD_H	3	#ifndef BTRFS_DISCARD_H
4	#define BTRFS_DISCARD_H	4	#define BTRFS_DISCARD_H

fs/btrfs/disk-io.c+32−4

@@ -2036,9 +2036,6 @@ void btrfs_free_fs_roots(struct btrfs_fs_info *fs_info) · 2035 unmodified lines
2036	for (i = 0; i < ret; i++)	2036	for (i = 0; i < ret; i++)
2037	btrfs_drop_and_free_fs_root(fs_info, gang[i]);	2037	btrfs_drop_and_free_fs_root(fs_info, gang[i]);
2038	}	2038	}
2039
2040	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state))
2041	btrfs_free_log_root_tree(NULL, fs_info);
2042	}	2039	}
2043		2040
2044	static void btrfs_init_scrub(struct btrfs_fs_info *fs_info)	2041	static void btrfs_init_scrub(struct btrfs_fs_info *fs_info)
@@ -3888,7 +3885,7 @@ void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info, · 1843 unmodified lines
3888	spin_unlock(&fs_info->fs_roots_radix_lock);	3885	spin_unlock(&fs_info->fs_roots_radix_lock);
3889		3886
3890	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {	3887	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
3891	btrfs_free_log(NULL, root);	3888	ASSERT(root->log_root == NULL);
3892	if (root->reloc_root) {	3889	if (root->reloc_root) {
3893	btrfs_put_root(root->reloc_root);	3890	btrfs_put_root(root->reloc_root);
3894	root->reloc_root = NULL;	3891	root->reloc_root = NULL;
@@ -4211,6 +4208,36 @@ static void btrfs_error_commit_super(struct btrfs_fs_info *fs_info) · 316 unmodified lines
4211	up_write(&fs_info->cleanup_work_sem);	4208	up_write(&fs_info->cleanup_work_sem);
4212	}	4209	}
4213		4210
		4211	static void btrfs_drop_all_logs(struct btrfs_fs_info *fs_info)
		4212	{
		4213	struct btrfs_root *gang[8];
		4214	u64 root_objectid = 0;
		4215	int ret;
		4216
		4217	spin_lock(&fs_info->fs_roots_radix_lock);
		4218	while ((ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
		4219	(void **)gang, root_objectid,
		4220	ARRAY_SIZE(gang))) != 0) {
		4221	int i;
		4222
		4223	for (i = 0; i < ret; i++)
		4224	gang[i] = btrfs_grab_root(gang[i]);
		4225	spin_unlock(&fs_info->fs_roots_radix_lock);
		4226
		4227	for (i = 0; i < ret; i++) {
		4228	if (!gang[i])
		4229	continue;
		4230	root_objectid = gang[i]->root_key.objectid;
		4231	btrfs_free_log(NULL, gang[i]);
		4232	btrfs_put_root(gang[i]);
		4233	}
		4234	root_objectid++;
		4235	spin_lock(&fs_info->fs_roots_radix_lock);
		4236	}
		4237	spin_unlock(&fs_info->fs_roots_radix_lock);
		4238	btrfs_free_log_root_tree(NULL, fs_info);
		4239	}
		4240
4214	static void btrfs_destroy_ordered_extents(struct btrfs_root *root)	4241	static void btrfs_destroy_ordered_extents(struct btrfs_root *root)
4215	{	4242	{
4216	struct btrfs_ordered_extent *ordered;	4243	struct btrfs_ordered_extent *ordered;
@@ -4603,6 +4630,7 @@ static int btrfs_cleanup_transaction(struct btrfs_fs_info *fs_info) · 386 unmodified lines
4603	btrfs_destroy_delayed_inodes(fs_info);	4630	btrfs_destroy_delayed_inodes(fs_info);
4604	btrfs_assert_delayed_root_empty(fs_info);	4631	btrfs_assert_delayed_root_empty(fs_info);
4605	btrfs_destroy_all_delalloc_inodes(fs_info);	4632	btrfs_destroy_all_delalloc_inodes(fs_info);
		4633	btrfs_drop_all_logs(fs_info);
4606	mutex_unlock(&fs_info->transaction_kthread_mutex);	4634	mutex_unlock(&fs_info->transaction_kthread_mutex);
4607		4635
4608	return 0;	4636	return 0;

fs/btrfs/relocation.c+1−0

@@ -4559,6 +4559,7 @@ int btrfs_recover_relocation(struct btrfs_root *root) · 4558 unmodified lines
4559	if (IS_ERR(fs_root)) {	4559	if (IS_ERR(fs_root)) {
4560	err = PTR_ERR(fs_root);	4560	err = PTR_ERR(fs_root);
4561	list_add_tail(&reloc_root->root_list, &reloc_roots);	4561	list_add_tail(&reloc_root->root_list, &reloc_roots);
		4562	btrfs_end_transaction(trans);
4562	goto out_unset;	4563	goto out_unset;
4563	}	4564	}
4564		4565

fs/btrfs/transaction.c+11−2

@@ -662,10 +662,19 @@ again: · 661 unmodified lines
662	}	662	}
663		663
664	got_it:	664	got_it:
665	btrfs_record_root_in_trans(h, root);
666
667	if (!current->journal_info)	665	if (!current->journal_info)
668	current->journal_info = h;	666	current->journal_info = h;
		667
		668	/*
		669	* btrfs_record_root_in_trans() needs to alloc new extents, and may
		670	* call btrfs_join_transaction() while we're also starting a
		671	* transaction.
		672	*
		673	* Thus it need to be called after current->journal_info initialized,
		674	* or we can deadlock.
		675	*/
		676	btrfs_record_root_in_trans(h, root);
		677
669	return h;	678	return h;
670		679
671	join_fail:	680	join_fail:

fs/btrfs/tree-log.c+40−3

@@ -4226,6 +4226,9 @@ static int btrfs_log_prealloc_extents(struct btrfs_trans_handle *trans, · 4225 unmodified lines
4226	const u64 ino = btrfs_ino(inode);	4226	const u64 ino = btrfs_ino(inode);
4227	struct btrfs_path *dst_path = NULL;	4227	struct btrfs_path *dst_path = NULL;
4228	bool dropped_extents = false;	4228	bool dropped_extents = false;
		4229	u64 truncate_offset = i_size;
		4230	struct extent_buffer *leaf;
		4231	int slot;
4229	int ins_nr = 0;	4232	int ins_nr = 0;
4230	int start_slot;	4233	int start_slot;
4231	int ret;	4234	int ret;
@@ -4240,9 +4243,43 @@ static int btrfs_log_prealloc_extents(struct btrfs_trans_handle *trans, · 8 unmodified lines
4240	if (ret < 0)	4243	if (ret < 0)
4241	goto out;	4244	goto out;
4242		4245
		4246	/*
		4247	* We must check if there is a prealloc extent that starts before the
		4248	* i_size and crosses the i_size boundary. This is to ensure later we
		4249	* truncate down to the end of that extent and not to the i_size, as
		4250	* otherwise we end up losing part of the prealloc extent after a log
		4251	* replay and with an implicit hole if there is another prealloc extent
		4252	* that starts at an offset beyond i_size.
		4253	*/
		4254	ret = btrfs_previous_item(root, path, ino, BTRFS_EXTENT_DATA_KEY);
		4255	if (ret < 0)
		4256	goto out;
		4257
		4258	if (ret == 0) {
		4259	struct btrfs_file_extent_item *ei;
		4260
		4261	leaf = path->nodes[0];
		4262	slot = path->slots[0];
		4263	ei = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
		4264
		4265	if (btrfs_file_extent_type(leaf, ei) ==
		4266	BTRFS_FILE_EXTENT_PREALLOC) {
		4267	u64 extent_end;
		4268
		4269	btrfs_item_key_to_cpu(leaf, &key, slot);
		4270	extent_end = key.offset +
		4271	btrfs_file_extent_num_bytes(leaf, ei);
		4272
		4273	if (extent_end > i_size)
		4274	truncate_offset = extent_end;
		4275	}
		4276	} else {
		4277	ret = 0;
		4278	}
		4279
4243	while (true) {	4280	while (true) {
4244	struct extent_buffer *leaf = path->nodes[0];	4281	leaf = path->nodes[0];
4245	int slot = path->slots[0];	4282	slot = path->slots[0];
4246		4283
4247	if (slot >= btrfs_header_nritems(leaf)) {	4284	if (slot >= btrfs_header_nritems(leaf)) {
4248	if (ins_nr > 0) {	4285	if (ins_nr > 0) {
@@ -4280,7 +4317,7 @@ static int btrfs_log_prealloc_extents(struct btrfs_trans_handle *trans, · 31 unmodified lines
4280	ret = btrfs_truncate_inode_items(trans,	4317	ret = btrfs_truncate_inode_items(trans,
4281	root->log_root,	4318	root->log_root,
4282	&inode->vfs_inode,	4319	&inode->vfs_inode,
4283	i_size,	4320	truncate_offset,
4284	BTRFS_EXTENT_DATA_KEY);	4321	BTRFS_EXTENT_DATA_KEY);
4285	} while (ret == -EAGAIN);	4322	} while (ret == -EAGAIN);
4286	if (ret)	4323	if (ret)

fs/io_uring.c+31−27

 	REQ_F_OVERFLOW_BIT,
 	REQ_F_POLLED_BIT,
 	REQ_F_BUFFER_SELECTED_BIT,
+	REQ_F_NO_FILE_TABLE_BIT,
 	/* not a real bit, just to check we're not overflowing the space */
 	__REQ_F_LAST_BIT,
 	REQ_F_POLLED		= BIT(REQ_F_POLLED_BIT),
 	/* buffer already selected */
 	REQ_F_BUFFER_SELECTED	= BIT(REQ_F_BUFFER_SELECTED_BIT),
+	/* doesn't need file table for this request */
+	REQ_F_NO_FILE_TABLE	= BIT(REQ_F_NO_FILE_TABLE_BIT),
 };
 struct async_poll {
 		.needs_file		= 1,
 		.fd_non_neg		= 1,
 		.needs_fs		= 1,
+		.file_table		= 1,
 	},
 	[IORING_OP_READ] = {
 		.needs_mm		= 1,
 	struct io_kiocb *req;
 	req = ctx->fallback_req;
-	if (!test_and_set_bit_lock(0, (unsigned long *) ctx->fallback_req))
+	if (!test_and_set_bit_lock(0, (unsigned long *) &ctx->fallback_req))
 		return req;
 	return NULL;
 	if (likely(!io_is_fallback_req(req)))
 		kmem_cache_free(req_cachep, req);
 	else
-		clear_bit_unlock(0, (unsigned long *) req->ctx->fallback_req);
+		clear_bit_unlock(0, (unsigned long *) &req->ctx->fallback_req);
 }
 struct req_batch {
  * any file. For now, just ensure that anything potentially problematic is done
  * inline.
  */
-static bool io_file_supports_async(struct file *file)
+static bool io_file_supports_async(struct file *file, int rw)
 {
 	umode_t mode = file_inode(file)->i_mode;
 	if (S_ISREG(mode) && file->f_op != &io_uring_fops)
 		return true;
-	return false;
+	if (!(file->f_mode & FMODE_NOWAIT))
+		return false;
+	if (rw == READ)
+		return file->f_op->read_iter != NULL;
+	return file->f_op->write_iter != NULL;
 }
 static int io_prep_rw(struct io_kiocb *req, const struct io_uring_sqe *sqe,
 	 * If the file doesn't support async, mark it as REQ_F_MUST_PUNT so
 	 * we know to async punt it even if it was opened O_NONBLOCK
 	 */
-	if (force_nonblock && !io_file_supports_async(req->file))
+	if (force_nonblock && !io_file_supports_async(req->file, READ))
 		goto copy_iov;
 	iov_count = iov_iter_count(&iter);
 			if (ret)
 				goto out_free;
 			/* any defer here is final, must blocking retry */
-			if (!(req->flags & REQ_F_NOWAIT))
+			if (!(req->flags & REQ_F_NOWAIT) &&
+			    !file_can_poll(req->file))
 				req->flags |= REQ_F_MUST_PUNT;
 			return -EAGAIN;
 		}
 	 * If the file doesn't support async, mark it as REQ_F_MUST_PUNT so
 	 * we know to async punt it even if it was opened O_NONBLOCK
 	 */
-	if (force_nonblock && !io_file_supports_async(req->file))
+	if (force_nonblock && !io_file_supports_async(req->file, WRITE))
 		goto copy_iov;
 	/* file path doesn't support NOWAIT for non-direct_IO */
 			if (ret)
 				goto out_free;
 			/* any defer here is final, must blocking retry */
-			req->flags |= REQ_F_MUST_PUNT;
+			if (!file_can_poll(req->file))
+				req->flags |= REQ_F_MUST_PUNT;
 			return -EAGAIN;
 		}
 	}
 	return 0;
 }
-static bool io_splice_punt(struct file *file)
-{
-	if (get_pipe_info(file))
-		return false;
-	if (!io_file_supports_async(file))
-		return true;
-	return !(file->f_flags & O_NONBLOCK);
-}
 static int io_splice(struct io_kiocb *req, bool force_nonblock)
 {
 	struct io_splice *sp = &req->splice;
 	loff_t *poff_in, *poff_out;
 	long ret;
-	if (force_nonblock) {
+	if (force_nonblock)
-		if (io_splice_punt(in) || io_splice_punt(out))
+		return -EAGAIN;
-			return -EAGAIN;
-		flags |= SPLICE_F_NONBLOCK;
-	}
 	poff_in = (sp->off_in == -1) ? NULL : &sp->off_in;
 	poff_out = (sp->off_out == -1) ? NULL : &sp->off_out;
 	struct kstat stat;
 	int ret;
-	if (force_nonblock)
+	if (force_nonblock) {
+		/* only need file table for an actual valid fd */
+		if (ctx->dfd == -1 || ctx->dfd == AT_FDCWD)
+			req->flags |= REQ_F_NO_FILE_TABLE;
 		return -EAGAIN;
+	}
 	if (vfs_stat_set_lookup_flags(&lookup_flags, ctx->how.flags))
 		return -EINVAL;
 	if (io_req_cancelled(req))
 		return;
 	__io_sync_file_range(req);
-	io_put_req(req); /* put submission ref */
+	io_steal_work(req, workptr);
 }
 static int io_sync_file_range(struct io_kiocb *req, bool force_nonblock)
 	int ret;
 	/* Still need defer if there is pending req in defer list. */
-	if (!req_need_defer(req) && list_empty(&ctx->defer_list))
+	if (!req_need_defer(req) && list_empty_careful(&ctx->defer_list))
 		return 0;
 	if (!req->io && io_alloc_async_ctx(req))
 	int ret = -EBADF;
 	struct io_ring_ctx *ctx = req->ctx;
-	if (req->work.files)
+	if (req->work.files || (req->flags & REQ_F_NO_FILE_TABLE))
 		return 0;
 	if (!ctx->ring_file)
 		return -EBADF;
 	 * it could cause shutdown to hang.
 	 */
 	while (ctx->sqo_thread && !wq_has_sleeper(&ctx->sqo_wait))
-		cpu_relax();
+		cond_resched();
 	io_kill_timeouts(ctx);
 	io_poll_remove_all(ctx);

fs/ioctl.c+8−0

 static int ioctl_fibmap(struct file *filp, int __user *p)
 {
 	struct inode *inode = file_inode(filp);
+	struct super_block *sb = inode->i_sb;
 	int error, ur_block;
 	sector_t block;
 	block = ur_block;
 	error = bmap(inode, &block);
+	if (block > INT_MAX) {
+		error = -ERANGE;
+		pr_warn_ratelimited("[%s/%d] FS: %s File: %pD4 would truncate fibmap result\n",
+				    current->comm, task_pid_nr(current),
+				    sb->s_id, filp);
+	}
 	if (error)
 		ur_block = 0;
 	else

fs/iomap/fiemap.c+1−4

 	if (iomap->type == IOMAP_MAPPED) {
 		addr = (pos - iomap->offset + iomap->addr) >> inode->i_blkbits;
-		if (addr > INT_MAX)
+		*bno = addr;
-			WARN(1, "would truncate bmap result\n");
-		else
-			*bno = addr;
 	}
 	return 0;
 }

fs/nfs/nfs3acl.c+15−7

 int nfs3_set_acl(struct inode *inode, struct posix_acl *acl, int type)
 {
-	struct posix_acl *alloc = NULL, *dfacl = NULL;
+	struct posix_acl *orig = acl, *dfacl = NULL, *alloc;
 	int status;
 	if (S_ISDIR(inode->i_mode)) {
 		switch(type) {
 		case ACL_TYPE_ACCESS:
-			alloc = dfacl = get_acl(inode, ACL_TYPE_DEFAULT);
+			alloc = get_acl(inode, ACL_TYPE_DEFAULT);
 			if (IS_ERR(alloc))
 				goto fail;
+			dfacl = alloc;
 			break;
 		case ACL_TYPE_DEFAULT:
-			dfacl = acl;
+			alloc = get_acl(inode, ACL_TYPE_ACCESS);
-			alloc = acl = get_acl(inode, ACL_TYPE_ACCESS);
 			if (IS_ERR(alloc))
 				goto fail;
+			dfacl = acl;
+			acl = alloc;
 			break;
 		}
 	}
 	if (acl == NULL) {
-		alloc = acl = posix_acl_from_mode(inode->i_mode, GFP_KERNEL);
+		alloc = posix_acl_from_mode(inode->i_mode, GFP_KERNEL);
 		if (IS_ERR(alloc))
 			goto fail;
+		acl = alloc;
 	}
 	status = __nfs3_proc_setacls(inode, acl, dfacl);
-	posix_acl_release(alloc);
+out:
+	if (acl != orig)
+		posix_acl_release(acl);
+	if (dfacl != orig)
+		posix_acl_release(dfacl);
 	return status;
 fail:
-	return PTR_ERR(alloc);
+	status = PTR_ERR(alloc);
+	goto out;
 }
 const struct xattr_handler *nfs3_xattr_handlers[] = {

fs/nfs/nfs4proc.c+9−2

@@ -7891,6 +7891,7 @@ static void · 7890 unmodified lines
7891	nfs4_bind_one_conn_to_session_done(struct rpc_task task, void calldata)	7891	nfs4_bind_one_conn_to_session_done(struct rpc_task task, void calldata)
7892	{	7892	{
7893	struct nfs41_bind_conn_to_session_args *args = task->tk_msg.rpc_argp;	7893	struct nfs41_bind_conn_to_session_args *args = task->tk_msg.rpc_argp;
		7894	struct nfs41_bind_conn_to_session_res *res = task->tk_msg.rpc_resp;
7894	struct nfs_client *clp = args->client;	7895	struct nfs_client *clp = args->client;
7895		7896
7896	switch (task->tk_status) {	7897	switch (task->tk_status) {
@@ -7899,6 +7900,12 @@ nfs4_bind_one_conn_to_session_done(struct rpc_task task, void calldata) · 2 unmodified lines
7899	nfs4_schedule_session_recovery(clp->cl_session,	7900	nfs4_schedule_session_recovery(clp->cl_session,
7900	task->tk_status);	7901	task->tk_status);
7901	}	7902	}
		7903	if (args->dir == NFS4_CDFC4_FORE_OR_BOTH &&
		7904	res->dir != NFS4_CDFS4_BOTH) {
		7905	rpc_task_close_connection(task);
		7906	if (args->retries++ < MAX_BIND_CONN_TO_SESSION_RETRIES)
		7907	rpc_restart_call(task);
		7908	}
7902	}	7909	}
7903		7910
7904	static const struct rpc_call_ops nfs4_bind_one_conn_to_session_ops = {	7911	static const struct rpc_call_ops nfs4_bind_one_conn_to_session_ops = {
@@ -7921,6 +7928,7 @@ int nfs4_proc_bind_one_conn_to_session(struct rpc_clnt *clnt, · 16 unmodified lines
7921	struct nfs41_bind_conn_to_session_args args = {	7928	struct nfs41_bind_conn_to_session_args args = {
7922	.client = clp,	7929	.client = clp,
7923	.dir = NFS4_CDFC4_FORE_OR_BOTH,	7930	.dir = NFS4_CDFC4_FORE_OR_BOTH,
		7931	.retries = 0,
7924	};	7932	};
7925	struct nfs41_bind_conn_to_session_res res;	7933	struct nfs41_bind_conn_to_session_res res;
7926	struct rpc_message msg = {	7934	struct rpc_message msg = {
@@ -9191,8 +9199,7 @@ nfs4_proc_layoutget(struct nfs4_layoutget lgp, long timeout) · 1264 unmodified lines
9191	nfs4_init_sequence(&lgp->args.seq_args, &lgp->res.seq_res, 0, 0);	9199	nfs4_init_sequence(&lgp->args.seq_args, &lgp->res.seq_res, 0, 0);
9192		9200
9193	task = rpc_run_task(&task_setup_data);	9201	task = rpc_run_task(&task_setup_data);
9194	if (IS_ERR(task))	9202
9195	return ERR_CAST(task);
9196	status = rpc_wait_for_completion_task(task);	9203	status = rpc_wait_for_completion_task(task);
9197	if (status != 0)	9204	if (status != 0)
9198	goto out;	9205	goto out;

fs/nfs/pnfs.c+5−6

 			!valid_layout) {
 		spin_unlock(&ino->i_lock);
 		dprintk("NFS: %s no layout segments to return\n", __func__);
-		goto out_put_layout_hdr;
+		goto out_wait_layoutreturn;
 	}
 	send = pnfs_prepare_layoutreturn(lo, &stateid, &cred, NULL);
 	spin_unlock(&ino->i_lock);
 	if (send)
 		status = pnfs_send_layoutreturn(lo, &stateid, &cred, IOMODE_ANY, true);
+out_wait_layoutreturn:
+	wait_on_bit(&lo->plh_flags, NFS_LAYOUT_RETURN, TASK_UNINTERRUPTIBLE);
 out_put_layout_hdr:
 	pnfs_free_lseg_list(&tmp_list);
 	pnfs_put_layout_hdr(lo);
 	/* lo ref dropped in pnfs_roc_release() */
 	layoutreturn = pnfs_prepare_layoutreturn(lo, &stateid, &lc_cred, &iomode);
 	/* If the creds don't match, we can't compound the layoutreturn */
-	if (!layoutreturn)
+	if (!layoutreturn || cred_fscmp(cred, lc_cred) != 0)
 		goto out_noroc;
-	if (cred_fscmp(cred, lc_cred) != 0)
-		goto out_noroc_put_cred;
 	roc = layoutreturn;
 	pnfs_init_layoutreturn_args(args, lo, &stateid, iomode);
 	res->lrs_present = 0;
 	layoutreturn = false;
-out_noroc_put_cred:
 	put_cred(lc_cred);
 out_noroc:
 	spin_unlock(&ino->i_lock);
 	rcu_read_unlock();

fs/nfs/super.c+1−1

@@ -185,7 +185,7 @@ static int __nfs_list_for_each_server(struct list_head *head, · 184 unmodified lines
185		185
186	rcu_read_lock();	186	rcu_read_lock();
187	list_for_each_entry_rcu(server, head, client_link) {	187	list_for_each_entry_rcu(server, head, client_link) {
188	if (!nfs_sb_active(server->super))	188	if (!(server->super && nfs_sb_active(server->super)))
189	continue;	189	continue;
190	rcu_read_unlock();	190	rcu_read_unlock();
191	if (last)	191	if (last)

fs/ocfs2/dlmfs/dlmfs.c+12−15

 				loff_t *ppos)
 {
 	int bytes_left;
-	ssize_t writelen;
 	char *lvb_buf;
 	struct inode *inode = file_inode(filp);
 	if (*ppos >= i_size_read(inode))
 		return -ENOSPC;
+	/* don't write past the lvb */
+	if (count > i_size_read(inode) - *ppos)
+		count = i_size_read(inode) - *ppos;
 	if (!count)
 		return 0;
 	if (!access_ok(buf, count))
 		return -EFAULT;
-	/* don't write past the lvb */
+	lvb_buf = kmalloc(count, GFP_NOFS);
-	if ((count + *ppos) > i_size_read(inode))
-		writelen = i_size_read(inode) - *ppos;
-	else
-		writelen = count - *ppos;
-	lvb_buf = kmalloc(writelen, GFP_NOFS);
 	if (!lvb_buf)
 		return -ENOMEM;
-	bytes_left = copy_from_user(lvb_buf, buf, writelen);
+	bytes_left = copy_from_user(lvb_buf, buf, count);
-	writelen -= bytes_left;
+	count -= bytes_left;
-	if (writelen)
+	if (count)
-		user_dlm_write_lvb(inode, lvb_buf, writelen);
+		user_dlm_write_lvb(inode, lvb_buf, count);
 	kfree(lvb_buf);
-	*ppos = *ppos + writelen;
+	*ppos = *ppos + count;
-	mlog(0, "wrote %zd bytes\n", writelen);
+	mlog(0, "wrote %zu bytes\n", count);
-	return writelen;
+	return count;
 }
 static void dlmfs_init_once(void *foo)

fs/pnode.c+4−5

 	child = copy_tree(last_source, last_source->mnt.mnt_root, type);
 	if (IS_ERR(child))
 		return PTR_ERR(child);
+	read_seqlock_excl(&mount_lock);
 	mnt_set_mountpoint(m, mp, child);
+	if (m->mnt_master != dest_master)
+		SET_MNT_MARK(m->mnt_master);
+	read_sequnlock_excl(&mount_lock);
 	last_dest = m;
 	last_source = child;
-	if (m->mnt_master != dest_master) {
-		read_seqlock_excl(&mount_lock);
-		SET_MNT_MARK(m->mnt_master);
-		read_sequnlock_excl(&mount_lock);
-	}
 	hlist_add_head(&child->mnt_hash, list);
 	return count_mounts(m->mnt_ns, child);
 }

fs/super.c+1−1

 	mutex_lock(&bdev->bd_fsfreeze_mutex);
 	if (bdev->bd_fsfreeze_count > 0) {
 		mutex_unlock(&bdev->bd_fsfreeze_mutex);
-		blkdev_put(bdev, mode);
 		warnf(fc, "%pg: Can't mount, blockdev is frozen", bdev);
+		blkdev_put(bdev, mode);
 		return -EBUSY;
 	}

include/linux/dma-buf.h+1−2

 /**
  * struct dma_buf_attach_ops - importer operations for an attachment
- * @move_notify: [optional] notification that the DMA-buf is moving
  *
  * Attachment operations implemented by the importer.
  */
 struct dma_buf_attach_ops {
 	/**
-	 * @move_notify
+	 * @move_notify: [optional] notification that the DMA-buf is moving
 	 *
 	 * If this callback is provided the framework can avoid pinning the
 	 * backing store while mappings exists.

include/linux/dmaengine.h+6−6

 /**
  * Interleaved Transfer Request
  * ----------------------------
- * A chunk is collection of contiguous bytes to be transfered.
+ * A chunk is collection of contiguous bytes to be transferred.
  * The gap(in bytes) between two chunks is called inter-chunk-gap(ICG).
- * ICGs may or maynot change between chunks.
+ * ICGs may or may not change between chunks.
  * A FRAME is the smallest series of contiguous {chunk,icg} pairs,
  *  that when repeated an integral number of times, specifies the transfer.
  * A transfer template is specification of a Frame, the number of times
  * @chan: driver channel device
  * @device: sysfs device
  * @dev_id: parent dma_device dev_id
- * @idr_ref: reference count to gate release of dma_device dev_id
  */
 struct dma_chan_dev {
 	struct dma_chan *chan;
 	struct device device;
 	int dev_id;
-	atomic_t *idr_ref;
 };
 /**
 	int dev_id;
 	struct device *dev;
 	struct module *owner;
+	struct ida chan_ida;
+	struct mutex chan_mutex;	/* to protect chan_ida */
 	u32 src_addr_widths;
 	u32 dst_addr_widths;
  * dmaengine_synchronize() needs to be called before it is safe to free
  * any memory that is accessed by previously submitted descriptors or before
  * freeing any resources accessed from within the completion callback of any
- * perviously submitted descriptors.
+ * previously submitted descriptors.
  *
  * This function can be called from atomic context as well as from within a
  * complete callback of a descriptor submitted on the same channel.
  *
  * Synchronizes to the DMA channel termination to the current context. When this
  * function returns it is guaranteed that all transfers for previously issued
- * descriptors have stopped and and it is safe to free the memory assoicated
+ * descriptors have stopped and it is safe to free the memory associated
  * with them. Furthermore it is guaranteed that all complete callback functions
  * for a previously submitted descriptor have finished running and it is safe to
  * free resources accessed from within the complete callbacks.

include/linux/nfs_xdr.h+2−0

 	struct nfstime4			date;
 };
+#define MAX_BIND_CONN_TO_SESSION_RETRIES 3
 struct nfs41_bind_conn_to_session_args {
 	struct nfs_client		*client;
 	struct nfs4_sessionid		sessionid;
 	u32				dir;
 	bool				use_conn_in_rdma_mode;
+	int				retries;
 };
 struct nfs41_bind_conn_to_session_res {

include/linux/sunrpc/clnt.h+12−1

 #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
 	struct dentry		*cl_debugfs;	/* debugfs directory */
 #endif
-	struct rpc_xprt_iter	cl_xpi;
+	/* cl_work is only needed after cl_xpi is no longer used,
+	 * and that are of similar size
+	 */
+	union {
+		struct rpc_xprt_iter	cl_xpi;
+		struct work_struct	cl_work;
+	};
 	const struct cred	*cl_cred;
 };
 		(task->tk_msg.rpc_proc->p_decode != NULL);
 }
+static inline void rpc_task_close_connection(struct rpc_task *task)
+{
+	if (task->tk_xprt)
+		xprt_force_disconnect(task->tk_xprt);
+}
 #endif /* _LINUX_SUNRPC_CLNT_H */

include/trace/events/rpcrdma.h+4−8

 TRACE_EVENT(xprtrdma_post_send,
 	TP_PROTO(
-		const struct rpcrdma_req *req,
+		const struct rpcrdma_req *req
-		int status
 	),
-	TP_ARGS(req, status),
+	TP_ARGS(req),
 	TP_STRUCT__entry(
 		__field(const void *, req)
 		__field(unsigned int, client_id)
 		__field(int, num_sge)
 		__field(int, signaled)
-		__field(int, status)
 	),
 	TP_fast_assign(
 		__entry->sc = req->rl_sendctx;
 		__entry->num_sge = req->rl_wr.num_sge;
 		__entry->signaled = req->rl_wr.send_flags & IB_SEND_SIGNALED;
-		__entry->status = status;
 	),
-	TP_printk("task:%u@%u req=%p sc=%p (%d SGE%s) %sstatus=%d",
+	TP_printk("task:%u@%u req=%p sc=%p (%d SGE%s) %s",
 		__entry->task_id, __entry->client_id,
 		__entry->req, __entry->sc, __entry->num_sge,
 		(__entry->num_sge == 1 ? "" : "s"),
-		(__entry->signaled ? "signaled " : ""),
+		(__entry->signaled ? "signaled" : "")
-		__entry->status
 	)
 );

include/uapi/drm/amdgpu_drm.h+4−0

 #define AMDGPU_TILING_DCC_PITCH_MAX_MASK		0x3FFF
 #define AMDGPU_TILING_DCC_INDEPENDENT_64B_SHIFT		43
 #define AMDGPU_TILING_DCC_INDEPENDENT_64B_MASK		0x1
+#define AMDGPU_TILING_DCC_INDEPENDENT_128B_SHIFT	44
+#define AMDGPU_TILING_DCC_INDEPENDENT_128B_MASK		0x1
+#define AMDGPU_TILING_SCANOUT_SHIFT			63
+#define AMDGPU_TILING_SCANOUT_MASK			0x1
 /* Set/Get helpers for tiling flags. */
 #define AMDGPU_TILING_SET(field, value) \

include/uapi/linux/dma-buf.h+6−0

 #define DMA_BUF_BASE		'b'
 #define DMA_BUF_IOCTL_SYNC	_IOW(DMA_BUF_BASE, 0, struct dma_buf_sync)
+/* 32/64bitness of this uapi was botched in android, there's no difference
+ * between them in actual uapi, they're just different numbers.
+ */
 #define DMA_BUF_SET_NAME	_IOW(DMA_BUF_BASE, 1, const char *)
+#define DMA_BUF_SET_NAME_A	_IOW(DMA_BUF_BASE, 1, u32)
+#define DMA_BUF_SET_NAME_B	_IOW(DMA_BUF_BASE, 1, u64)
 #endif

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

@@ -119,8 +119,8 @@ enum hv_fcopy_op { · 118 unmodified lines
119		119
120	struct hv_fcopy_hdr {	120	struct hv_fcopy_hdr {
121	__u32 operation;	121	__u32 operation;
122	uuid_le service_id0; /* currently unused */	122	__u8 service_id0[16]; /* currently unused */
123	uuid_le service_id1; /* currently unused */	123	__u8 service_id1[16]; /* currently unused */
124	} __attribute__((packed));	124	} __attribute__((packed));
125		125
126	#define OVER_WRITE 0x1	126	#define OVER_WRITE 0x1

kernel/power/hibernate.c+7−0

@@ -898,6 +898,13 @@ static int software_resume(void) · 897 unmodified lines
898	error = freeze_processes();	898	error = freeze_processes();
899	if (error)	899	if (error)
900	goto Close_Finish;	900	goto Close_Finish;
		901
		902	error = freeze_kernel_threads();
		903	if (error) {
		904	thaw_processes();
		905	goto Close_Finish;
		906	}
		907
901	error = load_image_and_restore();	908	error = load_image_and_restore();
902	thaw_processes();	909	thaw_processes();
903	Finish:	910	Finish:

lib/kunit/test.c+1−1

@@ -93,7 +93,7 @@ static void kunit_print_ok_not_ok(void *test_or_suite, · 92 unmodified lines
93	* representation.	93	* representation.
94	*/	94	*/
95	if (suite)	95	if (suite)
96	pr_info("%s %zd - %s",	96	pr_info("%s %zd - %s\n",
97	kunit_status_to_string(is_ok),	97	kunit_status_to_string(is_ok),
98	test_number, description);	98	test_number, description);
99	else	99	else

net/sunrpc/clnt.c+18−6

@@ -880,6 +880,20 @@ EXPORT_SYMBOL_GPL(rpc_shutdown_client); · 879 unmodified lines
880	/*	880	/*
881	* Free an RPC client	881	* Free an RPC client
882	*/	882	*/
		883	static void rpc_free_client_work(struct work_struct *work)
		884	{
		885	struct rpc_clnt *clnt = container_of(work, struct rpc_clnt, cl_work);
		886
		887	/* These might block on processes that might allocate memory,
		888	* so they cannot be called in rpciod, so they are handled separately
		889	* here.
		890	*/
		891	rpc_clnt_debugfs_unregister(clnt);
		892	rpc_clnt_remove_pipedir(clnt);
		893
		894	kfree(clnt);
		895	rpciod_down();
		896	}
883	static struct rpc_clnt *	897	static struct rpc_clnt *
884	rpc_free_client(struct rpc_clnt *clnt)	898	rpc_free_client(struct rpc_clnt *clnt)
885	{	899	{
@@ -890,17 +904,16 @@ rpc_free_client(struct rpc_clnt *clnt) · 4 unmodified lines
890	rcu_dereference(clnt->cl_xprt)->servername);	904	rcu_dereference(clnt->cl_xprt)->servername);
891	if (clnt->cl_parent != clnt)	905	if (clnt->cl_parent != clnt)
892	parent = clnt->cl_parent;	906	parent = clnt->cl_parent;
893	rpc_clnt_debugfs_unregister(clnt);
894	rpc_clnt_remove_pipedir(clnt);
895	rpc_unregister_client(clnt);	907	rpc_unregister_client(clnt);
896	rpc_free_iostats(clnt->cl_metrics);	908	rpc_free_iostats(clnt->cl_metrics);
897	clnt->cl_metrics = NULL;	909	clnt->cl_metrics = NULL;
898	xprt_put(rcu_dereference_raw(clnt->cl_xprt));	910	xprt_put(rcu_dereference_raw(clnt->cl_xprt));
899	xprt_iter_destroy(&clnt->cl_xpi);	911	xprt_iter_destroy(&clnt->cl_xpi);
900	rpciod_down();
901	put_cred(clnt->cl_cred);	912	put_cred(clnt->cl_cred);
902	rpc_free_clid(clnt);	913	rpc_free_clid(clnt);
903	kfree(clnt);	914
		915	INIT_WORK(&clnt->cl_work, rpc_free_client_work);
		916	schedule_work(&clnt->cl_work);
904	return parent;	917	return parent;
905	}	918	}
906		919
@@ -2808,8 +2821,7 @@ int rpc_clnt_test_and_add_xprt(struct rpc_clnt *clnt, · 1901 unmodified lines
2808	task = rpc_call_null_helper(clnt, xprt, NULL,	2821	task = rpc_call_null_helper(clnt, xprt, NULL,
2809	RPC_TASK_SOFT\|RPC_TASK_SOFTCONN\|RPC_TASK_ASYNC\|RPC_TASK_NULLCREDS,	2822	RPC_TASK_SOFT\|RPC_TASK_SOFTCONN\|RPC_TASK_ASYNC\|RPC_TASK_NULLCREDS,
2810	&rpc_cb_add_xprt_call_ops, data);	2823	&rpc_cb_add_xprt_call_ops, data);
2811	if (IS_ERR(task))	2824
2812	return PTR_ERR(task);
2813	rpc_put_task(task);	2825	rpc_put_task(task);
2814	success:	2826	success:
2815	return 1;	2827	return 1;

net/sunrpc/xprtrdma/rpc_rdma.c+11−4

 	} while (nsegs);
 done:
-	return xdr_stream_encode_item_absent(xdr);
+	if (xdr_stream_encode_item_absent(xdr) < 0)
+		return -EMSGSIZE;
+	return 0;
 }
 /* Register and XDR encode the Write list. Supports encoding a list
 	*segcount = cpu_to_be32(nchunks);
 done:
-	return xdr_stream_encode_item_absent(xdr);
+	if (xdr_stream_encode_item_absent(xdr) < 0)
+		return -EMSGSIZE;
+	return 0;
 }
 /* Register and XDR encode the Reply chunk. Supports encoding an array
 	int nsegs, nchunks;
 	__be32 *segcount;
-	if (wtype != rpcrdma_replych)
+	if (wtype != rpcrdma_replych) {
-		return xdr_stream_encode_item_absent(xdr);
+		if (xdr_stream_encode_item_absent(xdr) < 0)
+			return -EMSGSIZE;
+		return 0;
+	}
 	seg = req->rl_segments;
 	nsegs = rpcrdma_convert_iovs(r_xprt, &rqst->rq_rcv_buf, 0, wtype, seg);

net/sunrpc/xprtrdma/verbs.c+2−1

 	case RDMA_CM_EVENT_DISCONNECTED:
 		ep->re_connect_status = -ECONNABORTED;
 disconnected:
+		xprt_force_disconnect(xprt);
 		return rpcrdma_ep_destroy(ep);
 	default:
 		break;
 		--ep->re_send_count;
 	}
+	trace_xprtrdma_post_send(req);
 	rc = frwr_send(r_xprt, req);
-	trace_xprtrdma_post_send(req, rc);
 	if (rc)
 		return -ENOTCONN;
 	return 0;

security/selinux/hooks.c+45−25

@@ -5842,40 +5842,60 @@ static unsigned int selinux_ipv6_postroute(void *priv, · 5841 unmodified lines
5842		5842
5843	static int selinux_netlink_send(struct sock sk, struct sk_buff skb)	5843	static int selinux_netlink_send(struct sock sk, struct sk_buff skb)
5844	{	5844	{
5845	int err = 0;	5845	int rc = 0;
5846	u32 perm;	5846	unsigned int msg_len;
		5847	unsigned int data_len = skb->len;
		5848	unsigned char *data = skb->data;
5847	struct nlmsghdr *nlh;	5849	struct nlmsghdr *nlh;
5848	struct sk_security_struct *sksec = sk->sk_security;	5850	struct sk_security_struct *sksec = sk->sk_security;
		5851	u16 sclass = sksec->sclass;
		5852	u32 perm;
5849		5853
5850	if (skb->len < NLMSG_HDRLEN) {	5854	while (data_len >= nlmsg_total_size(0)) {
5851	err = -EINVAL;	5855	nlh = (struct nlmsghdr *)data;
5852	goto out;	5856
5853	}	5857	/* NOTE: the nlmsg_len field isn't reliably set by some netlink
5854	nlh = nlmsg_hdr(skb);	5858	* users which means we can't reject skb's with bogus
		5859	* length fields; our solution is to follow what
		5860	* netlink_rcv_skb() does and simply skip processing at
		5861	* messages with length fields that are clearly junk
		5862	*/
		5863	if (nlh->nlmsg_len < NLMSG_HDRLEN \|\| nlh->nlmsg_len > data_len)
		5864	return 0;
5855		5865
5856	err = selinux_nlmsg_lookup(sksec->sclass, nlh->nlmsg_type, &perm);	5866	rc = selinux_nlmsg_lookup(sclass, nlh->nlmsg_type, &perm);
5857	if (err) {	5867	if (rc == 0) {
5858	if (err == -EINVAL) {	5868	rc = sock_has_perm(sk, perm);
		5869	if (rc)
		5870	return rc;
		5871	} else if (rc == -EINVAL) {
		5872	/* -EINVAL is a missing msg/perm mapping */
5859	pr_warn_ratelimited("SELinux: unrecognized netlink"	5873	pr_warn_ratelimited("SELinux: unrecognized netlink"
5860	" message: protocol=%hu nlmsg_type=%hu sclass=%s"	5874	" message: protocol=%hu nlmsg_type=%hu sclass=%s"
5861	" pid=%d comm=%s\n",	5875	" pid=%d comm=%s\n",
5862	sk->sk_protocol, nlh->nlmsg_type,	5876	sk->sk_protocol, nlh->nlmsg_type,
5863	secclass_map[sksec->sclass - 1].name,	5877	secclass_map[sclass - 1].name,
5864	task_pid_nr(current), current->comm);	5878	task_pid_nr(current), current->comm);
5865	if (!enforcing_enabled(&selinux_state) \|\|	5879	if (enforcing_enabled(&selinux_state) &&
5866	security_get_allow_unknown(&selinux_state))	5880	!security_get_allow_unknown(&selinux_state))
5867	err = 0;	5881	return rc;
		5882	rc = 0;
		5883	} else if (rc == -ENOENT) {
		5884	/* -ENOENT is a missing socket/class mapping, ignore */
		5885	rc = 0;
		5886	} else {
		5887	return rc;
5868	}	5888	}
5869		5889
5870	/* Ignore */	5890	/* move to the next message after applying netlink padding */
5871	if (err == -ENOENT)	5891	msg_len = NLMSG_ALIGN(nlh->nlmsg_len);
5872	err = 0;	5892	if (msg_len >= data_len)
5873	goto out;	5893	return 0;
		5894	data_len -= msg_len;
		5895	data += msg_len;
5874	}	5896	}
5875		5897
5876	err = sock_has_perm(sk, perm);	5898	return rc;
5877	out:
5878	return err;
5879	}	5899	}
5880		5900
5881	static void ipc_init_security(struct ipc_security_struct *isec, u16 sclass)	5901	static void ipc_init_security(struct ipc_security_struct *isec, u16 sclass)

security/selinux/ss/conditional.c+1−1

@@ -429,7 +429,7 @@ int cond_read_list(struct policydb p, void fp) · 428 unmodified lines
429		429
430	p->cond_list = kcalloc(len, sizeof(*p->cond_list), GFP_KERNEL);	430	p->cond_list = kcalloc(len, sizeof(*p->cond_list), GFP_KERNEL);
431	if (!p->cond_list)	431	if (!p->cond_list)
432	return rc;	432	return -ENOMEM;
433		433
434	rc = avtab_alloc(&(p->te_cond_avtab), p->te_avtab.nel);	434	rc = avtab_alloc(&(p->te_cond_avtab), p->te_avtab.nel);
435	if (rc)	435	if (rc)

sound/core/oss/pcm_plugin.c+6−4

 	plugin = snd_pcm_plug_first(plug);
 	while (plugin && frames > 0) {
 		plugin_next = plugin->next;
+		if (check_size && plugin->buf_frames &&
+		    frames > plugin->buf_frames)
+			frames = plugin->buf_frames;
 		if (plugin->dst_frames) {
 			frames = plugin->dst_frames(plugin, frames);
 			if (frames < 0)
 				return frames;
 		}
-		if (check_size && frames > plugin->buf_frames)
-			frames = plugin->buf_frames;
 		plugin = plugin_next;
 	}
 	return frames;
 	plugin = snd_pcm_plug_last(plug);
 	while (plugin && frames > 0) {
-		if (check_size && frames > plugin->buf_frames)
-			frames = plugin->buf_frames;
 		plugin_prev = plugin->prev;
 		if (plugin->src_frames) {
 			frames = plugin->src_frames(plugin, frames);
 			if (frames < 0)
 				return frames;
 		}
+		if (check_size && plugin->buf_frames &&
+		    frames > plugin->buf_frames)
+			frames = plugin->buf_frames;
 		plugin = plugin_prev;
 	}
 	return frames;

sound/isa/opti9xx/miro.c+6−3

 	spin_unlock_irqrestore(&chip->lock, flags);
 }
+static inline void snd_miro_write_mask(struct snd_miro *chip,
+		unsigned char reg, unsigned char value, unsigned char mask)
+{
+	unsigned char oldval = snd_miro_read(chip, reg);
-#define snd_miro_write_mask(chip, reg, value, mask)	\
+	snd_miro_write(chip, reg, (oldval & ~mask) | (value & mask));
-	snd_miro_write(chip, reg,			\
+}
-		(snd_miro_read(chip, reg) & ~(mask)) | ((value) & (mask)))
 /*
  *  Proc Interface

sound/isa/opti9xx/opti92x-ad1848.c+6−3

 }
-#define snd_opti9xx_write_mask(chip, reg, value, mask)	\
+static inline void snd_opti9xx_write_mask(struct snd_opti9xx *chip,
-	snd_opti9xx_write(chip, reg,			\
+		unsigned char reg, unsigned char value, unsigned char mask)
-		(snd_opti9xx_read(chip, reg) & ~(mask)) | ((value) & (mask)))
+{
+	unsigned char oldval = snd_opti9xx_read(chip, reg);
+	snd_opti9xx_write(chip, reg, (oldval & ~mask) | (value & mask));
+}
 static int snd_opti9xx_configure(struct snd_opti9xx *chip,
 					   long port,

sound/pci/hda/hda_intel.c+5−4

  * some HD-audio PCI entries are exposed without any codecs, and such devices
  * should be ignored from the beginning.
  */
-static const struct snd_pci_quirk driver_blacklist[] = {
+static const struct pci_device_id driver_blacklist[] = {
-	SND_PCI_QUIRK(0x1462, 0xcb59, "MSI TRX40 Creator", 0),
+	{ PCI_DEVICE_SUB(0x1022, 0x1487, 0x1043, 0x874f) }, /* ASUS ROG Zenith II / Strix */
-	SND_PCI_QUIRK(0x1462, 0xcb60, "MSI TRX40", 0),
+	{ PCI_DEVICE_SUB(0x1022, 0x1487, 0x1462, 0xcb59) }, /* MSI TRX40 Creator */
+	{ PCI_DEVICE_SUB(0x1022, 0x1487, 0x1462, 0xcb60) }, /* MSI TRX40 */
 	{}
 };
 	bool schedule_probe;
 	int err;
-	if (snd_pci_quirk_lookup(pci, driver_blacklist)) {
+	if (pci_match_id(driver_blacklist, pci)) {
 		dev_info(&pci->dev, "Skipping the blacklisted device\n");
 		return -ENODEV;
 	}

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

 	/* Add sanity check to pass klockwork check.
 	 * This should never happen.
 	 */
-	if (WARN_ON(spdif == NULL))
+	if (WARN_ON(spdif == NULL)) {
+		mutex_unlock(&codec->spdif_mutex);
 		return true;
+	}
 	non_pcm = !!(spdif->status & IEC958_AES0_NONAUDIO);
 	mutex_unlock(&codec->spdif_mutex);
 	return non_pcm;
 	for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
 		struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
+		struct hdmi_eld *pin_eld = &per_pin->sink_eld;
+		pin_eld->eld_valid = false;
 		hdmi_present_sense(per_pin, 0);
 	}

sound/pci/hda/patch_realtek.c+1−0

@@ -7420,6 +7420,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { · 7419 unmodified lines
7420	SND_PCI_QUIRK(0x1558, 0x8560, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC),	7420	SND_PCI_QUIRK(0x1558, 0x8560, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC),
7421	SND_PCI_QUIRK(0x1558, 0x8561, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC),	7421	SND_PCI_QUIRK(0x1558, 0x8561, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC),
7422	SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),	7422	SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),
		7423	SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
7423	SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),	7424	SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
7424	SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),	7425	SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
7425	SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),	7426	SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),

sound/usb/line6/podhd.c+5−17

 enum {
 	LINE6_PODHD300,
 	LINE6_PODHD400,
-	LINE6_PODHD500_0,
+	LINE6_PODHD500,
-	LINE6_PODHD500_1,
 	LINE6_PODX3,
 	LINE6_PODX3LIVE,
 	LINE6_PODHD500X,
 	/* TODO: no need to alloc data interfaces when only audio is used */
 	{ LINE6_DEVICE(0x5057),    .driver_info = LINE6_PODHD300 },
 	{ LINE6_DEVICE(0x5058),    .driver_info = LINE6_PODHD400 },
-	{ LINE6_IF_NUM(0x414D, 0), .driver_info = LINE6_PODHD500_0 },
+	{ LINE6_IF_NUM(0x414D, 0), .driver_info = LINE6_PODHD500 },
-	{ LINE6_IF_NUM(0x414D, 1), .driver_info = LINE6_PODHD500_1 },
 	{ LINE6_IF_NUM(0x414A, 0), .driver_info = LINE6_PODX3 },
 	{ LINE6_IF_NUM(0x414B, 0), .driver_info = LINE6_PODX3LIVE },
 	{ LINE6_IF_NUM(0x4159, 0), .driver_info = LINE6_PODHD500X },
 		.ep_audio_r = 0x82,
 		.ep_audio_w = 0x01,
 	},
-	[LINE6_PODHD500_0] = {
+	[LINE6_PODHD500] = {
 		.id = "PODHD500",
 		.name = "POD HD500",
-		.capabilities	= LINE6_CAP_PCM
+		.capabilities	= LINE6_CAP_PCM | LINE6_CAP_CONTROL
 				| LINE6_CAP_HWMON,
 		.altsetting = 1,
-		.ep_ctrl_r = 0x81,
+		.ctrl_if = 1,
-		.ep_ctrl_w = 0x01,
-		.ep_audio_r = 0x86,
-		.ep_audio_w = 0x02,
-	},
-	[LINE6_PODHD500_1] = {
-		.id = "PODHD500",
-		.name = "POD HD500",
-		.capabilities	= LINE6_CAP_PCM
-				| LINE6_CAP_HWMON,
-		.altsetting = 0,
 		.ep_ctrl_r = 0x81,
 		.ep_ctrl_w = 0x01,
 		.ep_audio_r = 0x86,

sound/usb/quirks.c+1−1

@@ -1687,7 +1687,7 @@ u64 snd_usb_interface_dsd_format_quirks(struct snd_usb_audio *chip, · 1686 unmodified lines
1687		1687
1688	case USB_ID(0x0d8c, 0x0316): /* Hegel HD12 DSD */	1688	case USB_ID(0x0d8c, 0x0316): /* Hegel HD12 DSD */
1689	case USB_ID(0x10cb, 0x0103): /* The Bit Opus #3; with fp->dsd_raw */	1689	case USB_ID(0x10cb, 0x0103): /* The Bit Opus #3; with fp->dsd_raw */
1690	case USB_ID(0x16b0, 0x06b2): /* NuPrime DAC-10 */	1690	case USB_ID(0x16d0, 0x06b2): /* NuPrime DAC-10 */
1691	case USB_ID(0x16d0, 0x09dd): /* Encore mDSD */	1691	case USB_ID(0x16d0, 0x09dd): /* Encore mDSD */
1692	case USB_ID(0x16d0, 0x0733): /* Furutech ADL Stratos */	1692	case USB_ID(0x16d0, 0x0733): /* Furutech ADL Stratos */
1693	case USB_ID(0x16d0, 0x09db): /* NuPrime Audio DAC-9 */	1693	case USB_ID(0x16d0, 0x09db): /* NuPrime Audio DAC-9 */

tools/testing/selftests/ftrace/test.d/ftrace/fgraph-filter-stack.tc+1−4

     exit_unsupported
 fi
-if [ ! -f set_ftrace_filter ]; then
+check_filter_file set_ftrace_filter
-    echo "set_ftrace_filter not found? Is dynamic ftrace not set?"
-    exit_unsupported
-fi
 do_reset() {
     if [ -e /proc/sys/kernel/stack_tracer_enabled ]; then

tools/testing/selftests/ftrace/test.d/ftrace/fgraph-filter.tc+2−0

@@ -9,6 +9,8 @@ if ! grep -q function_graph available_tracers; then · 8 unmodified lines
9	exit_unsupported	9	exit_unsupported
10	fi	10	fi
11		11
		12	check_filter_file set_ftrace_filter
		13
12	fail() { # msg	14	fail() { # msg
13	echo $1	15	echo $1
14	exit_fail	16	exit_fail

tools/testing/selftests/ftrace/test.d/ftrace/func-filter-glob.tc+2−0

@@ -9,6 +9,8 @@ if ! grep -q function available_tracers; then · 8 unmodified lines
9	exit_unsupported	9	exit_unsupported
10	fi	10	fi
11		11
		12	check_filter_file set_ftrace_filter
		13
12	disable_tracing	14	disable_tracing
13	clear_trace	15	clear_trace
14		16

tools/testing/selftests/ftrace/test.d/ftrace/func-filter-notrace-pid.tc+1−4

@@ -15,10 +15,7 @@ if [ ! -f set_ftrace_notrace_pid ]; then · 14 unmodified lines
15	exit_unsupported	15	exit_unsupported
16	fi	16	fi
17		17
18	if [ ! -f set_ftrace_filter ]; then	18	check_filter_file set_ftrace_filter
19	echo "set_ftrace_filter not found? Is function tracer not set?"
20	exit_unsupported
21	fi
22		19
23	do_function_fork=1	20	do_function_fork=1
24		21

tools/testing/selftests/ftrace/test.d/ftrace/func-filter-pid.tc+1−4

@@ -16,10 +16,7 @@ if [ ! -f set_ftrace_pid ]; then · 15 unmodified lines
16	exit_unsupported	16	exit_unsupported
17	fi	17	fi
18		18
19	if [ ! -f set_ftrace_filter ]; then	19	check_filter_file set_ftrace_filter
20	echo "set_ftrace_filter not found? Is function tracer not set?"
21	exit_unsupported
22	fi
23		20
24	do_function_fork=1	21	do_function_fork=1
25		22

tools/testing/selftests/ftrace/test.d/ftrace/func-filter-stacktrace.tc+1−1

@@ -3,7 +3,7 @@ · 2 unmodified lines
3	# description: ftrace - stacktrace filter command	3	# description: ftrace - stacktrace filter command
4	# flags: instance	4	# flags: instance
5		5
6	[ ! -f set_ftrace_filter ] && exit_unsupported	6	check_filter_file set_ftrace_filter
7		7
8	echo _do_fork:stacktrace >> set_ftrace_filter	8	echo _do_fork:stacktrace >> set_ftrace_filter
9		9

tools/testing/selftests/ftrace/test.d/ftrace/func_event_triggers.tc+1−4

 #
 # The triggers are set within the set_ftrace_filter file
-if [ ! -f set_ftrace_filter ]; then
+check_filter_file set_ftrace_filter
-    echo "set_ftrace_filter not found? Is dynamic ftrace not set?"
-    exit_unsupported
-fi
 do_reset() {
     reset_ftrace_filter

tools/testing/selftests/ftrace/test.d/ftrace/func_mod_trace.tc+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	# SPDX-License-Identifier: GPL-2.0	2	# SPDX-License-Identifier: GPL-2.0
3	# description: ftrace - function trace on module	3	# description: ftrace - function trace on module
4		4
5	[ ! -f set_ftrace_filter ] && exit_unsupported	5	check_filter_file set_ftrace_filter
6		6
7	: "mod: allows to filter a non exist function"	7	: "mod: allows to filter a non exist function"
8	echo 'non_exist_func:mod:non_exist_module' > set_ftrace_filter	8	echo 'non_exist_func:mod:non_exist_module' > set_ftrace_filter

tools/testing/selftests/ftrace/test.d/ftrace/func_profiler.tc+1−4

     exit_unsupported;
 fi
-if [ ! -f set_ftrace_filter ]; then
+check_filter_file set_ftrace_filter
-    echo "set_ftrace_filter not found? Is dynamic ftrace not set?"
-    exit_unsupported
-fi
 if [ ! -f function_profile_enabled ]; then
     echo "function_profile_enabled not found, function profiling enabled?"

tools/testing/selftests/ftrace/test.d/ftrace/func_set_ftrace_file.tc+1−4

 #
 # The triggers are set within the set_ftrace_filter file
-if [ ! -f set_ftrace_filter ]; then
+check_filter_file set_ftrace_filter
-    echo "set_ftrace_filter not found? Is dynamic ftrace not set?"
-    exit_unsupported
-fi
 fail() { # mesg
     echo $1

tools/testing/selftests/ftrace/test.d/ftrace/func_stack_tracer.tc+2−0

@@ -8,6 +8,8 @@ if [ ! -f stack_trace ]; then · 7 unmodified lines
8	exit_unsupported	8	exit_unsupported
9	fi	9	fi
10		10
		11	check_filter_file stack_trace_filter
		12
11	echo > stack_trace_filter	13	echo > stack_trace_filter
12	echo 0 > stack_max_size	14	echo 0 > stack_max_size
13	echo 1 > /proc/sys/kernel/stack_tracer_enabled	15	echo 1 > /proc/sys/kernel/stack_tracer_enabled

tools/testing/selftests/ftrace/test.d/ftrace/func_traceonoff_triggers.tc+1−4

 #
 # The triggers are set within the set_ftrace_filter file
-if [ ! -f set_ftrace_filter ]; then
+check_filter_file set_ftrace_filter
-    echo "set_ftrace_filter not found? Is dynamic ftrace not set?"
-    exit_unsupported
-fi
 fail() { # mesg
     echo $1

tools/testing/selftests/ftrace/test.d/functions+6−0

@@ -1,3 +1,9 @@
		1	check_filter_file() { # check filter file introduced by dynamic ftrace
		2	if [ ! -f "$1" ]; then
		3	echo "$1 not found? Is dynamic ftrace not set?"
		4	exit_unsupported
		5	fi
		6	}
1		7
2	clear_trace() { # reset trace output	8	clear_trace() { # reset trace output
3	echo > trace	9	echo > trace

tools/testing/selftests/ftrace/test.d/kprobe/kprobe_args_type.tc+1−1

@@ -38,7 +38,7 @@ for width in 64 32 16 8; do · 37 unmodified lines
38	echo 0 > events/kprobes/testprobe/enable	38	echo 0 > events/kprobes/testprobe/enable
39		39
40	: "Confirm the arguments is recorded in given types correctly"	40	: "Confirm the arguments is recorded in given types correctly"
41	ARGS=`grep "testprobe" trace \| sed -e 's/.* arg1=$.$ arg2=$.$ arg3=$.$ arg4=$.$/\1 \2 \3 \4/'`	41	ARGS=`grep "testprobe" trace \| head -n 1 \| sed -e 's/.* arg1=$.$ arg2=$.$ arg3=$.$ arg4=$.$/\1 \2 \3 \4/'`
42	check_types $ARGS $width	42	check_types $ARGS $width
43		43
44	: "Clear event for next loop"	44	: "Clear event for next loop"

tools/testing/selftests/ftrace/test.d/kprobe/kprobe_ftrace.tc+2−0

@@ -5,6 +5,8 @@ · 4 unmodified lines
5	[ -f kprobe_events ] \|\| exit_unsupported # this is configurable	5	[ -f kprobe_events ] \|\| exit_unsupported # this is configurable
6	grep "function" available_tracers \|\| exit_unsupported # this is configurable	6	grep "function" available_tracers \|\| exit_unsupported # this is configurable
7		7
		8	check_filter_file set_ftrace_filter
		9
8	# prepare	10	# prepare
9	echo nop > current_tracer	11	echo nop > current_tracer
10	echo _do_fork > set_ftrace_filter	12	echo _do_fork > set_ftrace_filter

tools/testing/selftests/gpio/Makefile+6−6

@@ -1,13 +1,13 @@
1	# SPDX-License-Identifier: GPL-2.0	1	# SPDX-License-Identifier: GPL-2.0
2		2
3	MOUNT_CFLAGS := $(shell pkg-config --cflags mount 2>/dev/null)	3	VAR_CFLAGS := $(shell pkg-config --cflags mount 2>/dev/null)
4	MOUNT_LDLIBS := $(shell pkg-config --libs mount 2>/dev/null)	4	VAR_LDLIBS := $(shell pkg-config --libs mount 2>/dev/null)
5	ifeq ($(MOUNT_LDLIBS),)	5	ifeq ($(VAR_LDLIBS),)
6	MOUNT_LDLIBS := -lmount -I/usr/include/libmount	6	VAR_LDLIBS := -lmount -I/usr/include/libmount
7	endif	7	endif
8		8
9	CFLAGS += -O2 -g -std=gnu99 -Wall -I../../../../usr/include/ $(MOUNT_CFLAGS)	9	CFLAGS += -O2 -g -std=gnu99 -Wall -I../../../../usr/include/ $(VAR_CFLAGS)
10	LDLIBS += $(MOUNT_LDLIBS)	10	LDLIBS += $(VAR_LDLIBS)
11		11
12	TEST_PROGS := gpio-mockup.sh	12	TEST_PROGS := gpio-mockup.sh
13	TEST_FILES := gpio-mockup-sysfs.sh	13	TEST_FILES := gpio-mockup-sysfs.sh

tools/testing/selftests/intel_pstate/Makefile+1−1

@@ -1,6 +1,6 @@
1	# SPDX-License-Identifier: GPL-2.0	1	# SPDX-License-Identifier: GPL-2.0
2	CFLAGS := $(CFLAGS) -Wall -D_GNU_SOURCE	2	CFLAGS := $(CFLAGS) -Wall -D_GNU_SOURCE
3	LDLIBS := $(LDLIBS) -lm	3	LDLIBS += -lm
4		4
5	uname_M := $(shell uname -m 2>/dev/null \|\| echo not)	5	uname_M := $(shell uname -m 2>/dev/null \|\| echo not)
6	ARCH ?= $(shell echo $(uname_M) \| sed -e s/i.86/x86/ -e s/x86_64/x86/)	6	ARCH ?= $(shell echo $(uname_M) \| sed -e s/i.86/x86/ -e s/x86_64/x86/)

tools/testing/selftests/kselftest_deps.sh+272−0

@@ -0,0 +1,272 @@
	1	#!/bin/bash
	2	# SPDX-License-Identifier: GPL-2.0
	3	# kselftest_deps.sh
	4	#
	5	# Checks for kselftest build dependencies on the build system.
	6	# Copyright (c) 2020 Shuah Khan <skhan@linuxfoundation.org>
	7	#
	8	#
	9
	10	usage()
	11	{
	12
	13	echo -e "Usage: $0 -[p] <compiler> [test_name]\n"
	14	echo -e "\tkselftest_deps.sh [-p] gcc"
	15	echo -e "\tkselftest_deps.sh [-p] gcc vm"
	16	echo -e "\tkselftest_deps.sh [-p] aarch64-linux-gnu-gcc"
	17	echo -e "\tkselftest_deps.sh [-p] aarch64-linux-gnu-gcc vm\n"
	18	echo "- Should be run in selftests directory in the kernel repo."
	19	echo "- Checks if Kselftests can be built/cross-built on a system."
	20	echo "- Parses all test/sub-test Makefile to find library dependencies."
	21	echo "- Runs compile test on a trivial C file with LDLIBS specified"
	22	echo " in the test Makefiles to identify missing library dependencies."
	23	echo "- Prints suggested target list for a system filtering out tests"
	24	echo " failed the build dependency check from the TARGETS in Selftests"
	25	echo " main Makefile when optional -p is specified."
	26	echo "- Prints pass/fail dependency check for each tests/sub-test."
	27	echo "- Prints pass/fail targets and libraries."
	28	echo "- Default: runs dependency checks on all tests."
	29	echo "- Optional test name can be specified to check dependencies for it."
	30	exit 1
	31
	32	}
	33
	34	# Start main()
	35	main()
	36	{
	37
	38	base_dir=`pwd`
	39	# Make sure we're in the selftests top-level directory.
	40	if [ $(basename "$base_dir") != "selftests" ]; then
	41	echo -e "\tPlease run $0 in"
	42	echo -e "\ttools/testing/selftests directory ..."
	43	exit 1
	44	fi
	45
	46	print_targets=0
	47
	48	while getopts "p" arg; do
	49	case $arg in
	50	p)
	51	print_targets=1
	52	shift;;
	53	esac
	54	done
	55
	56	if [ $# -eq 0 ]
	57	then
	58	usage
	59	fi
	60
	61	# Compiler
	62	CC=$1
	63
	64	tmp_file=$(mktemp).c
	65	trap "rm -f $tmp_file.o $tmp_file $tmp_file.bin" EXIT
	66	#echo $tmp_file
	67
	68	pass=$(mktemp).out
	69	trap "rm -f $pass" EXIT
	70	#echo $pass
	71
	72	fail=$(mktemp).out
	73	trap "rm -f $fail" EXIT
	74	#echo $fail
	75
	76	# Generate tmp source fire for compile test
	77	cat << "EOF" > $tmp_file
	78	int main()
	79	{
	80	}
	81	EOF
	82
	83	# Save results
	84	total_cnt=0
	85	fail_trgts=()
	86	fail_libs=()
	87	fail_cnt=0
	88	pass_trgts=()
	89	pass_libs=()
	90	pass_cnt=0
	91
	92	# Get all TARGETS from selftests Makefile
	93	targets=$(egrep "^TARGETS +\|^TARGETS =" Makefile \| cut -d "=" -f2)
	94
	95	# Single test case
	96	if [ $# -eq 2 ]
	97	then
	98	test=$2/Makefile
	99
	100	l1_test $test
	101	l2_test $test
	102	l3_test $test
	103
	104	print_results $1 $2
	105	exit $?
	106	fi
	107
	108	# Level 1: LDLIBS set static.
	109	#
	110	# Find all LDLIBS set statically for all executables built by a Makefile
	111	# and filter out VAR_LDLIBS to discard the following:
	112	# gpio/Makefile:LDLIBS += $(VAR_LDLIBS)
	113	# Append space at the end of the list to append more tests.
	114
	115	l1_tests=$(grep -r --include=Makefile "^LDLIBS" \| \
	116	grep -v "VAR_LDLIBS" \| awk -F: '{print $1}')
	117
	118	# Level 2: LDLIBS set dynamically.
	119	#
	120	# Level 2
	121	# Some tests have multiple valid LDLIBS lines for individual sub-tests
	122	# that need dependency checks. Find them and append them to the tests
	123	# e.g: vm/Makefile:$(OUTPUT)/userfaultfd: LDLIBS += -lpthread
	124	# Filter out VAR_LDLIBS to discard the following:
	125	# memfd/Makefile:$(OUTPUT)/fuse_mnt: LDLIBS += $(VAR_LDLIBS)
	126	# Append space at the end of the list to append more tests.
	127
	128	l2_tests=$(grep -r --include=Makefile ": LDLIBS" \| \
	129	grep -v "VAR_LDLIBS" \| awk -F: '{print $1}')
	130
	131	# Level 3
	132	# gpio, memfd and others use pkg-config to find mount and fuse libs
	133	# respectively and save it in VAR_LDLIBS. If pkg-config doesn't find
	134	# any, VAR_LDLIBS set to default.
	135	# Use the default value and filter out pkg-config for dependency check.
	136	# e.g:
	137	# gpio/Makefile
	138	# VAR_LDLIBS := $(shell pkg-config --libs mount) 2>/dev/null)
	139	# memfd/Makefile
	140	# VAR_LDLIBS := $(shell pkg-config fuse --libs 2>/dev/null)
	141
	142	l3_tests=$(grep -r --include=Makefile "^VAR_LDLIBS" \| \
	143	grep -v "pkg-config" \| awk -F: '{print $1}')
	144
	145	#echo $l1_tests
	146	#echo $l2_1_tests
	147	#echo $l3_tests
	148
	149	all_tests
	150	print_results $1 $2
	151
	152	exit $?
	153	}
	154	# end main()
	155
	156	all_tests()
	157	{
	158	for test in $l1_tests; do
	159	l1_test $test
	160	done
	161
	162	for test in $l2_tests; do
	163	l2_test $test
	164	done
	165
	166	for test in $l3_tests; do
	167	l3_test $test
	168	done
	169	}
	170
	171	# Use same parsing used for l1_tests and pick libraries this time.
	172	l1_test()
	173	{
	174	test_libs=$(grep --include=Makefile "^LDLIBS" $test \| \
	175	grep -v "VAR_LDLIBS" \| \
	176	sed -e 's/\:/ /' \| \
	177	sed -e 's/+/ /' \| cut -d "=" -f 2)
	178
	179	check_libs $test $test_libs
	180	}
	181
	182	# Use same parsing used for l2__tests and pick libraries this time.
	183	l2_test()
	184	{
	185	test_libs=$(grep --include=Makefile ": LDLIBS" $test \| \
	186	grep -v "VAR_LDLIBS" \| \
	187	sed -e 's/\:/ /' \| sed -e 's/+/ /' \| \
	188	cut -d "=" -f 2)
	189
	190	check_libs $test $test_libs
	191	}
	192
	193	l3_test()
	194	{
	195	test_libs=$(grep --include=Makefile "^VAR_LDLIBS" $test \| \
	196	grep -v "pkg-config" \| sed -e 's/\:/ /' \|
	197	sed -e 's/+/ /' \| cut -d "=" -f 2)
	198
	199	check_libs $test $test_libs
	200	}
	201
	202	check_libs()
	203	{
	204
	205	if [[ ! -z "${test_libs// }" ]]
	206	then
	207
	208	#echo $test_libs
	209
	210	for lib in $test_libs; do
	211
	212	let total_cnt+=1
	213	$CC -o $tmp_file.bin $lib $tmp_file > /dev/null 2>&1
	214	if [ $? -ne 0 ]; then
	215	echo "FAIL: $test dependency check: $lib" >> $fail
	216	let fail_cnt+=1
	217	fail_libs+="$lib "
	218	fail_target=$(echo "$test" \| cut -d "/" -f1)
	219	fail_trgts+="$fail_target "
	220	targets=$(echo "$targets" \| grep -v "$fail_target")
	221	else
	222	echo "PASS: $test dependency check passed $lib" >> $pass
	223	let pass_cnt+=1
	224	pass_libs+="$lib "
	225	pass_trgts+="$(echo "$test" \| cut -d "/" -f1) "
	226	fi
	227
	228	done
	229	fi
	230	}
	231
	232	print_results()
	233	{
	234	echo -e "========================================================";
	235	echo -e "Kselftest Dependency Check for [$0 $1 $2] results..."
	236
	237	if [ $print_targets -ne 0 ]
	238	then
	239	echo -e "Suggested Selftest Targets for your configuration:"
	240	echo -e "$targets";
	241	fi
	242
	243	echo -e "========================================================";
	244	echo -e "Checked tests defining LDLIBS dependencies"
	245	echo -e "--------------------------------------------------------";
	246	echo -e "Total tests with Dependencies:"
	247	echo -e "$total_cnt Pass: $pass_cnt Fail: $fail_cnt";
	248
	249	if [ $pass_cnt -ne 0 ]; then
	250	echo -e "--------------------------------------------------------";
	251	cat $pass
	252	echo -e "--------------------------------------------------------";
	253	echo -e "Targets passed build dependency check on system:"
	254	echo -e "$(echo "$pass_trgts" \| xargs -n1 \| sort -u \| xargs)"
	255	fi
	256
	257	if [ $fail_cnt -ne 0 ]; then
	258	echo -e "--------------------------------------------------------";
	259	cat $fail
	260	echo -e "--------------------------------------------------------";
	261	echo -e "Targets failed build dependency check on system:"
	262	echo -e "$(echo "$fail_trgts" \| xargs -n1 \| sort -u \| xargs)"
	263	echo -e "--------------------------------------------------------";
	264	echo -e "Missing libraries system"
	265	echo -e "$(echo "$fail_libs" \| xargs -n1 \| sort -u \| xargs)"
	266	fi
	267
	268	echo -e "--------------------------------------------------------";
	269	echo -e "========================================================";
	270	}
	271
	272	main "$@"

tools/testing/selftests/memfd/Makefile+12−2

 TEST_PROGS := run_fuse_test.sh run_hugetlbfs_test.sh
 TEST_GEN_FILES := fuse_test fuse_mnt
-fuse_mnt.o: CFLAGS += $(shell pkg-config fuse --cflags)
+VAR_CFLAGS := $(shell pkg-config fuse --cflags 2>/dev/null)
+ifeq ($(VAR_CFLAGS),)
+VAR_CFLAGS := -D_FILE_OFFSET_BITS=64 -I/usr/include/fuse
+endif
+VAR_LDLIBS := $(shell pkg-config fuse --libs 2>/dev/null)
+ifeq ($(VAR_LDLIBS),)
+VAR_LDLIBS := -lfuse -pthread
+endif
+fuse_mnt.o: CFLAGS += $(VAR_CFLAGS)
 include ../lib.mk
-$(OUTPUT)/fuse_mnt: LDLIBS += $(shell pkg-config fuse --libs)
+$(OUTPUT)/fuse_mnt: LDLIBS += $(VAR_LDLIBS)
 $(OUTPUT)/memfd_test: memfd_test.c common.c
 $(OUTPUT)/fuse_test: fuse_test.c common.c