commit: 769023a25fa060b150715c78c10a6d44ab515704 Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Wed May 6 11:47:42 2020 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Wed May 6 11:47:42 2020 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=769023a2
Linux patch 5.6.11 Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org> 0000_README | 4 + 1010_linux-5.6.11.patch | 2447 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 2451 insertions(+) diff --git a/0000_README b/0000_README index 25aa563..13f0a7d 100644 --- a/0000_README +++ b/0000_README @@ -83,6 +83,10 @@ Patch: 1009_linux-5.6.10.patch From: http://www.kernel.org Desc: Linux 5.6.10 +Patch: 1010_linux-5.6.11.patch +From: http://www.kernel.org +Desc: Linux 5.6.11 + Patch: 1500_XATTR_USER_PREFIX.patch From: https://bugs.gentoo.org/show_bug.cgi?id=470644 Desc: Support for namespace user.pax.* on tmpfs. diff --git a/1010_linux-5.6.11.patch b/1010_linux-5.6.11.patch new file mode 100644 index 0000000..7ada05b --- /dev/null +++ b/1010_linux-5.6.11.patch @@ -0,0 +1,2447 @@ +diff --git a/Makefile b/Makefile +index 4b29cc9769e8..5dedd6f9ad75 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 5 + PATCHLEVEL = 6 +-SUBLEVEL = 10 ++SUBLEVEL = 11 + EXTRAVERSION = + NAME = Kleptomaniac Octopus + +diff --git a/arch/arm/boot/dts/imx6qdl-sr-som-ti.dtsi b/arch/arm/boot/dts/imx6qdl-sr-som-ti.dtsi +index 44a97ba93a95..352ac585ca6b 100644 +--- a/arch/arm/boot/dts/imx6qdl-sr-som-ti.dtsi ++++ b/arch/arm/boot/dts/imx6qdl-sr-som-ti.dtsi +@@ -153,6 +153,7 @@ + bus-width = <4>; + keep-power-in-suspend; + mmc-pwrseq = <&pwrseq_ti_wifi>; ++ cap-power-off-card; + non-removable; + vmmc-supply = <&vcc_3v3>; + /* vqmmc-supply = <&nvcc_sd1>; - MMC layer doesn't like it! */ +diff --git a/arch/arm64/kernel/vdso/Makefile b/arch/arm64/kernel/vdso/Makefile +index dd2514bb1511..3862cad2410c 100644 +--- a/arch/arm64/kernel/vdso/Makefile ++++ b/arch/arm64/kernel/vdso/Makefile +@@ -32,7 +32,7 @@ UBSAN_SANITIZE := n + OBJECT_FILES_NON_STANDARD := y + KCOV_INSTRUMENT := n + +-CFLAGS_vgettimeofday.o = -O2 -mcmodel=tiny ++CFLAGS_vgettimeofday.o = -O2 -mcmodel=tiny -fasynchronous-unwind-tables + + ifneq ($(c-gettimeofday-y),) + CFLAGS_vgettimeofday.o += -include $(c-gettimeofday-y) +diff --git a/arch/x86/hyperv/hv_init.c b/arch/x86/hyperv/hv_init.c +index 624f5d9b0f79..fd51bac11b46 100644 +--- a/arch/x86/hyperv/hv_init.c ++++ b/arch/x86/hyperv/hv_init.c +@@ -73,7 +73,8 @@ static int hv_cpu_init(unsigned int cpu) + 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); +@@ -254,6 +255,7 @@ static int __init hv_pci_init(void) + 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 +@@ -270,12 +272,17 @@ static int hv_suspend(void) + 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); +@@ -288,6 +295,7 @@ static void hv_resume(void) + 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, +diff --git a/block/partition-generic.c b/block/partition-generic.c +index ebe4c2e9834b..8a7906fa96fd 100644 +--- a/block/partition-generic.c ++++ b/block/partition-generic.c +@@ -468,7 +468,7 @@ int blk_drop_partitions(struct gendisk *disk, struct block_device *bdev) + + if (!disk_part_scan_enabled(disk)) + return 0; +- if (bdev->bd_part_count || bdev->bd_openers > 1) ++ if (bdev->bd_part_count) + return -EBUSY; + res = invalidate_partition(disk, 0); + if (res) +diff --git a/drivers/acpi/device_pm.c b/drivers/acpi/device_pm.c +index b2263ec67b43..5832bc10aca8 100644 +--- a/drivers/acpi/device_pm.c ++++ b/drivers/acpi/device_pm.c +@@ -273,13 +273,13 @@ int acpi_device_set_power(struct acpi_device *device, int state) + end: + if (result) { + dev_warn(&device->dev, "Failed to change power state to %s\n", +- acpi_power_state_string(state)); ++ acpi_power_state_string(target_state)); + } else { + device->power.state = target_state; + ACPI_DEBUG_PRINT((ACPI_DB_INFO, + "Device [%s] transitioned to %s\n", + device->pnp.bus_id, +- acpi_power_state_string(state))); ++ acpi_power_state_string(target_state))); + } + + return result; +diff --git a/drivers/crypto/caam/caamalg.c b/drivers/crypto/caam/caamalg.c +index ef1a65f4fc92..11ae7f1ff30d 100644 +--- a/drivers/crypto/caam/caamalg.c ++++ b/drivers/crypto/caam/caamalg.c +@@ -1791,7 +1791,7 @@ static struct skcipher_edesc *skcipher_edesc_alloc(struct skcipher_request *req, + + 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, +diff --git a/drivers/dma-buf/dma-buf.c b/drivers/dma-buf/dma-buf.c +index c343c7c10b4c..e7589d91de8f 100644 +--- a/drivers/dma-buf/dma-buf.c ++++ b/drivers/dma-buf/dma-buf.c +@@ -388,7 +388,8 @@ static long dma_buf_ioctl(struct file *file, + + 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: +diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig +index 5142da401db3..c7e1dfe81d1e 100644 +--- a/drivers/dma/Kconfig ++++ b/drivers/dma/Kconfig +@@ -241,7 +241,8 @@ config FSL_RAID + + config HISI_DMA + tristate "HiSilicon DMA Engine support" +- depends on ARM64 || (COMPILE_TEST && PCI_MSI) ++ depends on ARM64 || COMPILE_TEST ++ depends on PCI_MSI + select DMA_ENGINE + select DMA_VIRTUAL_CHANNELS + help +diff --git a/drivers/dma/dmaengine.c b/drivers/dma/dmaengine.c +index 17909fd1820f..b5c4926aa76e 100644 +--- a/drivers/dma/dmaengine.c ++++ b/drivers/dma/dmaengine.c +@@ -151,10 +151,6 @@ static void chan_dev_release(struct device *dev) + 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); + } + +@@ -952,27 +948,9 @@ static int get_dma_id(struct dma_device *device) + } + + static int __dma_async_device_channel_register(struct dma_device *device, +- struct dma_chan *chan, +- int chan_id) ++ struct dma_chan *chan) + { + 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) +@@ -988,29 +966,36 @@ static int __dma_async_device_channel_register(struct dma_device *device, + * 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; + } + +@@ -1019,7 +1004,7 @@ int dma_async_device_channel_register(struct dma_device *device, + { + int rc; + +- rc = __dma_async_device_channel_register(device, chan, -1); ++ rc = __dma_async_device_channel_register(device, chan); + if (rc < 0) + return rc; + +@@ -1039,6 +1024,9 @@ static void __dma_async_device_channel_unregister(struct dma_device *device, + 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); + } +@@ -1061,7 +1049,7 @@ EXPORT_SYMBOL_GPL(dma_async_device_channel_unregister); + */ + int dma_async_device_register(struct dma_device *device) + { +- int rc, i = 0; ++ int rc; + struct dma_chan* chan; + + if (!device) +@@ -1166,9 +1154,12 @@ int dma_async_device_register(struct dma_device *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; + } +@@ -1239,6 +1230,7 @@ void dma_async_device_unregister(struct dma_device *device) + */ + 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); + } +diff --git a/drivers/dma/dmatest.c b/drivers/dma/dmatest.c +index a2cadfa2e6d7..364dd34799d4 100644 +--- a/drivers/dma/dmatest.c ++++ b/drivers/dma/dmatest.c +@@ -240,7 +240,7 @@ static bool is_threaded_test_run(struct dmatest_info *info) + struct dmatest_thread *thread; + + list_for_each_entry(thread, &dtc->threads, node) { +- if (!thread->done) ++ if (!thread->done && !thread->pending) + return true; + } + } +@@ -662,8 +662,8 @@ static int dmatest_func(void *data) + flags = DMA_CTRL_ACK | DMA_PREP_INTERRUPT; + + ktime = ktime_get(); +- while (!kthread_should_stop() +- && !(params->iterations && total_tests >= params->iterations)) { ++ while (!(kthread_should_stop() || ++ (params->iterations && total_tests >= params->iterations))) { + struct dma_async_tx_descriptor *tx = NULL; + struct dmaengine_unmap_data *um; + dma_addr_t *dsts; +diff --git a/drivers/dma/ti/k3-psil.c b/drivers/dma/ti/k3-psil.c +index d7b965049ccb..fb7c8150b0d1 100644 +--- a/drivers/dma/ti/k3-psil.c ++++ b/drivers/dma/ti/k3-psil.c +@@ -27,6 +27,7 @@ struct psil_endpoint_config *psil_get_ep_config(u32 thread_id) + soc_ep_map = &j721e_ep_map; + } else { + pr_err("PSIL: No compatible machine found for map\n"); ++ mutex_unlock(&ep_map_mutex); + return ERR_PTR(-ENOTSUPP); + } + pr_debug("%s: Using map for %s\n", __func__, soc_ep_map->name); +diff --git a/drivers/gpu/drm/amd/amdgpu/navi10_sdma_pkt_open.h b/drivers/gpu/drm/amd/amdgpu/navi10_sdma_pkt_open.h +index 074a9a09c0a7..a5b60c9a2418 100644 +--- a/drivers/gpu/drm/amd/amdgpu/navi10_sdma_pkt_open.h ++++ b/drivers/gpu/drm/amd/amdgpu/navi10_sdma_pkt_open.h +@@ -73,6 +73,22 @@ + #define SDMA_OP_AQL_COPY 0 + #define SDMA_OP_AQL_BARRIER_OR 0 + ++#define SDMA_GCR_RANGE_IS_PA (1 << 18) ++#define SDMA_GCR_SEQ(x) (((x) & 0x3) << 16) ++#define SDMA_GCR_GL2_WB (1 << 15) ++#define SDMA_GCR_GL2_INV (1 << 14) ++#define SDMA_GCR_GL2_DISCARD (1 << 13) ++#define SDMA_GCR_GL2_RANGE(x) (((x) & 0x3) << 11) ++#define SDMA_GCR_GL2_US (1 << 10) ++#define SDMA_GCR_GL1_INV (1 << 9) ++#define SDMA_GCR_GLV_INV (1 << 8) ++#define SDMA_GCR_GLK_INV (1 << 7) ++#define SDMA_GCR_GLK_WB (1 << 6) ++#define SDMA_GCR_GLM_INV (1 << 5) ++#define SDMA_GCR_GLM_WB (1 << 4) ++#define SDMA_GCR_GL1_RANGE(x) (((x) & 0x3) << 2) ++#define SDMA_GCR_GLI_INV(x) (((x) & 0x3) << 0) ++ + /*define for op field*/ + #define SDMA_PKT_HEADER_op_offset 0 + #define SDMA_PKT_HEADER_op_mask 0x000000FF +diff --git a/drivers/gpu/drm/amd/amdgpu/sdma_v5_0.c b/drivers/gpu/drm/amd/amdgpu/sdma_v5_0.c +index 67b9830b7c7e..ddc8b217e8c6 100644 +--- a/drivers/gpu/drm/amd/amdgpu/sdma_v5_0.c ++++ b/drivers/gpu/drm/amd/amdgpu/sdma_v5_0.c +@@ -382,6 +382,18 @@ static void sdma_v5_0_ring_emit_ib(struct amdgpu_ring *ring, + 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 +@@ -1597,7 +1609,7 @@ static const struct amdgpu_ring_funcs sdma_v5_0_ring_funcs = { + 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, +diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +index 6240259b3a93..8136a58deb39 100644 +--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c ++++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +@@ -3212,7 +3212,8 @@ fill_plane_dcc_attributes(struct amdgpu_device *adev, + 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; +@@ -3224,6 +3225,9 @@ fill_plane_dcc_attributes(struct amdgpu_device *adev, + memset(&input, 0, sizeof(input)); + memset(&output, 0, sizeof(output)); + ++ if (force_disable_dcc) ++ return 0; ++ + if (!offset) + return 0; + +@@ -3273,7 +3277,8 @@ fill_plane_buffer_attributes(struct amdgpu_device *adev, + 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; +@@ -3379,7 +3384,8 @@ fill_plane_buffer_attributes(struct amdgpu_device *adev, + + 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; + } +@@ -3471,7 +3477,8 @@ fill_dc_plane_info_and_addr(struct amdgpu_device *adev, + 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 = +@@ -3550,7 +3557,8 @@ fill_dc_plane_info_and_addr(struct amdgpu_device *adev, + 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; + +@@ -3573,6 +3581,7 @@ static int fill_dc_plane_attributes(struct amdgpu_device *adev, + 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) +@@ -3587,9 +3596,11 @@ static int fill_dc_plane_attributes(struct amdgpu_device *adev, + 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; + +@@ -5171,6 +5182,7 @@ static int dm_plane_helper_prepare_fb(struct drm_plane *plane, + 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); +@@ -5229,11 +5241,13 @@ static int dm_plane_helper_prepare_fb(struct drm_plane *plane, + 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; +@@ -6514,7 +6528,12 @@ static void amdgpu_dm_commit_planes(struct drm_atomic_state *state, + 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]; +@@ -7935,7 +7954,8 @@ dm_determine_update_type_for_commit(struct amdgpu_display_manager *dm, + 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; + +diff --git a/drivers/gpu/drm/drm_edid.c b/drivers/gpu/drm/drm_edid.c +index 805fb004c8eb..079800a07d6e 100644 +--- a/drivers/gpu/drm/drm_edid.c ++++ b/drivers/gpu/drm/drm_edid.c +@@ -5009,7 +5009,7 @@ static struct drm_display_mode *drm_mode_displayid_detailed(struct drm_device *d + struct drm_display_mode *mode; + unsigned pixel_clock = (timings->pixel_clock[0] | + (timings->pixel_clock[1] << 8) | +- (timings->pixel_clock[2] << 16)); ++ (timings->pixel_clock[2] << 16)) + 1; + unsigned hactive = (timings->hactive[0] | timings->hactive[1] << 8) + 1; + unsigned hblank = (timings->hblank[0] | timings->hblank[1] << 8) + 1; + unsigned hsync = (timings->hsync[0] | (timings->hsync[1] & 0x7f) << 8) + 1; +diff --git a/drivers/gpu/drm/i915/gem/i915_gem_tiling.c b/drivers/gpu/drm/i915/gem/i915_gem_tiling.c +index 6c7825a2dc2a..b032d66d7c13 100644 +--- a/drivers/gpu/drm/i915/gem/i915_gem_tiling.c ++++ b/drivers/gpu/drm/i915/gem/i915_gem_tiling.c +@@ -183,21 +183,35 @@ i915_gem_object_fence_prepare(struct drm_i915_gem_object *obj, + 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; +@@ -269,6 +283,7 @@ i915_gem_object_set_tiling(struct drm_i915_gem_object *obj, + } + 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); +@@ -279,6 +294,7 @@ i915_gem_object_set_tiling(struct drm_i915_gem_object *obj, + if (vma->fence) + vma->fence->dirty = true; + } ++ spin_unlock(&obj->vma.lock); + + obj->tiling_and_stride = tiling | stride; + i915_gem_object_unlock(obj); +diff --git a/drivers/gpu/drm/i915/gem/selftests/huge_pages.c b/drivers/gpu/drm/i915/gem/selftests/huge_pages.c +index 9311250d7d6f..7a7763be6b2e 100644 +--- a/drivers/gpu/drm/i915/gem/selftests/huge_pages.c ++++ b/drivers/gpu/drm/i915/gem/selftests/huge_pages.c +@@ -1578,8 +1578,10 @@ static int igt_ppgtt_pin_update(void *arg) + unsigned int page_size = BIT(first); + + obj = i915_gem_object_create_internal(dev_priv, page_size); +- if (IS_ERR(obj)) +- return PTR_ERR(obj); ++ if (IS_ERR(obj)) { ++ err = PTR_ERR(obj); ++ goto out_vm; ++ } + + vma = i915_vma_instance(obj, vm, NULL); + if (IS_ERR(vma)) { +@@ -1632,8 +1634,10 @@ static int igt_ppgtt_pin_update(void *arg) + } + + obj = i915_gem_object_create_internal(dev_priv, PAGE_SIZE); +- if (IS_ERR(obj)) +- return PTR_ERR(obj); ++ if (IS_ERR(obj)) { ++ err = PTR_ERR(obj); ++ goto out_vm; ++ } + + vma = i915_vma_instance(obj, vm, NULL); + if (IS_ERR(vma)) { +diff --git a/drivers/gpu/drm/i915/gt/intel_timeline.c b/drivers/gpu/drm/i915/gt/intel_timeline.c +index d8d9f1179c2b..eaa4d81b7436 100644 +--- a/drivers/gpu/drm/i915/gt/intel_timeline.c ++++ b/drivers/gpu/drm/i915/gt/intel_timeline.c +@@ -519,6 +519,8 @@ int intel_timeline_read_hwsp(struct i915_request *from, + + rcu_read_lock(); + cl = rcu_dereference(from->hwsp_cacheline); ++ if (i915_request_completed(from)) /* confirm cacheline is valid */ ++ goto unlock; + if (unlikely(!i915_active_acquire_if_busy(&cl->active))) + goto unlock; /* seqno wrapped and completed! */ + if (unlikely(i915_request_completed(from))) +diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c +index afc6aad9bf8c..c6f02b0b6c7a 100644 +--- a/drivers/gpu/drm/i915/i915_irq.c ++++ b/drivers/gpu/drm/i915/i915_irq.c +@@ -3321,7 +3321,8 @@ static void gen8_de_irq_postinstall(struct drm_i915_private *dev_priv) + { + 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; +@@ -3332,13 +3333,10 @@ static void gen8_de_irq_postinstall(struct drm_i915_private *dev_priv) + 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) +diff --git a/drivers/gpu/drm/i915/i915_vma.c b/drivers/gpu/drm/i915/i915_vma.c +index 4ff380770b32..1aee3efb4505 100644 +--- a/drivers/gpu/drm/i915/i915_vma.c ++++ b/drivers/gpu/drm/i915/i915_vma.c +@@ -158,16 +158,18 @@ vma_create(struct drm_i915_gem_object *obj, + + 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)); + +@@ -179,8 +181,6 @@ vma_create(struct drm_i915_gem_object *obj, + __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) { +@@ -225,6 +225,8 @@ vma_create(struct drm_i915_gem_object *obj, + + return vma; + ++err_unlock: ++ spin_unlock(&obj->vma.lock); + err_vma: + i915_vma_free(vma); + return ERR_PTR(-E2BIG); +diff --git a/drivers/gpu/drm/qxl/qxl_cmd.c b/drivers/gpu/drm/qxl/qxl_cmd.c +index ef09dc6bc635..d082c194cccc 100644 +--- a/drivers/gpu/drm/qxl/qxl_cmd.c ++++ b/drivers/gpu/drm/qxl/qxl_cmd.c +@@ -480,9 +480,10 @@ int qxl_hw_surface_alloc(struct qxl_device *qdev, + return ret; + + ret = qxl_release_reserve_list(release, true); +- if (ret) ++ if (ret) { ++ qxl_release_free(qdev, release); + return ret; +- ++ } + cmd = (struct qxl_surface_cmd *)qxl_release_map(qdev, release); + cmd->type = QXL_SURFACE_CMD_CREATE; + cmd->flags = QXL_SURF_FLAG_KEEP_DATA; +@@ -499,8 +500,8 @@ int qxl_hw_surface_alloc(struct qxl_device *qdev, + /* no need to add a release to the fence for this surface bo, + since it is only released when we ask to destroy the surface + and it would never signal otherwise */ +- qxl_push_command_ring_release(qdev, release, QXL_CMD_SURFACE, false); + qxl_release_fence_buffer_objects(release); ++ qxl_push_command_ring_release(qdev, release, QXL_CMD_SURFACE, false); + + surf->hw_surf_alloc = true; + spin_lock(&qdev->surf_id_idr_lock); +@@ -542,9 +543,8 @@ int qxl_hw_surface_dealloc(struct qxl_device *qdev, + cmd->surface_id = id; + qxl_release_unmap(qdev, release, &cmd->release_info); + +- qxl_push_command_ring_release(qdev, release, QXL_CMD_SURFACE, false); +- + qxl_release_fence_buffer_objects(release); ++ qxl_push_command_ring_release(qdev, release, QXL_CMD_SURFACE, false); + + return 0; + } +diff --git a/drivers/gpu/drm/qxl/qxl_display.c b/drivers/gpu/drm/qxl/qxl_display.c +index 16d73b22f3f5..92d84280096e 100644 +--- a/drivers/gpu/drm/qxl/qxl_display.c ++++ b/drivers/gpu/drm/qxl/qxl_display.c +@@ -523,8 +523,8 @@ static int qxl_primary_apply_cursor(struct drm_plane *plane) + 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; + +@@ -665,8 +665,8 @@ static void qxl_cursor_atomic_update(struct drm_plane *plane, + 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); +@@ -713,8 +713,8 @@ static void qxl_cursor_atomic_disable(struct drm_plane *plane, + 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, +diff --git a/drivers/gpu/drm/qxl/qxl_draw.c b/drivers/gpu/drm/qxl/qxl_draw.c +index 5bebf1ea1c5d..3599db096973 100644 +--- a/drivers/gpu/drm/qxl/qxl_draw.c ++++ b/drivers/gpu/drm/qxl/qxl_draw.c +@@ -209,9 +209,10 @@ void qxl_draw_dirty_fb(struct qxl_device *qdev, + goto out_release_backoff; + + rects = drawable_set_clipping(qdev, num_clips, clips_bo); +- if (!rects) ++ if (!rects) { ++ ret = -EINVAL; + goto out_release_backoff; +- ++ } + drawable = (struct qxl_drawable *)qxl_release_map(qdev, release); + + drawable->clip.type = SPICE_CLIP_TYPE_RECTS; +@@ -242,8 +243,8 @@ void qxl_draw_dirty_fb(struct qxl_device *qdev, + } + qxl_bo_kunmap(clips_bo); + +- qxl_push_command_ring_release(qdev, release, QXL_CMD_DRAW, false); + qxl_release_fence_buffer_objects(release); ++ qxl_push_command_ring_release(qdev, release, QXL_CMD_DRAW, false); + + out_release_backoff: + if (ret) +diff --git a/drivers/gpu/drm/qxl/qxl_ioctl.c b/drivers/gpu/drm/qxl/qxl_ioctl.c +index 8117a45b3610..72f3f1bbb40c 100644 +--- a/drivers/gpu/drm/qxl/qxl_ioctl.c ++++ b/drivers/gpu/drm/qxl/qxl_ioctl.c +@@ -261,11 +261,8 @@ static int qxl_process_single_command(struct qxl_device *qdev, + 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: +diff --git a/drivers/gpu/drm/scheduler/sched_main.c b/drivers/gpu/drm/scheduler/sched_main.c +index 60c4c6a1aac6..75737ec59614 100644 +--- a/drivers/gpu/drm/scheduler/sched_main.c ++++ b/drivers/gpu/drm/scheduler/sched_main.c +@@ -687,7 +687,7 @@ drm_sched_get_cleanup_job(struct drm_gpu_scheduler *sched) + */ + if ((sched->timeout != MAX_SCHEDULE_TIMEOUT && + !cancel_delayed_work(&sched->work_tdr)) || +- __kthread_should_park(sched->thread)) ++ kthread_should_park()) + return NULL; + + spin_lock_irqsave(&sched->job_list_lock, flags); +diff --git a/drivers/hv/vmbus_drv.c b/drivers/hv/vmbus_drv.c +index a68bce4d0ddb..e06c6b9555cf 100644 +--- a/drivers/hv/vmbus_drv.c ++++ b/drivers/hv/vmbus_drv.c +@@ -978,6 +978,9 @@ static int vmbus_resume(struct device *child_device) + + return drv->resume(dev); + } ++#else ++#define vmbus_suspend NULL ++#define vmbus_resume NULL + #endif /* CONFIG_PM_SLEEP */ + + /* +@@ -997,11 +1000,22 @@ static void vmbus_device_release(struct device *device) + } + + /* +- * Note: we must use SET_NOIRQ_SYSTEM_SLEEP_PM_OPS rather than +- * SET_SYSTEM_SLEEP_PM_OPS: see the comment before vmbus_bus_pm. ++ * Note: we must use the "noirq" 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 */ +@@ -2281,6 +2295,9 @@ static int vmbus_bus_resume(struct device *dev) + + 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[] = { +@@ -2291,16 +2308,24 @@ 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 +- * SET_SYSTEM_SLEEP_PM_OPS, otherwise NIC SR-IOV can not work, because the +- * "pci_dev_pm_ops" uses the "noirq" callbacks: in the resume path, the +- * pci "noirq" restore callback runs before "non-noirq" callbacks (see ++ * Note: we must use the "no_irq" ops, otherwise hibernation can not work with ++ * PCI device assignment, because "pci_dev_pm_ops" uses the "noirq" ops: in ++ * the resume path, the pci "noirq" restore op runs before "non-noirq" op (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 = { +diff --git a/drivers/i2c/busses/i2c-amd-mp2-pci.c b/drivers/i2c/busses/i2c-amd-mp2-pci.c +index 5e4800d72e00..cd3fd5ee5f65 100644 +--- a/drivers/i2c/busses/i2c-amd-mp2-pci.c ++++ b/drivers/i2c/busses/i2c-amd-mp2-pci.c +@@ -349,12 +349,12 @@ static int amd_mp2_pci_probe(struct pci_dev *pci_dev, + 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); +diff --git a/drivers/i2c/busses/i2c-aspeed.c b/drivers/i2c/busses/i2c-aspeed.c +index a7be6f24450b..538dfc4110f8 100644 +--- a/drivers/i2c/busses/i2c-aspeed.c ++++ b/drivers/i2c/busses/i2c-aspeed.c +@@ -603,6 +603,7 @@ static irqreturn_t aspeed_i2c_bus_irq(int irq, void *dev_id) + /* 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) +@@ -645,9 +646,11 @@ static irqreturn_t aspeed_i2c_bus_irq(int irq, void *dev_id) + 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; + } +diff --git a/drivers/i2c/busses/i2c-bcm-iproc.c b/drivers/i2c/busses/i2c-bcm-iproc.c +index 30efb7913b2e..b58224b7ba79 100644 +--- a/drivers/i2c/busses/i2c-bcm-iproc.c ++++ b/drivers/i2c/busses/i2c-bcm-iproc.c +@@ -360,6 +360,9 @@ static bool bcm_iproc_i2c_slave_isr(struct bcm_iproc_i2c_dev *iproc_i2c, + 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 */ +diff --git a/drivers/infiniband/core/cm.c b/drivers/infiniband/core/cm.c +index 15e99a888427..a133f9e2735e 100644 +--- a/drivers/infiniband/core/cm.c ++++ b/drivers/infiniband/core/cm.c +@@ -572,18 +572,6 @@ static int cm_init_av_by_path(struct sa_path_rec *path, + return 0; + } + +-static int cm_alloc_id(struct cm_id_private *cm_id_priv) +-{ +- int err; +- u32 id; +- +- err = xa_alloc_cyclic_irq(&cm.local_id_table, &id, cm_id_priv, +- xa_limit_32b, &cm.local_id_next, GFP_KERNEL); +- +- cm_id_priv->id.local_id = (__force __be32)id ^ cm.random_id_operand; +- return err; +-} +- + static u32 cm_local_id(__be32 local_id) + { + return (__force u32) (local_id ^ cm.random_id_operand); +@@ -825,6 +813,7 @@ struct ib_cm_id *ib_create_cm_id(struct ib_device *device, + void *context) + { + struct cm_id_private *cm_id_priv; ++ u32 id; + int ret; + + cm_id_priv = kzalloc(sizeof *cm_id_priv, GFP_KERNEL); +@@ -836,9 +825,6 @@ struct ib_cm_id *ib_create_cm_id(struct ib_device *device, + cm_id_priv->id.cm_handler = cm_handler; + cm_id_priv->id.context = context; + cm_id_priv->id.remote_cm_qpn = 1; +- ret = cm_alloc_id(cm_id_priv); +- if (ret) +- goto error; + + spin_lock_init(&cm_id_priv->lock); + init_completion(&cm_id_priv->comp); +@@ -847,11 +833,20 @@ struct ib_cm_id *ib_create_cm_id(struct ib_device *device, + INIT_LIST_HEAD(&cm_id_priv->altr_list); + atomic_set(&cm_id_priv->work_count, -1); + refcount_set(&cm_id_priv->refcount, 1); ++ ++ ret = xa_alloc_cyclic_irq(&cm.local_id_table, &id, NULL, xa_limit_32b, ++ &cm.local_id_next, GFP_KERNEL); ++ if (ret < 0) ++ goto error; ++ cm_id_priv->id.local_id = (__force __be32)id ^ cm.random_id_operand; ++ xa_store_irq(&cm.local_id_table, cm_local_id(cm_id_priv->id.local_id), ++ cm_id_priv, GFP_KERNEL); ++ + return &cm_id_priv->id; + + error: + kfree(cm_id_priv); +- return ERR_PTR(-ENOMEM); ++ return ERR_PTR(ret); + } + EXPORT_SYMBOL(ib_create_cm_id); + +diff --git a/drivers/infiniband/core/rdma_core.c b/drivers/infiniband/core/rdma_core.c +index 5128cb16bb48..177333d8bcda 100644 +--- a/drivers/infiniband/core/rdma_core.c ++++ b/drivers/infiniband/core/rdma_core.c +@@ -360,7 +360,7 @@ lookup_get_fd_uobject(const struct uverbs_api_object *obj, + * 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); + } +@@ -474,16 +474,15 @@ alloc_begin_fd_uobject(const struct uverbs_api_object *obj, + 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; +@@ -679,7 +678,6 @@ void rdma_lookup_put_uobject(struct ib_uobject *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 +@@ -696,6 +694,7 @@ void rdma_lookup_put_uobject(struct ib_uobject *uobj, + break; + } + ++ uobj->uapi_object->type_class->lookup_put(uobj, mode); + /* Pairs with the kref obtained by type->lookup_get */ + uverbs_uobject_put(uobj); + } +diff --git a/drivers/infiniband/core/uverbs_main.c b/drivers/infiniband/core/uverbs_main.c +index 2d4083bf4a04..17fc25db0311 100644 +--- a/drivers/infiniband/core/uverbs_main.c ++++ b/drivers/infiniband/core/uverbs_main.c +@@ -820,6 +820,10 @@ void uverbs_user_mmap_disassociate(struct ib_uverbs_file *ufile) + 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; + } +diff --git a/drivers/infiniband/hw/mlx4/main.c b/drivers/infiniband/hw/mlx4/main.c +index 2f5d9b181848..e5758eb0b7d2 100644 +--- a/drivers/infiniband/hw/mlx4/main.c ++++ b/drivers/infiniband/hw/mlx4/main.c +@@ -1502,8 +1502,9 @@ static int __mlx4_ib_create_default_rules( + int i; + + for (i = 0; i < ARRAY_SIZE(pdefault_rules->rules_create_list); i++) { ++ union ib_flow_spec ib_spec = {}; + int ret; +- union ib_flow_spec ib_spec; ++ + switch (pdefault_rules->rules_create_list[i]) { + case 0: + /* no rule */ +diff --git a/drivers/infiniband/hw/mlx5/qp.c b/drivers/infiniband/hw/mlx5/qp.c +index 8fe149e808af..245fef36ab4c 100644 +--- a/drivers/infiniband/hw/mlx5/qp.c ++++ b/drivers/infiniband/hw/mlx5/qp.c +@@ -5545,7 +5545,9 @@ static void to_rdma_ah_attr(struct mlx5_ib_dev *ibdev, + rdma_ah_set_path_bits(ah_attr, path->grh_mlid & 0x7f); + rdma_ah_set_static_rate(ah_attr, + path->static_rate ? path->static_rate - 5 : 0); +- if (path->grh_mlid & (1 << 7)) { ++ ++ if (path->grh_mlid & (1 << 7) || ++ ah_attr->type == RDMA_AH_ATTR_TYPE_ROCE) { + u32 tc_fl = be32_to_cpu(path->tclass_flowlabel); + + rdma_ah_set_grh(ah_attr, NULL, +diff --git a/drivers/infiniband/sw/rdmavt/cq.c b/drivers/infiniband/sw/rdmavt/cq.c +index 5724cbbe38b1..04d2e72017fe 100644 +--- a/drivers/infiniband/sw/rdmavt/cq.c ++++ b/drivers/infiniband/sw/rdmavt/cq.c +@@ -248,8 +248,8 @@ int rvt_create_cq(struct ib_cq *ibcq, const struct ib_cq_init_attr *attr, + */ + if (udata && udata->outlen >= sizeof(__u64)) { + cq->ip = rvt_create_mmap_info(rdi, sz, udata, u_wc); +- if (!cq->ip) { +- err = -ENOMEM; ++ if (IS_ERR(cq->ip)) { ++ err = PTR_ERR(cq->ip); + goto bail_wc; + } + +diff --git a/drivers/infiniband/sw/rdmavt/mmap.c b/drivers/infiniband/sw/rdmavt/mmap.c +index 652f4a7efc1b..37853aa3bcf7 100644 +--- a/drivers/infiniband/sw/rdmavt/mmap.c ++++ b/drivers/infiniband/sw/rdmavt/mmap.c +@@ -154,7 +154,7 @@ done: + * @udata: user data (must be valid!) + * @obj: opaque pointer to a cq, wq etc + * +- * Return: rvt_mmap struct on success ++ * Return: rvt_mmap struct on success, ERR_PTR on failure + */ + struct rvt_mmap_info *rvt_create_mmap_info(struct rvt_dev_info *rdi, u32 size, + 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, + + ip = kmalloc_node(sizeof(*ip), GFP_KERNEL, rdi->dparms.node); + if (!ip) +- return ip; ++ return ERR_PTR(-ENOMEM); + + size = PAGE_ALIGN(size); + +diff --git a/drivers/infiniband/sw/rdmavt/qp.c b/drivers/infiniband/sw/rdmavt/qp.c +index 7858d499db03..2c702e1b9a2c 100644 +--- a/drivers/infiniband/sw/rdmavt/qp.c ++++ b/drivers/infiniband/sw/rdmavt/qp.c +@@ -1244,8 +1244,8 @@ struct ib_qp *rvt_create_qp(struct ib_pd *ibpd, + + qp->ip = rvt_create_mmap_info(rdi, s, udata, + qp->r_rq.wq); +- if (!qp->ip) { +- ret = ERR_PTR(-ENOMEM); ++ if (IS_ERR(qp->ip)) { ++ ret = ERR_CAST(qp->ip); + goto bail_qpn; + } + +diff --git a/drivers/infiniband/sw/rdmavt/srq.c b/drivers/infiniband/sw/rdmavt/srq.c +index 24fef021d51d..f547c115af03 100644 +--- a/drivers/infiniband/sw/rdmavt/srq.c ++++ b/drivers/infiniband/sw/rdmavt/srq.c +@@ -111,8 +111,8 @@ int rvt_create_srq(struct ib_srq *ibsrq, struct ib_srq_init_attr *srq_init_attr, + u32 s = sizeof(struct rvt_rwq) + srq->rq.size * sz; + + srq->ip = rvt_create_mmap_info(dev, s, udata, srq->rq.wq); +- if (!srq->ip) { +- ret = -ENOMEM; ++ if (IS_ERR(srq->ip)) { ++ ret = PTR_ERR(srq->ip); + goto bail_wq; + } + +diff --git a/drivers/infiniband/sw/siw/siw_qp_tx.c b/drivers/infiniband/sw/siw/siw_qp_tx.c +index ae92c8080967..9f53aa4feb87 100644 +--- a/drivers/infiniband/sw/siw/siw_qp_tx.c ++++ b/drivers/infiniband/sw/siw/siw_qp_tx.c +@@ -920,20 +920,27 @@ static int siw_fastreg_mr(struct ib_pd *pd, struct siw_sqe *sqe) + { + 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; +- goto out; ++ return -EINVAL; + } ++ ++ 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; +diff --git a/drivers/iommu/amd_iommu_init.c b/drivers/iommu/amd_iommu_init.c +index 6be3853a5d97..2b9a67ecc6ac 100644 +--- a/drivers/iommu/amd_iommu_init.c ++++ b/drivers/iommu/amd_iommu_init.c +@@ -2936,7 +2936,7 @@ static int __init parse_amd_iommu_intr(char *str) + { + for (; *str; ++str) { + if (strncmp(str, "legacy", 6) == 0) { +- amd_iommu_guest_ir = AMD_IOMMU_GUEST_IR_LEGACY; ++ amd_iommu_guest_ir = AMD_IOMMU_GUEST_IR_LEGACY_GA; + break; + } + if (strncmp(str, "vapic", 5) == 0) { +diff --git a/drivers/iommu/intel-iommu.c b/drivers/iommu/intel-iommu.c +index ef0a5246700e..0182cff2c7ac 100644 +--- a/drivers/iommu/intel-iommu.c ++++ b/drivers/iommu/intel-iommu.c +@@ -371,11 +371,11 @@ int dmar_disabled = 0; + int dmar_disabled = 1; + #endif /* CONFIG_INTEL_IOMMU_DEFAULT_ON */ + +-#ifdef INTEL_IOMMU_SCALABLE_MODE_DEFAULT_ON ++#ifdef CONFIG_INTEL_IOMMU_SCALABLE_MODE_DEFAULT_ON + int intel_iommu_sm = 1; + #else + int intel_iommu_sm; +-#endif /* INTEL_IOMMU_SCALABLE_MODE_DEFAULT_ON */ ++#endif /* CONFIG_INTEL_IOMMU_SCALABLE_MODE_DEFAULT_ON */ + + int intel_iommu_enabled = 0; + EXPORT_SYMBOL_GPL(intel_iommu_enabled); +diff --git a/drivers/iommu/iommu.c b/drivers/iommu/iommu.c +index 3e3528436e0b..8d2477941fd9 100644 +--- a/drivers/iommu/iommu.c ++++ b/drivers/iommu/iommu.c +@@ -1428,7 +1428,7 @@ struct iommu_group *iommu_group_get_for_dev(struct device *dev) + + return group; + } +-EXPORT_SYMBOL(iommu_group_get_for_dev); ++EXPORT_SYMBOL_GPL(iommu_group_get_for_dev); + + struct iommu_domain *iommu_group_default_domain(struct iommu_group *group) + { +diff --git a/drivers/iommu/qcom_iommu.c b/drivers/iommu/qcom_iommu.c +index 4328da0b0a9f..b160cf140e16 100644 +--- a/drivers/iommu/qcom_iommu.c ++++ b/drivers/iommu/qcom_iommu.c +@@ -813,8 +813,11 @@ static int qcom_iommu_device_probe(struct platform_device *pdev) + 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)) { +diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c +index 58fd137b6ae1..3e500098132f 100644 +--- a/drivers/md/dm-mpath.c ++++ b/drivers/md/dm-mpath.c +@@ -585,10 +585,12 @@ static struct pgpath *__map_bio(struct multipath *m, struct bio *bio) + + /* 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 || !queue_io) ++ if (!pgpath || !test_bit(MPATHF_QUEUE_IO, &m->flags)) + 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 */ +diff --git a/drivers/md/dm-verity-fec.c b/drivers/md/dm-verity-fec.c +index 49147e634046..fb41b4f23c48 100644 +--- a/drivers/md/dm-verity-fec.c ++++ b/drivers/md/dm-verity-fec.c +@@ -435,7 +435,7 @@ int verity_fec_decode(struct dm_verity *v, struct dm_verity_io *io, + fio->level++; + + if (type == DM_VERITY_BLOCK_TYPE_METADATA) +- block += v->data_blocks; ++ block = block - v->hash_start + v->data_blocks; + + /* + * For RS(M, N), the continuous FEC data is divided into blocks of N +diff --git a/drivers/md/dm-writecache.c b/drivers/md/dm-writecache.c +index d3b17a654917..a3b3c6b2e61b 100644 +--- a/drivers/md/dm-writecache.c ++++ b/drivers/md/dm-writecache.c +@@ -882,6 +882,24 @@ static int writecache_alloc_entries(struct dm_writecache *wc) + 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, ®ion, NULL); ++} ++ + static void writecache_resume(struct dm_target *ti) + { + struct dm_writecache *wc = ti->private; +@@ -892,8 +910,18 @@ static void writecache_resume(struct dm_target *ti) + + 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); +@@ -2005,6 +2033,12 @@ static int writecache_ctr(struct dm_target *ti, unsigned argc, char **argv) + 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; +@@ -2093,8 +2127,6 @@ invalid_optional: + 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; + +@@ -2151,19 +2183,9 @@ invalid_optional: + goto bad; + } + +- region.bdev = wc->ssd_dev->bdev; +- 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, ®ion, NULL); ++ r = writecache_read_metadata(wc, wc->block_size >> SECTOR_SHIFT); + if (r) { +- ti->error = "Unable to read metadata"; ++ ti->error = "Unable to read first block of metadata"; + goto bad; + } + } +diff --git a/drivers/mmc/host/cqhci.c b/drivers/mmc/host/cqhci.c +index 5047f7343ffc..c19f4c3f115a 100644 +--- a/drivers/mmc/host/cqhci.c ++++ b/drivers/mmc/host/cqhci.c +@@ -5,6 +5,7 @@ + #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> +@@ -343,12 +344,16 @@ static int cqhci_enable(struct mmc_host *mmc, struct mmc_card *card) + /* 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; +@@ -358,15 +363,9 @@ static void cqhci_off(struct mmc_host *mmc) + + cqhci_writel(cq_host, CQHCI_HALT, CQHCI_CTL); + +- timeout = ktime_add_us(ktime_get(), CQHCI_OFF_TIMEOUT); +- while (1) { +- timed_out = ktime_compare(ktime_get(), timeout) > 0; +- reg = cqhci_readl(cq_host, CQHCI_CTL); +- if ((reg & CQHCI_HALT) || timed_out) +- break; +- } +- +- if (timed_out) ++ err = readx_poll_timeout(cqhci_read_ctl, cq_host, reg, ++ reg & CQHCI_HALT, 0, CQHCI_OFF_TIMEOUT); ++ if (err < 0) + pr_err("%s: cqhci: CQE stuck on\n", mmc_hostname(mmc)); + else + pr_debug("%s: cqhci: CQE off\n", mmc_hostname(mmc)); +diff --git a/drivers/mmc/host/meson-mx-sdio.c b/drivers/mmc/host/meson-mx-sdio.c +index 8b038e7b2cd3..2e58743d83bb 100644 +--- a/drivers/mmc/host/meson-mx-sdio.c ++++ b/drivers/mmc/host/meson-mx-sdio.c +@@ -357,14 +357,6 @@ static void meson_mx_mmc_request(struct mmc_host *mmc, struct mmc_request *mrq) + 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) + { +@@ -506,7 +498,6 @@ static void meson_mx_mmc_timeout(struct timer_list *t) + 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, + }; +@@ -570,7 +561,7 @@ static int meson_mx_mmc_add_host(struct meson_mx_mmc_host *host) + 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); +diff --git a/drivers/mmc/host/sdhci-msm.c b/drivers/mmc/host/sdhci-msm.c +index 3955fa5db43c..b68dcd1b0d50 100644 +--- a/drivers/mmc/host/sdhci-msm.c ++++ b/drivers/mmc/host/sdhci-msm.c +@@ -2068,6 +2068,8 @@ static int sdhci_msm_probe(struct platform_device *pdev) + goto clk_disable; + } + ++ msm_host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY | MMC_CAP_NEED_RSP_BUSY; ++ + pm_runtime_get_noresume(&pdev->dev); + pm_runtime_set_active(&pdev->dev); + pm_runtime_enable(&pdev->dev); +diff --git a/drivers/mmc/host/sdhci-pci-core.c b/drivers/mmc/host/sdhci-pci-core.c +index 525de2454a4d..2527244c2ae1 100644 +--- a/drivers/mmc/host/sdhci-pci-core.c ++++ b/drivers/mmc/host/sdhci-pci-core.c +@@ -601,6 +601,9 @@ static int intel_select_drive_strength(struct mmc_card *card, + struct sdhci_pci_slot *slot = sdhci_priv(host); + struct intel_host *intel_host = sdhci_pci_priv(slot); + ++ if (!(mmc_driver_type_mask(intel_host->drv_strength) & card_drv)) ++ return 0; ++ + return intel_host->drv_strength; + } + +diff --git a/drivers/mmc/host/sdhci-xenon.c b/drivers/mmc/host/sdhci-xenon.c +index 1dea1ba66f7b..4703cd540c7f 100644 +--- a/drivers/mmc/host/sdhci-xenon.c ++++ b/drivers/mmc/host/sdhci-xenon.c +@@ -235,6 +235,16 @@ static void xenon_voltage_switch(struct sdhci_host *host) + { + /* Wait for 5ms after set 1.8V signal enable bit */ + usleep_range(5000, 5500); ++ ++ /* ++ * For some reason the controller's Host Control2 register reports ++ * the bit representing 1.8V signaling as 0 when read after it was ++ * written as 1. Subsequent read reports 1. ++ * ++ * Since this may cause some issues, do an empty read of the Host ++ * Control2 register here to circumvent this. ++ */ ++ sdhci_readw(host, SDHCI_HOST_CONTROL2); + } + + static const struct sdhci_ops sdhci_xenon_ops = { +diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c +index 652ca87dac94..fb4c35a43065 100644 +--- a/drivers/nvme/host/core.c ++++ b/drivers/nvme/host/core.c +@@ -3580,6 +3580,8 @@ static int nvme_alloc_ns(struct nvme_ctrl *ctrl, unsigned nsid) + + return 0; + out_put_disk: ++ /* prevent double queue cleanup */ ++ ns->disk->queue = NULL; + put_disk(ns->disk); + out_unlink_ns: + mutex_lock(&ctrl->subsys->lock); +diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c +index 7a94e1171c72..98908c2a096a 100644 +--- a/drivers/scsi/qla2xxx/qla_os.c ++++ b/drivers/scsi/qla2xxx/qla_os.c +@@ -3720,6 +3720,13 @@ qla2x00_remove_one(struct pci_dev *pdev) + } + 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) +@@ -3738,15 +3745,6 @@ qla2x00_remove_one(struct pci_dev *pdev) + + 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, +@@ -4856,6 +4854,9 @@ qla2x00_alloc_work(struct scsi_qla_host *vha, enum qla_work_type type) + 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; +@@ -6044,13 +6045,6 @@ qla2x00_disable_board_on_pci_error(struct work_struct *work) + 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"); + +@@ -6061,9 +6055,14 @@ qla2x00_disable_board_on_pci_error(struct work_struct *work) + 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); + +diff --git a/drivers/target/target_core_iblock.c b/drivers/target/target_core_iblock.c +index 51ffd5c002de..1c181d31f4c8 100644 +--- a/drivers/target/target_core_iblock.c ++++ b/drivers/target/target_core_iblock.c +@@ -432,7 +432,7 @@ iblock_execute_zero_out(struct block_device *bdev, struct se_cmd *cmd) + target_to_linux_sector(dev, cmd->t_task_lba), + target_to_linux_sector(dev, + sbc_get_write_same_sectors(cmd)), +- GFP_KERNEL, false); ++ GFP_KERNEL, BLKDEV_ZERO_NOUNMAP); + if (ret) + return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; + +diff --git a/drivers/vfio/vfio_iommu_type1.c b/drivers/vfio/vfio_iommu_type1.c +index a177bf2c6683..4315facf0243 100644 +--- a/drivers/vfio/vfio_iommu_type1.c ++++ b/drivers/vfio/vfio_iommu_type1.c +@@ -341,8 +341,8 @@ static int vaddr_get_pfn(struct mm_struct *mm, unsigned long vaddr, + vma = find_vma_intersection(mm, vaddr, vaddr + 1); + + if (vma && vma->vm_flags & VM_PFNMAP) { +- *pfn = ((vaddr - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff; +- if (is_invalid_reserved_pfn(*pfn)) ++ if (!follow_pfn(vma, vaddr, pfn) && ++ is_invalid_reserved_pfn(*pfn)) + ret = 0; + } + done: +@@ -554,7 +554,7 @@ static int vfio_iommu_type1_pin_pages(void *iommu_data, + continue; + } + +- remote_vaddr = dma->vaddr + iova - dma->iova; ++ remote_vaddr = dma->vaddr + (iova - dma->iova); + ret = vfio_pin_page_external(dma, remote_vaddr, &phys_pfn[i], + do_accounting); + if (ret) +diff --git a/fs/btrfs/block-group.c b/fs/btrfs/block-group.c +index c9a3bbc8c6af..f689fa74c33a 100644 +--- a/fs/btrfs/block-group.c ++++ b/fs/btrfs/block-group.c +@@ -916,7 +916,7 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans, + path = btrfs_alloc_path(); + if (!path) { + ret = -ENOMEM; +- goto out; ++ goto out_put_group; + } + + /* +@@ -954,7 +954,7 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans, + 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 */ +@@ -977,13 +977,13 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans, + + 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); + } + +@@ -1102,9 +1102,9 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans, + + 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); +@@ -1127,6 +1127,10 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans, + /* 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); +diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c +index 696e769d069a..8cb02b5417c5 100644 +--- a/fs/btrfs/relocation.c ++++ b/fs/btrfs/relocation.c +@@ -4614,6 +4614,7 @@ int btrfs_recover_relocation(struct btrfs_root *root) + if (IS_ERR(fs_root)) { + err = PTR_ERR(fs_root); + list_add_tail(&reloc_root->root_list, &reloc_roots); ++ btrfs_end_transaction(trans); + goto out_unset; + } + +diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c +index beb6c69cd1e5..a209e2ef547f 100644 +--- a/fs/btrfs/transaction.c ++++ b/fs/btrfs/transaction.c +@@ -660,10 +660,19 @@ again: + } + + got_it: +- btrfs_record_root_in_trans(h, root); +- + if (!current->journal_info) + current->journal_info = h; ++ ++ /* ++ * btrfs_record_root_in_trans() needs to alloc new extents, and may ++ * call btrfs_join_transaction() while we're also starting a ++ * transaction. ++ * ++ * Thus it need to be called after current->journal_info initialized, ++ * or we can deadlock. ++ */ ++ btrfs_record_root_in_trans(h, root); ++ + return h; + + join_fail: +diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c +index 7dd7552f53a4..61b9770ca78f 100644 +--- a/fs/btrfs/tree-log.c ++++ b/fs/btrfs/tree-log.c +@@ -4211,6 +4211,9 @@ static int btrfs_log_prealloc_extents(struct btrfs_trans_handle *trans, + const u64 ino = btrfs_ino(inode); + struct btrfs_path *dst_path = NULL; + bool dropped_extents = false; ++ u64 truncate_offset = i_size; ++ struct extent_buffer *leaf; ++ int slot; + int ins_nr = 0; + int start_slot; + int ret; +@@ -4225,9 +4228,43 @@ static int btrfs_log_prealloc_extents(struct btrfs_trans_handle *trans, + if (ret < 0) + goto out; + ++ /* ++ * We must check if there is a prealloc extent that starts before the ++ * i_size and crosses the i_size boundary. This is to ensure later we ++ * truncate down to the end of that extent and not to the i_size, as ++ * otherwise we end up losing part of the prealloc extent after a log ++ * replay and with an implicit hole if there is another prealloc extent ++ * that starts at an offset beyond i_size. ++ */ ++ ret = btrfs_previous_item(root, path, ino, BTRFS_EXTENT_DATA_KEY); ++ if (ret < 0) ++ goto out; ++ ++ if (ret == 0) { ++ struct btrfs_file_extent_item *ei; ++ ++ leaf = path->nodes[0]; ++ slot = path->slots[0]; ++ ei = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item); ++ ++ if (btrfs_file_extent_type(leaf, ei) == ++ BTRFS_FILE_EXTENT_PREALLOC) { ++ u64 extent_end; ++ ++ btrfs_item_key_to_cpu(leaf, &key, slot); ++ extent_end = key.offset + ++ btrfs_file_extent_num_bytes(leaf, ei); ++ ++ if (extent_end > i_size) ++ truncate_offset = extent_end; ++ } ++ } else { ++ ret = 0; ++ } ++ + while (true) { +- struct extent_buffer *leaf = path->nodes[0]; +- int slot = path->slots[0]; ++ leaf = path->nodes[0]; ++ slot = path->slots[0]; + + if (slot >= btrfs_header_nritems(leaf)) { + if (ins_nr > 0) { +@@ -4265,7 +4302,7 @@ static int btrfs_log_prealloc_extents(struct btrfs_trans_handle *trans, + ret = btrfs_truncate_inode_items(trans, + root->log_root, + &inode->vfs_inode, +- i_size, ++ truncate_offset, + BTRFS_EXTENT_DATA_KEY); + } while (ret == -EAGAIN); + if (ret) +diff --git a/fs/io_uring.c b/fs/io_uring.c +index a46de2cfc28e..38b25f599896 100644 +--- a/fs/io_uring.c ++++ b/fs/io_uring.c +@@ -479,6 +479,7 @@ enum { + REQ_F_COMP_LOCKED_BIT, + REQ_F_NEED_CLEANUP_BIT, + REQ_F_OVERFLOW_BIT, ++ REQ_F_NO_FILE_TABLE_BIT, + }; + + enum { +@@ -521,6 +522,8 @@ enum { + REQ_F_NEED_CLEANUP = BIT(REQ_F_NEED_CLEANUP_BIT), + /* in overflow list */ + REQ_F_OVERFLOW = BIT(REQ_F_OVERFLOW_BIT), ++ /* doesn't need file table for this request */ ++ REQ_F_NO_FILE_TABLE = BIT(REQ_F_NO_FILE_TABLE_BIT), + }; + + /* +@@ -711,6 +714,7 @@ static const struct io_op_def io_op_defs[] = { + .needs_file = 1, + .fd_non_neg = 1, + .needs_fs = 1, ++ .file_table = 1, + }, + [IORING_OP_READ] = { + .needs_mm = 1, +@@ -2843,8 +2847,12 @@ static int io_statx(struct io_kiocb *req, struct io_kiocb **nxt, + 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; +@@ -4632,7 +4640,7 @@ static int io_grab_files(struct io_kiocb *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; +diff --git a/fs/nfs/nfs3acl.c b/fs/nfs/nfs3acl.c +index c5c3fc6e6c60..26c94b32d6f4 100644 +--- a/fs/nfs/nfs3acl.c ++++ b/fs/nfs/nfs3acl.c +@@ -253,37 +253,45 @@ int nfs3_proc_setacls(struct inode *inode, struct posix_acl *acl, + + 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 = acl = get_acl(inode, ACL_TYPE_ACCESS); ++ alloc = 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[] = { +diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c +index 69b7ab7a5815..1b1e21bcb994 100644 +--- a/fs/nfs/nfs4proc.c ++++ b/fs/nfs/nfs4proc.c +@@ -7893,6 +7893,7 @@ static void + nfs4_bind_one_conn_to_session_done(struct rpc_task *task, void *calldata) + { + struct nfs41_bind_conn_to_session_args *args = task->tk_msg.rpc_argp; ++ struct nfs41_bind_conn_to_session_res *res = task->tk_msg.rpc_resp; + struct nfs_client *clp = args->client; + + switch (task->tk_status) { +@@ -7901,6 +7902,12 @@ nfs4_bind_one_conn_to_session_done(struct rpc_task *task, void *calldata) + nfs4_schedule_session_recovery(clp->cl_session, + task->tk_status); + } ++ if (args->dir == NFS4_CDFC4_FORE_OR_BOTH && ++ res->dir != NFS4_CDFS4_BOTH) { ++ rpc_task_close_connection(task); ++ if (args->retries++ < MAX_BIND_CONN_TO_SESSION_RETRIES) ++ rpc_restart_call(task); ++ } + } + + static const struct rpc_call_ops nfs4_bind_one_conn_to_session_ops = { +@@ -7923,6 +7930,7 @@ int nfs4_proc_bind_one_conn_to_session(struct rpc_clnt *clnt, + struct nfs41_bind_conn_to_session_args args = { + .client = clp, + .dir = NFS4_CDFC4_FORE_OR_BOTH, ++ .retries = 0, + }; + struct nfs41_bind_conn_to_session_res res; + struct rpc_message msg = { +diff --git a/fs/ocfs2/dlmfs/dlmfs.c b/fs/ocfs2/dlmfs/dlmfs.c +index 8e4f1ace467c..1de77f1a600b 100644 +--- a/fs/ocfs2/dlmfs/dlmfs.c ++++ b/fs/ocfs2/dlmfs/dlmfs.c +@@ -275,7 +275,6 @@ static ssize_t dlmfs_file_write(struct file *filp, + loff_t *ppos) + { + int bytes_left; +- ssize_t writelen; + char *lvb_buf; + struct inode *inode = file_inode(filp); + +@@ -285,32 +284,30 @@ static ssize_t dlmfs_file_write(struct file *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 */ +- if ((count + *ppos) > i_size_read(inode)) +- writelen = i_size_read(inode) - *ppos; +- else +- writelen = count - *ppos; +- +- lvb_buf = kmalloc(writelen, GFP_NOFS); ++ lvb_buf = kmalloc(count, GFP_NOFS); + if (!lvb_buf) + return -ENOMEM; + +- bytes_left = copy_from_user(lvb_buf, buf, writelen); +- writelen -= bytes_left; +- if (writelen) +- user_dlm_write_lvb(inode, lvb_buf, writelen); ++ bytes_left = copy_from_user(lvb_buf, buf, count); ++ count -= bytes_left; ++ if (count) ++ user_dlm_write_lvb(inode, lvb_buf, count); + + kfree(lvb_buf); + +- *ppos = *ppos + writelen; +- mlog(0, "wrote %zd bytes\n", writelen); +- return writelen; ++ *ppos = *ppos + count; ++ mlog(0, "wrote %zu bytes\n", count); ++ return count; + } + + static void dlmfs_init_once(void *foo) +diff --git a/fs/super.c b/fs/super.c +index cd352530eca9..a288cd60d2ae 100644 +--- a/fs/super.c ++++ b/fs/super.c +@@ -1302,8 +1302,8 @@ int get_tree_bdev(struct fs_context *fc, + 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; + } + +diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h +index 64461fc64e1b..7adc007f2023 100644 +--- a/include/linux/dmaengine.h ++++ b/include/linux/dmaengine.h +@@ -336,13 +336,11 @@ struct dma_chan { + * @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; + }; + + /** +@@ -827,6 +825,8 @@ struct dma_device { + 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; +diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h +index 94c77ed55ce1..faa150b4e85d 100644 +--- a/include/linux/nfs_xdr.h ++++ b/include/linux/nfs_xdr.h +@@ -1307,11 +1307,13 @@ struct nfs41_impl_id { + 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 { +diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h +index ca7e108248e2..cc20a0816830 100644 +--- a/include/linux/sunrpc/clnt.h ++++ b/include/linux/sunrpc/clnt.h +@@ -236,4 +236,9 @@ static inline int rpc_reply_expected(struct rpc_task *task) + (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 */ +diff --git a/include/uapi/linux/dma-buf.h b/include/uapi/linux/dma-buf.h +index dbc7092e04b5..7f30393b92c3 100644 +--- a/include/uapi/linux/dma-buf.h ++++ b/include/uapi/linux/dma-buf.h +@@ -39,6 +39,12 @@ struct dma_buf_sync { + + #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 +diff --git a/kernel/power/hibernate.c b/kernel/power/hibernate.c +index 6dbeedb7354c..daf3ea9d81de 100644 +--- a/kernel/power/hibernate.c ++++ b/kernel/power/hibernate.c +@@ -898,6 +898,13 @@ static int software_resume(void) + error = freeze_processes(); + if (error) + goto Close_Finish; ++ ++ error = freeze_kernel_threads(); ++ if (error) { ++ thaw_processes(); ++ goto Close_Finish; ++ } ++ + error = load_image_and_restore(); + thaw_processes(); + Finish: +diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c +index 1659b59fb5d7..053269461bcc 100644 +--- a/security/selinux/hooks.c ++++ b/security/selinux/hooks.c +@@ -5829,40 +5829,60 @@ static unsigned int selinux_ipv6_postroute(void *priv, + + static int selinux_netlink_send(struct sock *sk, struct sk_buff *skb) + { +- int err = 0; +- u32 perm; ++ int rc = 0; ++ unsigned int msg_len; ++ unsigned int data_len = skb->len; ++ unsigned char *data = skb->data; + struct nlmsghdr *nlh; + struct sk_security_struct *sksec = sk->sk_security; ++ u16 sclass = sksec->sclass; ++ u32 perm; + +- if (skb->len < NLMSG_HDRLEN) { +- err = -EINVAL; +- goto out; +- } +- nlh = nlmsg_hdr(skb); ++ while (data_len >= nlmsg_total_size(0)) { ++ nlh = (struct nlmsghdr *)data; ++ ++ /* NOTE: the nlmsg_len field isn't reliably set by some netlink ++ * users which means we can't reject skb's with bogus ++ * length fields; our solution is to follow what ++ * netlink_rcv_skb() does and simply skip processing at ++ * messages with length fields that are clearly junk ++ */ ++ if (nlh->nlmsg_len < NLMSG_HDRLEN || nlh->nlmsg_len > data_len) ++ return 0; + +- err = selinux_nlmsg_lookup(sksec->sclass, nlh->nlmsg_type, &perm); +- if (err) { +- if (err == -EINVAL) { ++ rc = selinux_nlmsg_lookup(sclass, nlh->nlmsg_type, &perm); ++ if (rc == 0) { ++ rc = sock_has_perm(sk, perm); ++ if (rc) ++ return rc; ++ } else if (rc == -EINVAL) { ++ /* -EINVAL is a missing msg/perm mapping */ + pr_warn_ratelimited("SELinux: unrecognized netlink" +- " message: protocol=%hu nlmsg_type=%hu sclass=%s" +- " pid=%d comm=%s\n", +- sk->sk_protocol, nlh->nlmsg_type, +- secclass_map[sksec->sclass - 1].name, +- task_pid_nr(current), current->comm); +- if (!enforcing_enabled(&selinux_state) || +- security_get_allow_unknown(&selinux_state)) +- err = 0; ++ " message: protocol=%hu nlmsg_type=%hu sclass=%s" ++ " pid=%d comm=%s\n", ++ sk->sk_protocol, nlh->nlmsg_type, ++ secclass_map[sclass - 1].name, ++ task_pid_nr(current), current->comm); ++ if (enforcing_enabled(&selinux_state) && ++ !security_get_allow_unknown(&selinux_state)) ++ return rc; ++ rc = 0; ++ } else if (rc == -ENOENT) { ++ /* -ENOENT is a missing socket/class mapping, ignore */ ++ rc = 0; ++ } else { ++ return rc; + } + +- /* Ignore */ +- if (err == -ENOENT) +- err = 0; +- goto out; ++ /* move to the next message after applying netlink padding */ ++ msg_len = NLMSG_ALIGN(nlh->nlmsg_len); ++ if (msg_len >= data_len) ++ return 0; ++ data_len -= msg_len; ++ data += msg_len; + } + +- err = sock_has_perm(sk, perm); +-out: +- return err; ++ return rc; + } + + static void ipc_init_security(struct ipc_security_struct *isec, u16 sclass) +diff --git a/sound/core/oss/pcm_plugin.c b/sound/core/oss/pcm_plugin.c +index 50c35ecc8953..d1760f86773c 100644 +--- a/sound/core/oss/pcm_plugin.c ++++ b/sound/core/oss/pcm_plugin.c +@@ -211,21 +211,23 @@ static snd_pcm_sframes_t plug_client_size(struct snd_pcm_substream *plug, + if (stream == SNDRV_PCM_STREAM_PLAYBACK) { + plugin = snd_pcm_plug_last(plug); + while (plugin && drv_frames > 0) { +- if (check_size && drv_frames > plugin->buf_frames) +- drv_frames = plugin->buf_frames; + plugin_prev = plugin->prev; + if (plugin->src_frames) + drv_frames = plugin->src_frames(plugin, drv_frames); ++ if (check_size && plugin->buf_frames && ++ drv_frames > plugin->buf_frames) ++ drv_frames = plugin->buf_frames; + plugin = plugin_prev; + } + } else if (stream == SNDRV_PCM_STREAM_CAPTURE) { + plugin = snd_pcm_plug_first(plug); + while (plugin && drv_frames > 0) { + plugin_next = plugin->next; ++ if (check_size && plugin->buf_frames && ++ drv_frames > plugin->buf_frames) ++ drv_frames = plugin->buf_frames; + if (plugin->dst_frames) + drv_frames = plugin->dst_frames(plugin, drv_frames); +- if (check_size && drv_frames > plugin->buf_frames) +- drv_frames = plugin->buf_frames; + plugin = plugin_next; + } + } else +@@ -251,26 +253,28 @@ static snd_pcm_sframes_t plug_slave_size(struct snd_pcm_substream *plug, + 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; + } + } else if (stream == SNDRV_PCM_STREAM_CAPTURE) { + plugin = snd_pcm_plug_last(plug); + while (plugin) { +- 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; + } + } else +diff --git a/sound/isa/opti9xx/miro.c b/sound/isa/opti9xx/miro.c +index e764816a8f7a..b039429e6871 100644 +--- a/sound/isa/opti9xx/miro.c ++++ b/sound/isa/opti9xx/miro.c +@@ -867,10 +867,13 @@ static void snd_miro_write(struct snd_miro *chip, unsigned char reg, + 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, \ +- (snd_miro_read(chip, reg) & ~(mask)) | ((value) & (mask))) ++ snd_miro_write(chip, reg, (oldval & ~mask) | (value & mask)); ++} + + /* + * Proc Interface +diff --git a/sound/isa/opti9xx/opti92x-ad1848.c b/sound/isa/opti9xx/opti92x-ad1848.c +index d06b29693c85..0e6d20e49158 100644 +--- a/sound/isa/opti9xx/opti92x-ad1848.c ++++ b/sound/isa/opti9xx/opti92x-ad1848.c +@@ -317,10 +317,13 @@ static void snd_opti9xx_write(struct snd_opti9xx *chip, unsigned char reg, + } + + +-#define snd_opti9xx_write_mask(chip, reg, value, mask) \ +- snd_opti9xx_write(chip, reg, \ +- (snd_opti9xx_read(chip, reg) & ~(mask)) | ((value) & (mask))) ++static inline void snd_opti9xx_write_mask(struct snd_opti9xx *chip, ++ unsigned char reg, unsigned char value, unsigned char 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, +diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c +index 8bc4d66ff986..0c1a59d5ad59 100644 +--- a/sound/pci/hda/patch_hdmi.c ++++ b/sound/pci/hda/patch_hdmi.c +@@ -1934,8 +1934,10 @@ static bool check_non_pcm_per_cvt(struct hda_codec *codec, hda_nid_t cvt_nid) + /* 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; +diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c +index f2fccf267b48..da4863d7f7f2 100644 +--- a/sound/pci/hda/patch_realtek.c ++++ b/sound/pci/hda/patch_realtek.c +@@ -7295,6 +7295,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { + SND_PCI_QUIRK(0x1558, 0x8560, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC), + SND_PCI_QUIRK(0x1558, 0x8561, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC), + SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS), ++ SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC), + SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE), + SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE), + SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE), +diff --git a/sound/usb/line6/podhd.c b/sound/usb/line6/podhd.c +index d37db32ecd3b..e39dc85c355a 100644 +--- a/sound/usb/line6/podhd.c ++++ b/sound/usb/line6/podhd.c +@@ -21,8 +21,7 @@ + enum { + LINE6_PODHD300, + LINE6_PODHD400, +- LINE6_PODHD500_0, +- LINE6_PODHD500_1, ++ LINE6_PODHD500, + LINE6_PODX3, + LINE6_PODX3LIVE, + LINE6_PODHD500X, +@@ -318,8 +317,7 @@ static const struct usb_device_id podhd_id_table[] = { + /* 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, 1), .driver_info = LINE6_PODHD500_1 }, ++ { LINE6_IF_NUM(0x414D, 0), .driver_info = LINE6_PODHD500 }, + { 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 }, +@@ -352,23 +350,13 @@ static const struct line6_properties podhd_properties_table[] = { + .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, +- .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, ++ .ctrl_if = 1, + .ep_ctrl_r = 0x81, + .ep_ctrl_w = 0x01, + .ep_audio_r = 0x86, +diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c +index 7f558f4b4520..0686e056e39b 100644 +--- a/sound/usb/quirks.c ++++ b/sound/usb/quirks.c +@@ -1643,7 +1643,7 @@ u64 snd_usb_interface_dsd_format_quirks(struct snd_usb_audio *chip, + + case USB_ID(0x0d8c, 0x0316): /* Hegel HD12 DSD */ + case USB_ID(0x10cb, 0x0103): /* The Bit Opus #3; with fp->dsd_raw */ +- case USB_ID(0x16b0, 0x06b2): /* NuPrime DAC-10 */ ++ case USB_ID(0x16d0, 0x06b2): /* NuPrime DAC-10 */ + case USB_ID(0x16d0, 0x09dd): /* Encore mDSD */ + case USB_ID(0x16d0, 0x0733): /* Furutech ADL Stratos */ + case USB_ID(0x16d0, 0x09db): /* NuPrime Audio DAC-9 */
