Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/kernel-alx/patches-5.4/0138-5.4.39-all-fixes.patch

    Contents of /trunk/kernel-alx/patches-5.4/0138-5.4.39-all-fixes.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 3519 - (show annotations) (download)
    Mon May 11 14:36:44 2020 UTC (4 years ago) by niro
    File size: 61780 byte(s) 
    -linux-5.4.39
    1 diff --git a/Makefile b/Makefile
    2 index 989e7d649633..ff2b90ddc9bc 100644
    3 --- a/Makefile
    4 +++ b/Makefile
    5 @@ -1,7 +1,7 @@
    6 # SPDX-License-Identifier: GPL-2.0
    7 VERSION = 5
    8 PATCHLEVEL = 4
    9 -SUBLEVEL = 38
    10 +SUBLEVEL = 39
    11 EXTRAVERSION =
    12 NAME = Kleptomaniac Octopus
    13
    14 diff --git a/arch/arm/boot/dts/imx6qdl-sr-som-ti.dtsi b/arch/arm/boot/dts/imx6qdl-sr-som-ti.dtsi
    15 index 44a97ba93a95..352ac585ca6b 100644
    16 --- a/arch/arm/boot/dts/imx6qdl-sr-som-ti.dtsi
    17 +++ b/arch/arm/boot/dts/imx6qdl-sr-som-ti.dtsi
    18 @@ -153,6 +153,7 @@
    19 bus-width = <4>;
    20 keep-power-in-suspend;
    21 mmc-pwrseq = <&pwrseq_ti_wifi>;
    22 + cap-power-off-card;
    23 non-removable;
    24 vmmc-supply = <&vcc_3v3>;
    25 /* vqmmc-supply = <&nvcc_sd1>; - MMC layer doesn't like it! */
    26 diff --git a/arch/arm64/kernel/vdso/Makefile b/arch/arm64/kernel/vdso/Makefile
    27 index dd2514bb1511..3862cad2410c 100644
    28 --- a/arch/arm64/kernel/vdso/Makefile
    29 +++ b/arch/arm64/kernel/vdso/Makefile
    30 @@ -32,7 +32,7 @@ UBSAN_SANITIZE := n
    31 OBJECT_FILES_NON_STANDARD := y
    32 KCOV_INSTRUMENT := n
    33
    34 -CFLAGS_vgettimeofday.o = -O2 -mcmodel=tiny
    35 +CFLAGS_vgettimeofday.o = -O2 -mcmodel=tiny -fasynchronous-unwind-tables
    36
    37 ifneq ($(c-gettimeofday-y),)
    38 CFLAGS_vgettimeofday.o += -include $(c-gettimeofday-y)
    39 diff --git a/drivers/acpi/device_pm.c b/drivers/acpi/device_pm.c
    40 index 5e4a8860a9c0..ea9ecf3d70c2 100644
    41 --- a/drivers/acpi/device_pm.c
    42 +++ b/drivers/acpi/device_pm.c
    43 @@ -273,13 +273,13 @@ int acpi_device_set_power(struct acpi_device *device, int state)
    44 end:
    45 if (result) {
    46 dev_warn(&device->dev, "Failed to change power state to %s\n",
    47 - acpi_power_state_string(state));
    48 + acpi_power_state_string(target_state));
    49 } else {
    50 device->power.state = target_state;
    51 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
    52 "Device [%s] transitioned to %s\n",
    53 device->pnp.bus_id,
    54 - acpi_power_state_string(state)));
    55 + acpi_power_state_string(target_state)));
    56 }
    57
    58 return result;
    59 diff --git a/drivers/crypto/caam/caamalg.c b/drivers/crypto/caam/caamalg.c
    60 index 2912006b946b..4ce9c2b4544a 100644
    61 --- a/drivers/crypto/caam/caamalg.c
    62 +++ b/drivers/crypto/caam/caamalg.c
    63 @@ -1810,7 +1810,7 @@ static struct skcipher_edesc *skcipher_edesc_alloc(struct skcipher_request *req,
    64
    65 if (ivsize || mapped_dst_nents > 1)
    66 sg_to_sec4_set_last(edesc->sec4_sg + dst_sg_idx +
    67 - mapped_dst_nents);
    68 + mapped_dst_nents - 1 + !!ivsize);
    69
    70 if (sec4_sg_bytes) {
    71 edesc->sec4_sg_dma = dma_map_single(jrdev, edesc->sec4_sg,
    72 diff --git a/drivers/dma-buf/dma-buf.c b/drivers/dma-buf/dma-buf.c
    73 index 0fb0358f0073..adc88e1dc999 100644
    74 --- a/drivers/dma-buf/dma-buf.c
    75 +++ b/drivers/dma-buf/dma-buf.c
    76 @@ -388,7 +388,8 @@ static long dma_buf_ioctl(struct file *file,
    77
    78 return ret;
    79
    80 - case DMA_BUF_SET_NAME:
    81 + case DMA_BUF_SET_NAME_A:
    82 + case DMA_BUF_SET_NAME_B:
    83 return dma_buf_set_name(dmabuf, (const char __user *)arg);
    84
    85 default:
    86 diff --git a/drivers/dma/dmatest.c b/drivers/dma/dmatest.c
    87 index a2cadfa2e6d7..364dd34799d4 100644
    88 --- a/drivers/dma/dmatest.c
    89 +++ b/drivers/dma/dmatest.c
    90 @@ -240,7 +240,7 @@ static bool is_threaded_test_run(struct dmatest_info *info)
    91 struct dmatest_thread *thread;
    92
    93 list_for_each_entry(thread, &dtc->threads, node) {
    94 - if (!thread->done)
    95 + if (!thread->done && !thread->pending)
    96 return true;
    97 }
    98 }
    99 @@ -662,8 +662,8 @@ static int dmatest_func(void *data)
    100 flags = DMA_CTRL_ACK | DMA_PREP_INTERRUPT;
    101
    102 ktime = ktime_get();
    103 - while (!kthread_should_stop()
    104 - && !(params->iterations && total_tests >= params->iterations)) {
    105 + while (!(kthread_should_stop() ||
    106 + (params->iterations && total_tests >= params->iterations))) {
    107 struct dma_async_tx_descriptor *tx = NULL;
    108 struct dmaengine_unmap_data *um;
    109 dma_addr_t *dsts;
    110 diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
    111 index 360c87ba4595..be61ae1430ed 100644
    112 --- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
    113 +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
    114 @@ -2698,7 +2698,8 @@ fill_plane_dcc_attributes(struct amdgpu_device *adev,
    115 const union dc_tiling_info *tiling_info,
    116 const uint64_t info,
    117 struct dc_plane_dcc_param *dcc,
    118 - struct dc_plane_address *address)
    119 + struct dc_plane_address *address,
    120 + bool force_disable_dcc)
    121 {
    122 struct dc *dc = adev->dm.dc;
    123 struct dc_dcc_surface_param input;
    124 @@ -2710,6 +2711,9 @@ fill_plane_dcc_attributes(struct amdgpu_device *adev,
    125 memset(&input, 0, sizeof(input));
    126 memset(&output, 0, sizeof(output));
    127
    128 + if (force_disable_dcc)
    129 + return 0;
    130 +
    131 if (!offset)
    132 return 0;
    133
    134 @@ -2759,7 +2763,8 @@ fill_plane_buffer_attributes(struct amdgpu_device *adev,
    135 union dc_tiling_info *tiling_info,
    136 struct plane_size *plane_size,
    137 struct dc_plane_dcc_param *dcc,
    138 - struct dc_plane_address *address)
    139 + struct dc_plane_address *address,
    140 + bool force_disable_dcc)
    141 {
    142 const struct drm_framebuffer *fb = &afb->base;
    143 int ret;
    144 @@ -2869,7 +2874,8 @@ fill_plane_buffer_attributes(struct amdgpu_device *adev,
    145
    146 ret = fill_plane_dcc_attributes(adev, afb, format, rotation,
    147 plane_size, tiling_info,
    148 - tiling_flags, dcc, address);
    149 + tiling_flags, dcc, address,
    150 + force_disable_dcc);
    151 if (ret)
    152 return ret;
    153 }
    154 @@ -2961,7 +2967,8 @@ fill_dc_plane_info_and_addr(struct amdgpu_device *adev,
    155 const struct drm_plane_state *plane_state,
    156 const uint64_t tiling_flags,
    157 struct dc_plane_info *plane_info,
    158 - struct dc_plane_address *address)
    159 + struct dc_plane_address *address,
    160 + bool force_disable_dcc)
    161 {
    162 const struct drm_framebuffer *fb = plane_state->fb;
    163 const struct amdgpu_framebuffer *afb =
    164 @@ -3040,7 +3047,8 @@ fill_dc_plane_info_and_addr(struct amdgpu_device *adev,
    165 plane_info->rotation, tiling_flags,
    166 &plane_info->tiling_info,
    167 &plane_info->plane_size,
    168 - &plane_info->dcc, address);
    169 + &plane_info->dcc, address,
    170 + force_disable_dcc);
    171 if (ret)
    172 return ret;
    173
    174 @@ -3063,6 +3071,7 @@ static int fill_dc_plane_attributes(struct amdgpu_device *adev,
    175 struct dc_plane_info plane_info;
    176 uint64_t tiling_flags;
    177 int ret;
    178 + bool force_disable_dcc = false;
    179
    180 ret = fill_dc_scaling_info(plane_state, &scaling_info);
    181 if (ret)
    182 @@ -3077,9 +3086,11 @@ static int fill_dc_plane_attributes(struct amdgpu_device *adev,
    183 if (ret)
    184 return ret;
    185
    186 + force_disable_dcc = adev->asic_type == CHIP_RAVEN && adev->in_suspend;
    187 ret = fill_dc_plane_info_and_addr(adev, plane_state, tiling_flags,
    188 &plane_info,
    189 - &dc_plane_state->address);
    190 + &dc_plane_state->address,
    191 + force_disable_dcc);
    192 if (ret)
    193 return ret;
    194
    195 @@ -4481,6 +4492,7 @@ static int dm_plane_helper_prepare_fb(struct drm_plane *plane,
    196 uint64_t tiling_flags;
    197 uint32_t domain;
    198 int r;
    199 + bool force_disable_dcc = false;
    200
    201 dm_plane_state_old = to_dm_plane_state(plane->state);
    202 dm_plane_state_new = to_dm_plane_state(new_state);
    203 @@ -4539,11 +4551,13 @@ static int dm_plane_helper_prepare_fb(struct drm_plane *plane,
    204 dm_plane_state_old->dc_state != dm_plane_state_new->dc_state) {
    205 struct dc_plane_state *plane_state = dm_plane_state_new->dc_state;
    206
    207 + force_disable_dcc = adev->asic_type == CHIP_RAVEN && adev->in_suspend;
    208 fill_plane_buffer_attributes(
    209 adev, afb, plane_state->format, plane_state->rotation,
    210 tiling_flags, &plane_state->tiling_info,
    211 &plane_state->plane_size, &plane_state->dcc,
    212 - &plane_state->address);
    213 + &plane_state->address,
    214 + force_disable_dcc);
    215 }
    216
    217 return 0;
    218 @@ -5767,7 +5781,12 @@ static void amdgpu_dm_commit_planes(struct drm_atomic_state *state,
    219 fill_dc_plane_info_and_addr(
    220 dm->adev, new_plane_state, tiling_flags,
    221 &bundle->plane_infos[planes_count],
    222 - &bundle->flip_addrs[planes_count].address);
    223 + &bundle->flip_addrs[planes_count].address,
    224 + false);
    225 +
    226 + DRM_DEBUG_DRIVER("plane: id=%d dcc_en=%d\n",
    227 + new_plane_state->plane->index,
    228 + bundle->plane_infos[planes_count].dcc.enable);
    229
    230 bundle->surface_updates[planes_count].plane_info =
    231 &bundle->plane_infos[planes_count];
    232 @@ -7138,7 +7157,8 @@ dm_determine_update_type_for_commit(struct amdgpu_display_manager *dm,
    233 ret = fill_dc_plane_info_and_addr(
    234 dm->adev, new_plane_state, tiling_flags,
    235 &plane_info,
    236 - &flip_addr.address);
    237 + &flip_addr.address,
    238 + false);
    239 if (ret)
    240 goto cleanup;
    241
    242 diff --git a/drivers/gpu/drm/drm_edid.c b/drivers/gpu/drm/drm_edid.c
    243 index 3f50b8865db4..ea2849338d6c 100644
    244 --- a/drivers/gpu/drm/drm_edid.c
    245 +++ b/drivers/gpu/drm/drm_edid.c
    246 @@ -4743,7 +4743,7 @@ static struct drm_display_mode *drm_mode_displayid_detailed(struct drm_device *d
    247 struct drm_display_mode *mode;
    248 unsigned pixel_clock = (timings->pixel_clock[0] |
    249 (timings->pixel_clock[1] << 8) |
    250 - (timings->pixel_clock[2] << 16));
    251 + (timings->pixel_clock[2] << 16)) + 1;
    252 unsigned hactive = (timings->hactive[0] | timings->hactive[1] << 8) + 1;
    253 unsigned hblank = (timings->hblank[0] | timings->hblank[1] << 8) + 1;
    254 unsigned hsync = (timings->hsync[0] | (timings->hsync[1] & 0x7f) << 8) + 1;
    255 diff --git a/drivers/gpu/drm/qxl/qxl_cmd.c b/drivers/gpu/drm/qxl/qxl_cmd.c
    256 index ef09dc6bc635..d082c194cccc 100644
    257 --- a/drivers/gpu/drm/qxl/qxl_cmd.c
    258 +++ b/drivers/gpu/drm/qxl/qxl_cmd.c
    259 @@ -480,9 +480,10 @@ int qxl_hw_surface_alloc(struct qxl_device *qdev,
    260 return ret;
    261
    262 ret = qxl_release_reserve_list(release, true);
    263 - if (ret)
    264 + if (ret) {
    265 + qxl_release_free(qdev, release);
    266 return ret;
    267 -
    268 + }
    269 cmd = (struct qxl_surface_cmd *)qxl_release_map(qdev, release);
    270 cmd->type = QXL_SURFACE_CMD_CREATE;
    271 cmd->flags = QXL_SURF_FLAG_KEEP_DATA;
    272 @@ -499,8 +500,8 @@ int qxl_hw_surface_alloc(struct qxl_device *qdev,
    273 /* no need to add a release to the fence for this surface bo,
    274 since it is only released when we ask to destroy the surface
    275 and it would never signal otherwise */
    276 - qxl_push_command_ring_release(qdev, release, QXL_CMD_SURFACE, false);
    277 qxl_release_fence_buffer_objects(release);
    278 + qxl_push_command_ring_release(qdev, release, QXL_CMD_SURFACE, false);
    279
    280 surf->hw_surf_alloc = true;
    281 spin_lock(&qdev->surf_id_idr_lock);
    282 @@ -542,9 +543,8 @@ int qxl_hw_surface_dealloc(struct qxl_device *qdev,
    283 cmd->surface_id = id;
    284 qxl_release_unmap(qdev, release, &cmd->release_info);
    285
    286 - qxl_push_command_ring_release(qdev, release, QXL_CMD_SURFACE, false);
    287 -
    288 qxl_release_fence_buffer_objects(release);
    289 + qxl_push_command_ring_release(qdev, release, QXL_CMD_SURFACE, false);
    290
    291 return 0;
    292 }
    293 diff --git a/drivers/gpu/drm/qxl/qxl_display.c b/drivers/gpu/drm/qxl/qxl_display.c
    294 index 16d73b22f3f5..92d84280096e 100644
    295 --- a/drivers/gpu/drm/qxl/qxl_display.c
    296 +++ b/drivers/gpu/drm/qxl/qxl_display.c
    297 @@ -523,8 +523,8 @@ static int qxl_primary_apply_cursor(struct drm_plane *plane)
    298 cmd->u.set.visible = 1;
    299 qxl_release_unmap(qdev, release, &cmd->release_info);
    300
    301 - qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
    302 qxl_release_fence_buffer_objects(release);
    303 + qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
    304
    305 return ret;
    306
    307 @@ -665,8 +665,8 @@ static void qxl_cursor_atomic_update(struct drm_plane *plane,
    308 cmd->u.position.y = plane->state->crtc_y + fb->hot_y;
    309
    310 qxl_release_unmap(qdev, release, &cmd->release_info);
    311 - qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
    312 qxl_release_fence_buffer_objects(release);
    313 + qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
    314
    315 if (old_cursor_bo != NULL)
    316 qxl_bo_unpin(old_cursor_bo);
    317 @@ -713,8 +713,8 @@ static void qxl_cursor_atomic_disable(struct drm_plane *plane,
    318 cmd->type = QXL_CURSOR_HIDE;
    319 qxl_release_unmap(qdev, release, &cmd->release_info);
    320
    321 - qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
    322 qxl_release_fence_buffer_objects(release);
    323 + qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
    324 }
    325
    326 static void qxl_update_dumb_head(struct qxl_device *qdev,
    327 diff --git a/drivers/gpu/drm/qxl/qxl_draw.c b/drivers/gpu/drm/qxl/qxl_draw.c
    328 index 5bebf1ea1c5d..3599db096973 100644
    329 --- a/drivers/gpu/drm/qxl/qxl_draw.c
    330 +++ b/drivers/gpu/drm/qxl/qxl_draw.c
    331 @@ -209,9 +209,10 @@ void qxl_draw_dirty_fb(struct qxl_device *qdev,
    332 goto out_release_backoff;
    333
    334 rects = drawable_set_clipping(qdev, num_clips, clips_bo);
    335 - if (!rects)
    336 + if (!rects) {
    337 + ret = -EINVAL;
    338 goto out_release_backoff;
    339 -
    340 + }
    341 drawable = (struct qxl_drawable *)qxl_release_map(qdev, release);
    342
    343 drawable->clip.type = SPICE_CLIP_TYPE_RECTS;
    344 @@ -242,8 +243,8 @@ void qxl_draw_dirty_fb(struct qxl_device *qdev,
    345 }
    346 qxl_bo_kunmap(clips_bo);
    347
    348 - qxl_push_command_ring_release(qdev, release, QXL_CMD_DRAW, false);
    349 qxl_release_fence_buffer_objects(release);
    350 + qxl_push_command_ring_release(qdev, release, QXL_CMD_DRAW, false);
    351
    352 out_release_backoff:
    353 if (ret)
    354 diff --git a/drivers/gpu/drm/qxl/qxl_ioctl.c b/drivers/gpu/drm/qxl/qxl_ioctl.c
    355 index 8117a45b3610..72f3f1bbb40c 100644
    356 --- a/drivers/gpu/drm/qxl/qxl_ioctl.c
    357 +++ b/drivers/gpu/drm/qxl/qxl_ioctl.c
    358 @@ -261,11 +261,8 @@ static int qxl_process_single_command(struct qxl_device *qdev,
    359 apply_surf_reloc(qdev, &reloc_info[i]);
    360 }
    361
    362 + qxl_release_fence_buffer_objects(release);
    363 ret = qxl_push_command_ring_release(qdev, release, cmd->type, true);
    364 - if (ret)
    365 - qxl_release_backoff_reserve_list(release);
    366 - else
    367 - qxl_release_fence_buffer_objects(release);
    368
    369 out_free_bos:
    370 out_free_release:
    371 diff --git a/drivers/hv/vmbus_drv.c b/drivers/hv/vmbus_drv.c
    372 index 40f6b73dae94..9cdd434bb340 100644
    373 --- a/drivers/hv/vmbus_drv.c
    374 +++ b/drivers/hv/vmbus_drv.c
    375 @@ -978,6 +978,9 @@ static int vmbus_resume(struct device *child_device)
    376
    377 return drv->resume(dev);
    378 }
    379 +#else
    380 +#define vmbus_suspend NULL
    381 +#define vmbus_resume NULL
    382 #endif /* CONFIG_PM_SLEEP */
    383
    384 /*
    385 @@ -995,11 +998,22 @@ static void vmbus_device_release(struct device *device)
    386 }
    387
    388 /*
    389 - * Note: we must use SET_NOIRQ_SYSTEM_SLEEP_PM_OPS rather than
    390 - * SET_SYSTEM_SLEEP_PM_OPS: see the comment before vmbus_bus_pm.
    391 + * Note: we must use the "noirq" ops: see the comment before vmbus_bus_pm.
    392 + *
    393 + * suspend_noirq/resume_noirq are set to NULL to support Suspend-to-Idle: we
    394 + * shouldn't suspend the vmbus devices upon Suspend-to-Idle, otherwise there
    395 + * is no way to wake up a Generation-2 VM.
    396 + *
    397 + * The other 4 ops are for hibernation.
    398 */
    399 +
    400 static const struct dev_pm_ops vmbus_pm = {
    401 - SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(vmbus_suspend, vmbus_resume)
    402 + .suspend_noirq = NULL,
    403 + .resume_noirq = NULL,
    404 + .freeze_noirq = vmbus_suspend,
    405 + .thaw_noirq = vmbus_resume,
    406 + .poweroff_noirq = vmbus_suspend,
    407 + .restore_noirq = vmbus_resume,
    408 };
    409
    410 /* The one and only one */
    411 @@ -2280,6 +2294,9 @@ static int vmbus_bus_resume(struct device *dev)
    412
    413 return 0;
    414 }
    415 +#else
    416 +#define vmbus_bus_suspend NULL
    417 +#define vmbus_bus_resume NULL
    418 #endif /* CONFIG_PM_SLEEP */
    419
    420 static const struct acpi_device_id vmbus_acpi_device_ids[] = {
    421 @@ -2290,16 +2307,24 @@ static const struct acpi_device_id vmbus_acpi_device_ids[] = {
    422 MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);
    423
    424 /*
    425 - * Note: we must use SET_NOIRQ_SYSTEM_SLEEP_PM_OPS rather than
    426 - * SET_SYSTEM_SLEEP_PM_OPS, otherwise NIC SR-IOV can not work, because the
    427 - * "pci_dev_pm_ops" uses the "noirq" callbacks: in the resume path, the
    428 - * pci "noirq" restore callback runs before "non-noirq" callbacks (see
    429 + * Note: we must use the "no_irq" ops, otherwise hibernation can not work with
    430 + * PCI device assignment, because "pci_dev_pm_ops" uses the "noirq" ops: in
    431 + * the resume path, the pci "noirq" restore op runs before "non-noirq" op (see
    432 * resume_target_kernel() -> dpm_resume_start(), and hibernation_restore() ->
    433 * dpm_resume_end()). This means vmbus_bus_resume() and the pci-hyperv's
    434 - * resume callback must also run via the "noirq" callbacks.
    435 + * resume callback must also run via the "noirq" ops.
    436 + *
    437 + * Set suspend_noirq/resume_noirq to NULL for Suspend-to-Idle: see the comment
    438 + * earlier in this file before vmbus_pm.
    439 */
    440 +
    441 static const struct dev_pm_ops vmbus_bus_pm = {
    442 - SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(vmbus_bus_suspend, vmbus_bus_resume)
    443 + .suspend_noirq = NULL,
    444 + .resume_noirq = NULL,
    445 + .freeze_noirq = vmbus_bus_suspend,
    446 + .thaw_noirq = vmbus_bus_resume,
    447 + .poweroff_noirq = vmbus_bus_suspend,
    448 + .restore_noirq = vmbus_bus_resume
    449 };
    450
    451 static struct acpi_driver vmbus_acpi_driver = {
    452 diff --git a/drivers/i2c/busses/i2c-amd-mp2-pci.c b/drivers/i2c/busses/i2c-amd-mp2-pci.c
    453 index 5e4800d72e00..cd3fd5ee5f65 100644
    454 --- a/drivers/i2c/busses/i2c-amd-mp2-pci.c
    455 +++ b/drivers/i2c/busses/i2c-amd-mp2-pci.c
    456 @@ -349,12 +349,12 @@ static int amd_mp2_pci_probe(struct pci_dev *pci_dev,
    457 if (!privdata)
    458 return -ENOMEM;
    459
    460 + privdata->pci_dev = pci_dev;
    461 rc = amd_mp2_pci_init(privdata, pci_dev);
    462 if (rc)
    463 return rc;
    464
    465 mutex_init(&privdata->c2p_lock);
    466 - privdata->pci_dev = pci_dev;
    467
    468 pm_runtime_set_autosuspend_delay(&pci_dev->dev, 1000);
    469 pm_runtime_use_autosuspend(&pci_dev->dev);
    470 diff --git a/drivers/i2c/busses/i2c-aspeed.c b/drivers/i2c/busses/i2c-aspeed.c
    471 index 7b098ff5f5dd..dad6e432de89 100644
    472 --- a/drivers/i2c/busses/i2c-aspeed.c
    473 +++ b/drivers/i2c/busses/i2c-aspeed.c
    474 @@ -603,6 +603,7 @@ static irqreturn_t aspeed_i2c_bus_irq(int irq, void *dev_id)
    475 /* Ack all interrupts except for Rx done */
    476 writel(irq_received & ~ASPEED_I2CD_INTR_RX_DONE,
    477 bus->base + ASPEED_I2C_INTR_STS_REG);
    478 + readl(bus->base + ASPEED_I2C_INTR_STS_REG);
    479 irq_remaining = irq_received;
    480
    481 #if IS_ENABLED(CONFIG_I2C_SLAVE)
    482 @@ -645,9 +646,11 @@ static irqreturn_t aspeed_i2c_bus_irq(int irq, void *dev_id)
    483 irq_received, irq_handled);
    484
    485 /* Ack Rx done */
    486 - if (irq_received & ASPEED_I2CD_INTR_RX_DONE)
    487 + if (irq_received & ASPEED_I2CD_INTR_RX_DONE) {
    488 writel(ASPEED_I2CD_INTR_RX_DONE,
    489 bus->base + ASPEED_I2C_INTR_STS_REG);
    490 + readl(bus->base + ASPEED_I2C_INTR_STS_REG);
    491 + }
    492 spin_unlock(&bus->lock);
    493 return irq_remaining ? IRQ_NONE : IRQ_HANDLED;
    494 }
    495 diff --git a/drivers/i2c/busses/i2c-bcm-iproc.c b/drivers/i2c/busses/i2c-bcm-iproc.c
    496 index 9ffdffaf6141..03475f179973 100644
    497 --- a/drivers/i2c/busses/i2c-bcm-iproc.c
    498 +++ b/drivers/i2c/busses/i2c-bcm-iproc.c
    499 @@ -359,6 +359,9 @@ static bool bcm_iproc_i2c_slave_isr(struct bcm_iproc_i2c_dev *iproc_i2c,
    500 value = (u8)((val >> S_RX_DATA_SHIFT) & S_RX_DATA_MASK);
    501 i2c_slave_event(iproc_i2c->slave,
    502 I2C_SLAVE_WRITE_RECEIVED, &value);
    503 + if (rx_status == I2C_SLAVE_RX_END)
    504 + i2c_slave_event(iproc_i2c->slave,
    505 + I2C_SLAVE_STOP, &value);
    506 }
    507 } else if (status & BIT(IS_S_TX_UNDERRUN_SHIFT)) {
    508 /* Master read other than start */
    509 diff --git a/drivers/infiniband/core/cm.c b/drivers/infiniband/core/cm.c
    510 index 319e4b4ae639..09af96ec41dd 100644
    511 --- a/drivers/infiniband/core/cm.c
    512 +++ b/drivers/infiniband/core/cm.c
    513 @@ -597,18 +597,6 @@ static int cm_init_av_by_path(struct sa_path_rec *path,
    514 return 0;
    515 }
    516
    517 -static int cm_alloc_id(struct cm_id_private *cm_id_priv)
    518 -{
    519 - int err;
    520 - u32 id;
    521 -
    522 - err = xa_alloc_cyclic_irq(&cm.local_id_table, &id, cm_id_priv,
    523 - xa_limit_32b, &cm.local_id_next, GFP_KERNEL);
    524 -
    525 - cm_id_priv->id.local_id = (__force __be32)id ^ cm.random_id_operand;
    526 - return err;
    527 -}
    528 -
    529 static u32 cm_local_id(__be32 local_id)
    530 {
    531 return (__force u32) (local_id ^ cm.random_id_operand);
    532 @@ -862,6 +850,7 @@ struct ib_cm_id *ib_create_cm_id(struct ib_device *device,
    533 void *context)
    534 {
    535 struct cm_id_private *cm_id_priv;
    536 + u32 id;
    537 int ret;
    538
    539 cm_id_priv = kzalloc(sizeof *cm_id_priv, GFP_KERNEL);
    540 @@ -873,9 +862,6 @@ struct ib_cm_id *ib_create_cm_id(struct ib_device *device,
    541 cm_id_priv->id.cm_handler = cm_handler;
    542 cm_id_priv->id.context = context;
    543 cm_id_priv->id.remote_cm_qpn = 1;
    544 - ret = cm_alloc_id(cm_id_priv);
    545 - if (ret)
    546 - goto error;
    547
    548 spin_lock_init(&cm_id_priv->lock);
    549 init_completion(&cm_id_priv->comp);
    550 @@ -884,11 +870,20 @@ struct ib_cm_id *ib_create_cm_id(struct ib_device *device,
    551 INIT_LIST_HEAD(&cm_id_priv->altr_list);
    552 atomic_set(&cm_id_priv->work_count, -1);
    553 atomic_set(&cm_id_priv->refcount, 1);
    554 +
    555 + ret = xa_alloc_cyclic_irq(&cm.local_id_table, &id, NULL, xa_limit_32b,
    556 + &cm.local_id_next, GFP_KERNEL);
    557 + if (ret < 0)
    558 + goto error;
    559 + cm_id_priv->id.local_id = (__force __be32)id ^ cm.random_id_operand;
    560 + xa_store_irq(&cm.local_id_table, cm_local_id(cm_id_priv->id.local_id),
    561 + cm_id_priv, GFP_KERNEL);
    562 +
    563 return &cm_id_priv->id;
    564
    565 error:
    566 kfree(cm_id_priv);
    567 - return ERR_PTR(-ENOMEM);
    568 + return ERR_PTR(ret);
    569 }
    570 EXPORT_SYMBOL(ib_create_cm_id);
    571
    572 diff --git a/drivers/infiniband/core/rdma_core.c b/drivers/infiniband/core/rdma_core.c
    573 index ccf4d069c25c..1c95fefa1f06 100644
    574 --- a/drivers/infiniband/core/rdma_core.c
    575 +++ b/drivers/infiniband/core/rdma_core.c
    576 @@ -362,7 +362,7 @@ lookup_get_fd_uobject(const struct uverbs_api_object *obj,
    577 * and the caller is expected to ensure that uverbs_close_fd is never
    578 * done while a call top lookup is possible.
    579 */
    580 - if (f->f_op != fd_type->fops) {
    581 + if (f->f_op != fd_type->fops || uobject->ufile != ufile) {
    582 fput(f);
    583 return ERR_PTR(-EBADF);
    584 }
    585 @@ -689,7 +689,6 @@ void rdma_lookup_put_uobject(struct ib_uobject *uobj,
    586 enum rdma_lookup_mode mode)
    587 {
    588 assert_uverbs_usecnt(uobj, mode);
    589 - uobj->uapi_object->type_class->lookup_put(uobj, mode);
    590 /*
    591 * In order to unlock an object, either decrease its usecnt for
    592 * read access or zero it in case of exclusive access. See
    593 @@ -706,6 +705,7 @@ void rdma_lookup_put_uobject(struct ib_uobject *uobj,
    594 break;
    595 }
    596
    597 + uobj->uapi_object->type_class->lookup_put(uobj, mode);
    598 /* Pairs with the kref obtained by type->lookup_get */
    599 uverbs_uobject_put(uobj);
    600 }
    601 diff --git a/drivers/infiniband/hw/mlx4/main.c b/drivers/infiniband/hw/mlx4/main.c
    602 index 369a203332a2..61a1b0bdede0 100644
    603 --- a/drivers/infiniband/hw/mlx4/main.c
    604 +++ b/drivers/infiniband/hw/mlx4/main.c
    605 @@ -1492,8 +1492,9 @@ static int __mlx4_ib_create_default_rules(
    606 int i;
    607
    608 for (i = 0; i < ARRAY_SIZE(pdefault_rules->rules_create_list); i++) {
    609 + union ib_flow_spec ib_spec = {};
    610 int ret;
    611 - union ib_flow_spec ib_spec;
    612 +
    613 switch (pdefault_rules->rules_create_list[i]) {
    614 case 0:
    615 /* no rule */
    616 diff --git a/drivers/infiniband/hw/mlx5/qp.c b/drivers/infiniband/hw/mlx5/qp.c
    617 index 881decb1309a..96edc5c30204 100644
    618 --- a/drivers/infiniband/hw/mlx5/qp.c
    619 +++ b/drivers/infiniband/hw/mlx5/qp.c
    620 @@ -5496,7 +5496,9 @@ static void to_rdma_ah_attr(struct mlx5_ib_dev *ibdev,
    621 rdma_ah_set_path_bits(ah_attr, path->grh_mlid & 0x7f);
    622 rdma_ah_set_static_rate(ah_attr,
    623 path->static_rate ? path->static_rate - 5 : 0);
    624 - if (path->grh_mlid & (1 << 7)) {
    625 +
    626 + if (path->grh_mlid & (1 << 7) ||
    627 + ah_attr->type == RDMA_AH_ATTR_TYPE_ROCE) {
    628 u32 tc_fl = be32_to_cpu(path->tclass_flowlabel);
    629
    630 rdma_ah_set_grh(ah_attr, NULL,
    631 diff --git a/drivers/infiniband/sw/rdmavt/cq.c b/drivers/infiniband/sw/rdmavt/cq.c
    632 index 0fee3c87776b..bd729aa1d510 100644
    633 --- a/drivers/infiniband/sw/rdmavt/cq.c
    634 +++ b/drivers/infiniband/sw/rdmavt/cq.c
    635 @@ -248,8 +248,8 @@ int rvt_create_cq(struct ib_cq *ibcq, const struct ib_cq_init_attr *attr,
    636 */
    637 if (udata && udata->outlen >= sizeof(__u64)) {
    638 cq->ip = rvt_create_mmap_info(rdi, sz, udata, u_wc);
    639 - if (!cq->ip) {
    640 - err = -ENOMEM;
    641 + if (IS_ERR(cq->ip)) {
    642 + err = PTR_ERR(cq->ip);
    643 goto bail_wc;
    644 }
    645
    646 diff --git a/drivers/infiniband/sw/rdmavt/mmap.c b/drivers/infiniband/sw/rdmavt/mmap.c
    647 index 652f4a7efc1b..37853aa3bcf7 100644
    648 --- a/drivers/infiniband/sw/rdmavt/mmap.c
    649 +++ b/drivers/infiniband/sw/rdmavt/mmap.c
    650 @@ -154,7 +154,7 @@ done:
    651 * @udata: user data (must be valid!)
    652 * @obj: opaque pointer to a cq, wq etc
    653 *
    654 - * Return: rvt_mmap struct on success
    655 + * Return: rvt_mmap struct on success, ERR_PTR on failure
    656 */
    657 struct rvt_mmap_info *rvt_create_mmap_info(struct rvt_dev_info *rdi, u32 size,
    658 struct ib_udata *udata, void *obj)
    659 @@ -166,7 +166,7 @@ struct rvt_mmap_info *rvt_create_mmap_info(struct rvt_dev_info *rdi, u32 size,
    660
    661 ip = kmalloc_node(sizeof(*ip), GFP_KERNEL, rdi->dparms.node);
    662 if (!ip)
    663 - return ip;
    664 + return ERR_PTR(-ENOMEM);
    665
    666 size = PAGE_ALIGN(size);
    667
    668 diff --git a/drivers/infiniband/sw/rdmavt/qp.c b/drivers/infiniband/sw/rdmavt/qp.c
    669 index 799254a049ba..d35465389357 100644
    670 --- a/drivers/infiniband/sw/rdmavt/qp.c
    671 +++ b/drivers/infiniband/sw/rdmavt/qp.c
    672 @@ -1244,8 +1244,8 @@ struct ib_qp *rvt_create_qp(struct ib_pd *ibpd,
    673
    674 qp->ip = rvt_create_mmap_info(rdi, s, udata,
    675 qp->r_rq.wq);
    676 - if (!qp->ip) {
    677 - ret = ERR_PTR(-ENOMEM);
    678 + if (IS_ERR(qp->ip)) {
    679 + ret = ERR_CAST(qp->ip);
    680 goto bail_qpn;
    681 }
    682
    683 diff --git a/drivers/infiniband/sw/rdmavt/srq.c b/drivers/infiniband/sw/rdmavt/srq.c
    684 index 24fef021d51d..f547c115af03 100644
    685 --- a/drivers/infiniband/sw/rdmavt/srq.c
    686 +++ b/drivers/infiniband/sw/rdmavt/srq.c
    687 @@ -111,8 +111,8 @@ int rvt_create_srq(struct ib_srq *ibsrq, struct ib_srq_init_attr *srq_init_attr,
    688 u32 s = sizeof(struct rvt_rwq) + srq->rq.size * sz;
    689
    690 srq->ip = rvt_create_mmap_info(dev, s, udata, srq->rq.wq);
    691 - if (!srq->ip) {
    692 - ret = -ENOMEM;
    693 + if (IS_ERR(srq->ip)) {
    694 + ret = PTR_ERR(srq->ip);
    695 goto bail_wq;
    696 }
    697
    698 diff --git a/drivers/infiniband/sw/siw/siw_qp_tx.c b/drivers/infiniband/sw/siw/siw_qp_tx.c
    699 index 5d97bba0ce6d..e7cd04eda04a 100644
    700 --- a/drivers/infiniband/sw/siw/siw_qp_tx.c
    701 +++ b/drivers/infiniband/sw/siw/siw_qp_tx.c
    702 @@ -920,20 +920,27 @@ static int siw_fastreg_mr(struct ib_pd *pd, struct siw_sqe *sqe)
    703 {
    704 struct ib_mr *base_mr = (struct ib_mr *)(uintptr_t)sqe->base_mr;
    705 struct siw_device *sdev = to_siw_dev(pd->device);
    706 - struct siw_mem *mem = siw_mem_id2obj(sdev, sqe->rkey >> 8);
    707 + struct siw_mem *mem;
    708 int rv = 0;
    709
    710 siw_dbg_pd(pd, "STag 0x%08x\n", sqe->rkey);
    711
    712 - if (unlikely(!mem || !base_mr)) {
    713 + if (unlikely(!base_mr)) {
    714 pr_warn("siw: fastreg: STag 0x%08x unknown\n", sqe->rkey);
    715 return -EINVAL;
    716 }
    717 +
    718 if (unlikely(base_mr->rkey >> 8 != sqe->rkey >> 8)) {
    719 pr_warn("siw: fastreg: STag 0x%08x: bad MR\n", sqe->rkey);
    720 - rv = -EINVAL;
    721 - goto out;
    722 + return -EINVAL;
    723 }
    724 +
    725 + mem = siw_mem_id2obj(sdev, sqe->rkey >> 8);
    726 + if (unlikely(!mem)) {
    727 + pr_warn("siw: fastreg: STag 0x%08x unknown\n", sqe->rkey);
    728 + return -EINVAL;
    729 + }
    730 +
    731 if (unlikely(mem->pd != pd)) {
    732 pr_warn("siw: fastreg: PD mismatch\n");
    733 rv = -EINVAL;
    734 diff --git a/drivers/iommu/amd_iommu_init.c b/drivers/iommu/amd_iommu_init.c
    735 index b5ae9f7c0510..ef14b00fa94b 100644
    736 --- a/drivers/iommu/amd_iommu_init.c
    737 +++ b/drivers/iommu/amd_iommu_init.c
    738 @@ -2946,7 +2946,7 @@ static int __init parse_amd_iommu_intr(char *str)
    739 {
    740 for (; *str; ++str) {
    741 if (strncmp(str, "legacy", 6) == 0) {
    742 - amd_iommu_guest_ir = AMD_IOMMU_GUEST_IR_LEGACY;
    743 + amd_iommu_guest_ir = AMD_IOMMU_GUEST_IR_LEGACY_GA;
    744 break;
    745 }
    746 if (strncmp(str, "vapic", 5) == 0) {
    747 diff --git a/drivers/iommu/qcom_iommu.c b/drivers/iommu/qcom_iommu.c
    748 index e0b3fa2bb7ab..280de92b332e 100644
    749 --- a/drivers/iommu/qcom_iommu.c
    750 +++ b/drivers/iommu/qcom_iommu.c
    751 @@ -814,8 +814,11 @@ static int qcom_iommu_device_probe(struct platform_device *pdev)
    752 qcom_iommu->dev = dev;
    753
    754 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    755 - if (res)
    756 + if (res) {
    757 qcom_iommu->local_base = devm_ioremap_resource(dev, res);
    758 + if (IS_ERR(qcom_iommu->local_base))
    759 + return PTR_ERR(qcom_iommu->local_base);
    760 + }
    761
    762 qcom_iommu->iface_clk = devm_clk_get(dev, "iface");
    763 if (IS_ERR(qcom_iommu->iface_clk)) {
    764 diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c
    765 index e0c32793c248..456d790c918c 100644
    766 --- a/drivers/md/dm-mpath.c
    767 +++ b/drivers/md/dm-mpath.c
    768 @@ -576,10 +576,12 @@ static struct pgpath *__map_bio(struct multipath *m, struct bio *bio)
    769
    770 /* Do we need to select a new pgpath? */
    771 pgpath = READ_ONCE(m->current_pgpath);
    772 - queue_io = test_bit(MPATHF_QUEUE_IO, &m->flags);
    773 - if (!pgpath || !queue_io)
    774 + if (!pgpath || !test_bit(MPATHF_QUEUE_IO, &m->flags))
    775 pgpath = choose_pgpath(m, bio->bi_iter.bi_size);
    776
    777 + /* MPATHF_QUEUE_IO might have been cleared by choose_pgpath. */
    778 + queue_io = test_bit(MPATHF_QUEUE_IO, &m->flags);
    779 +
    780 if ((pgpath && queue_io) ||
    781 (!pgpath && test_bit(MPATHF_QUEUE_IF_NO_PATH, &m->flags))) {
    782 /* Queue for the daemon to resubmit */
    783 diff --git a/drivers/md/dm-verity-fec.c b/drivers/md/dm-verity-fec.c
    784 index 49147e634046..fb41b4f23c48 100644
    785 --- a/drivers/md/dm-verity-fec.c
    786 +++ b/drivers/md/dm-verity-fec.c
    787 @@ -435,7 +435,7 @@ int verity_fec_decode(struct dm_verity *v, struct dm_verity_io *io,
    788 fio->level++;
    789
    790 if (type == DM_VERITY_BLOCK_TYPE_METADATA)
    791 - block += v->data_blocks;
    792 + block = block - v->hash_start + v->data_blocks;
    793
    794 /*
    795 * For RS(M, N), the continuous FEC data is divided into blocks of N
    796 diff --git a/drivers/md/dm-writecache.c b/drivers/md/dm-writecache.c
    797 index 5bf60d6be96a..0d6ca723257f 100644
    798 --- a/drivers/md/dm-writecache.c
    799 +++ b/drivers/md/dm-writecache.c
    800 @@ -878,6 +878,24 @@ static int writecache_alloc_entries(struct dm_writecache *wc)
    801 return 0;
    802 }
    803
    804 +static int writecache_read_metadata(struct dm_writecache *wc, sector_t n_sectors)
    805 +{
    806 + struct dm_io_region region;
    807 + struct dm_io_request req;
    808 +
    809 + region.bdev = wc->ssd_dev->bdev;
    810 + region.sector = wc->start_sector;
    811 + region.count = n_sectors;
    812 + req.bi_op = REQ_OP_READ;
    813 + req.bi_op_flags = REQ_SYNC;
    814 + req.mem.type = DM_IO_VMA;
    815 + req.mem.ptr.vma = (char *)wc->memory_map;
    816 + req.client = wc->dm_io;
    817 + req.notify.fn = NULL;
    818 +
    819 + return dm_io(&req, 1, &region, NULL);
    820 +}
    821 +
    822 static void writecache_resume(struct dm_target *ti)
    823 {
    824 struct dm_writecache *wc = ti->private;
    825 @@ -888,8 +906,18 @@ static void writecache_resume(struct dm_target *ti)
    826
    827 wc_lock(wc);
    828
    829 - if (WC_MODE_PMEM(wc))
    830 + if (WC_MODE_PMEM(wc)) {
    831 persistent_memory_invalidate_cache(wc->memory_map, wc->memory_map_size);
    832 + } else {
    833 + r = writecache_read_metadata(wc, wc->metadata_sectors);
    834 + if (r) {
    835 + size_t sb_entries_offset;
    836 + writecache_error(wc, r, "unable to read metadata: %d", r);
    837 + sb_entries_offset = offsetof(struct wc_memory_superblock, entries);
    838 + memset((char *)wc->memory_map + sb_entries_offset, -1,
    839 + (wc->metadata_sectors << SECTOR_SHIFT) - sb_entries_offset);
    840 + }
    841 + }
    842
    843 wc->tree = RB_ROOT;
    844 INIT_LIST_HEAD(&wc->lru);
    845 @@ -1984,6 +2012,12 @@ static int writecache_ctr(struct dm_target *ti, unsigned argc, char **argv)
    846 ti->error = "Invalid block size";
    847 goto bad;
    848 }
    849 + if (wc->block_size < bdev_logical_block_size(wc->dev->bdev) ||
    850 + wc->block_size < bdev_logical_block_size(wc->ssd_dev->bdev)) {
    851 + r = -EINVAL;
    852 + ti->error = "Block size is smaller than device logical block size";
    853 + goto bad;
    854 + }
    855 wc->block_size_bits = __ffs(wc->block_size);
    856
    857 wc->max_writeback_jobs = MAX_WRITEBACK_JOBS;
    858 @@ -2072,8 +2106,6 @@ invalid_optional:
    859 goto bad;
    860 }
    861 } else {
    862 - struct dm_io_region region;
    863 - struct dm_io_request req;
    864 size_t n_blocks, n_metadata_blocks;
    865 uint64_t n_bitmap_bits;
    866
    867 @@ -2130,19 +2162,9 @@ invalid_optional:
    868 goto bad;
    869 }
    870
    871 - region.bdev = wc->ssd_dev->bdev;
    872 - region.sector = wc->start_sector;
    873 - region.count = wc->metadata_sectors;
    874 - req.bi_op = REQ_OP_READ;
    875 - req.bi_op_flags = REQ_SYNC;
    876 - req.mem.type = DM_IO_VMA;
    877 - req.mem.ptr.vma = (char *)wc->memory_map;
    878 - req.client = wc->dm_io;
    879 - req.notify.fn = NULL;
    880 -
    881 - r = dm_io(&req, 1, &region, NULL);
    882 + r = writecache_read_metadata(wc, wc->block_size >> SECTOR_SHIFT);
    883 if (r) {
    884 - ti->error = "Unable to read metadata";
    885 + ti->error = "Unable to read first block of metadata";
    886 goto bad;
    887 }
    888 }
    889 diff --git a/drivers/mmc/host/cqhci.c b/drivers/mmc/host/cqhci.c
    890 index 5047f7343ffc..c19f4c3f115a 100644
    891 --- a/drivers/mmc/host/cqhci.c
    892 +++ b/drivers/mmc/host/cqhci.c
    893 @@ -5,6 +5,7 @@
    894 #include <linux/delay.h>
    895 #include <linux/highmem.h>
    896 #include <linux/io.h>
    897 +#include <linux/iopoll.h>
    898 #include <linux/module.h>
    899 #include <linux/dma-mapping.h>
    900 #include <linux/slab.h>
    901 @@ -343,12 +344,16 @@ static int cqhci_enable(struct mmc_host *mmc, struct mmc_card *card)
    902 /* CQHCI is idle and should halt immediately, so set a small timeout */
    903 #define CQHCI_OFF_TIMEOUT 100
    904
    905 +static u32 cqhci_read_ctl(struct cqhci_host *cq_host)
    906 +{
    907 + return cqhci_readl(cq_host, CQHCI_CTL);
    908 +}
    909 +
    910 static void cqhci_off(struct mmc_host *mmc)
    911 {
    912 struct cqhci_host *cq_host = mmc->cqe_private;
    913 - ktime_t timeout;
    914 - bool timed_out;
    915 u32 reg;
    916 + int err;
    917
    918 if (!cq_host->enabled || !mmc->cqe_on || cq_host->recovery_halt)
    919 return;
    920 @@ -358,15 +363,9 @@ static void cqhci_off(struct mmc_host *mmc)
    921
    922 cqhci_writel(cq_host, CQHCI_HALT, CQHCI_CTL);
    923
    924 - timeout = ktime_add_us(ktime_get(), CQHCI_OFF_TIMEOUT);
    925 - while (1) {
    926 - timed_out = ktime_compare(ktime_get(), timeout) > 0;
    927 - reg = cqhci_readl(cq_host, CQHCI_CTL);
    928 - if ((reg & CQHCI_HALT) || timed_out)
    929 - break;
    930 - }
    931 -
    932 - if (timed_out)
    933 + err = readx_poll_timeout(cqhci_read_ctl, cq_host, reg,
    934 + reg & CQHCI_HALT, 0, CQHCI_OFF_TIMEOUT);
    935 + if (err < 0)
    936 pr_err("%s: cqhci: CQE stuck on\n", mmc_hostname(mmc));
    937 else
    938 pr_debug("%s: cqhci: CQE off\n", mmc_hostname(mmc));
    939 diff --git a/drivers/mmc/host/meson-mx-sdio.c b/drivers/mmc/host/meson-mx-sdio.c
    940 index ba9a63db73da..999214e8cf2b 100644
    941 --- a/drivers/mmc/host/meson-mx-sdio.c
    942 +++ b/drivers/mmc/host/meson-mx-sdio.c
    943 @@ -357,14 +357,6 @@ static void meson_mx_mmc_request(struct mmc_host *mmc, struct mmc_request *mrq)
    944 meson_mx_mmc_start_cmd(mmc, mrq->cmd);
    945 }
    946
    947 -static int meson_mx_mmc_card_busy(struct mmc_host *mmc)
    948 -{
    949 - struct meson_mx_mmc_host *host = mmc_priv(mmc);
    950 - u32 irqc = readl(host->base + MESON_MX_SDIO_IRQC);
    951 -
    952 - return !!(irqc & MESON_MX_SDIO_IRQC_FORCE_DATA_DAT_MASK);
    953 -}
    954 -
    955 static void meson_mx_mmc_read_response(struct mmc_host *mmc,
    956 struct mmc_command *cmd)
    957 {
    958 @@ -506,7 +498,6 @@ static void meson_mx_mmc_timeout(struct timer_list *t)
    959 static struct mmc_host_ops meson_mx_mmc_ops = {
    960 .request = meson_mx_mmc_request,
    961 .set_ios = meson_mx_mmc_set_ios,
    962 - .card_busy = meson_mx_mmc_card_busy,
    963 .get_cd = mmc_gpio_get_cd,
    964 .get_ro = mmc_gpio_get_ro,
    965 };
    966 @@ -570,7 +561,7 @@ static int meson_mx_mmc_add_host(struct meson_mx_mmc_host *host)
    967 mmc->f_max = clk_round_rate(host->cfg_div_clk,
    968 clk_get_rate(host->parent_clk));
    969
    970 - mmc->caps |= MMC_CAP_ERASE | MMC_CAP_CMD23;
    971 + mmc->caps |= MMC_CAP_ERASE | MMC_CAP_CMD23 | MMC_CAP_WAIT_WHILE_BUSY;
    972 mmc->ops = &meson_mx_mmc_ops;
    973
    974 ret = mmc_of_parse(mmc);
    975 diff --git a/drivers/mmc/host/sdhci-msm.c b/drivers/mmc/host/sdhci-msm.c
    976 index 3d0bb5e2e09b..0148f8e6bb37 100644
    977 --- a/drivers/mmc/host/sdhci-msm.c
    978 +++ b/drivers/mmc/host/sdhci-msm.c
    979 @@ -1944,6 +1944,8 @@ static int sdhci_msm_probe(struct platform_device *pdev)
    980 goto clk_disable;
    981 }
    982
    983 + msm_host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY | MMC_CAP_NEED_RSP_BUSY;
    984 +
    985 pm_runtime_get_noresume(&pdev->dev);
    986 pm_runtime_set_active(&pdev->dev);
    987 pm_runtime_enable(&pdev->dev);
    988 diff --git a/drivers/mmc/host/sdhci-pci-core.c b/drivers/mmc/host/sdhci-pci-core.c
    989 index 5091e2c1c0e5..9b66e8b374ed 100644
    990 --- a/drivers/mmc/host/sdhci-pci-core.c
    991 +++ b/drivers/mmc/host/sdhci-pci-core.c
    992 @@ -601,6 +601,9 @@ static int intel_select_drive_strength(struct mmc_card *card,
    993 struct sdhci_pci_slot *slot = sdhci_priv(host);
    994 struct intel_host *intel_host = sdhci_pci_priv(slot);
    995
    996 + if (!(mmc_driver_type_mask(intel_host->drv_strength) & card_drv))
    997 + return 0;
    998 +
    999 return intel_host->drv_strength;
    1000 }
    1001
    1002 diff --git a/drivers/mmc/host/sdhci-xenon.c b/drivers/mmc/host/sdhci-xenon.c
    1003 index 1dea1ba66f7b..4703cd540c7f 100644
    1004 --- a/drivers/mmc/host/sdhci-xenon.c
    1005 +++ b/drivers/mmc/host/sdhci-xenon.c
    1006 @@ -235,6 +235,16 @@ static void xenon_voltage_switch(struct sdhci_host *host)
    1007 {
    1008 /* Wait for 5ms after set 1.8V signal enable bit */
    1009 usleep_range(5000, 5500);
    1010 +
    1011 + /*
    1012 + * For some reason the controller's Host Control2 register reports
    1013 + * the bit representing 1.8V signaling as 0 when read after it was
    1014 + * written as 1. Subsequent read reports 1.
    1015 + *
    1016 + * Since this may cause some issues, do an empty read of the Host
    1017 + * Control2 register here to circumvent this.
    1018 + */
    1019 + sdhci_readw(host, SDHCI_HOST_CONTROL2);
    1020 }
    1021
    1022 static const struct sdhci_ops sdhci_xenon_ops = {
    1023 diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c
    1024 index f97c48fd3eda..31b7dcd791c2 100644
    1025 --- a/drivers/nvme/host/core.c
    1026 +++ b/drivers/nvme/host/core.c
    1027 @@ -3566,6 +3566,8 @@ static int nvme_alloc_ns(struct nvme_ctrl *ctrl, unsigned nsid)
    1028
    1029 return 0;
    1030 out_put_disk:
    1031 + /* prevent double queue cleanup */
    1032 + ns->disk->queue = NULL;
    1033 put_disk(ns->disk);
    1034 out_unlink_ns:
    1035 mutex_lock(&ctrl->subsys->lock);
    1036 diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
    1037 index 06037e3c7854..03d272a09e26 100644
    1038 --- a/drivers/scsi/qla2xxx/qla_os.c
    1039 +++ b/drivers/scsi/qla2xxx/qla_os.c
    1040 @@ -3700,6 +3700,13 @@ qla2x00_remove_one(struct pci_dev *pdev)
    1041 }
    1042 qla2x00_wait_for_hba_ready(base_vha);
    1043
    1044 + /*
    1045 + * if UNLOADING flag is already set, then continue unload,
    1046 + * where it was set first.
    1047 + */
    1048 + if (test_and_set_bit(UNLOADING, &base_vha->dpc_flags))
    1049 + return;
    1050 +
    1051 if (IS_QLA25XX(ha) || IS_QLA2031(ha) || IS_QLA27XX(ha) ||
    1052 IS_QLA28XX(ha)) {
    1053 if (ha->flags.fw_started)
    1054 @@ -3718,15 +3725,6 @@ qla2x00_remove_one(struct pci_dev *pdev)
    1055
    1056 qla2x00_wait_for_sess_deletion(base_vha);
    1057
    1058 - /*
    1059 - * if UNLOAD flag is already set, then continue unload,
    1060 - * where it was set first.
    1061 - */
    1062 - if (test_bit(UNLOADING, &base_vha->dpc_flags))
    1063 - return;
    1064 -
    1065 - set_bit(UNLOADING, &base_vha->dpc_flags);
    1066 -
    1067 qla_nvme_delete(base_vha);
    1068
    1069 dma_free_coherent(&ha->pdev->dev,
    1070 @@ -4859,6 +4857,9 @@ qla2x00_alloc_work(struct scsi_qla_host *vha, enum qla_work_type type)
    1071 struct qla_work_evt *e;
    1072 uint8_t bail;
    1073
    1074 + if (test_bit(UNLOADING, &vha->dpc_flags))
    1075 + return NULL;
    1076 +
    1077 QLA_VHA_MARK_BUSY(vha, bail);
    1078 if (bail)
    1079 return NULL;
    1080 @@ -6053,13 +6054,6 @@ qla2x00_disable_board_on_pci_error(struct work_struct *work)
    1081 struct pci_dev *pdev = ha->pdev;
    1082 scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
    1083
    1084 - /*
    1085 - * if UNLOAD flag is already set, then continue unload,
    1086 - * where it was set first.
    1087 - */
    1088 - if (test_bit(UNLOADING, &base_vha->dpc_flags))
    1089 - return;
    1090 -
    1091 ql_log(ql_log_warn, base_vha, 0x015b,
    1092 "Disabling adapter.\n");
    1093
    1094 @@ -6070,9 +6064,14 @@ qla2x00_disable_board_on_pci_error(struct work_struct *work)
    1095 return;
    1096 }
    1097
    1098 - qla2x00_wait_for_sess_deletion(base_vha);
    1099 + /*
    1100 + * if UNLOADING flag is already set, then continue unload,
    1101 + * where it was set first.
    1102 + */
    1103 + if (test_and_set_bit(UNLOADING, &base_vha->dpc_flags))
    1104 + return;
    1105
    1106 - set_bit(UNLOADING, &base_vha->dpc_flags);
    1107 + qla2x00_wait_for_sess_deletion(base_vha);
    1108
    1109 qla2x00_delete_all_vps(ha, base_vha);
    1110
    1111 diff --git a/drivers/target/target_core_iblock.c b/drivers/target/target_core_iblock.c
    1112 index 51ffd5c002de..1c181d31f4c8 100644
    1113 --- a/drivers/target/target_core_iblock.c
    1114 +++ b/drivers/target/target_core_iblock.c
    1115 @@ -432,7 +432,7 @@ iblock_execute_zero_out(struct block_device *bdev, struct se_cmd *cmd)
    1116 target_to_linux_sector(dev, cmd->t_task_lba),
    1117 target_to_linux_sector(dev,
    1118 sbc_get_write_same_sectors(cmd)),
    1119 - GFP_KERNEL, false);
    1120 + GFP_KERNEL, BLKDEV_ZERO_NOUNMAP);
    1121 if (ret)
    1122 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
    1123
    1124 diff --git a/drivers/vfio/vfio_iommu_type1.c b/drivers/vfio/vfio_iommu_type1.c
    1125 index d864277ea16f..6cc47af1f06d 100644
    1126 --- a/drivers/vfio/vfio_iommu_type1.c
    1127 +++ b/drivers/vfio/vfio_iommu_type1.c
    1128 @@ -380,8 +380,8 @@ static int vaddr_get_pfn(struct mm_struct *mm, unsigned long vaddr,
    1129 vma = find_vma_intersection(mm, vaddr, vaddr + 1);
    1130
    1131 if (vma && vma->vm_flags & VM_PFNMAP) {
    1132 - *pfn = ((vaddr - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;
    1133 - if (is_invalid_reserved_pfn(*pfn))
    1134 + if (!follow_pfn(vma, vaddr, pfn) &&
    1135 + is_invalid_reserved_pfn(*pfn))
    1136 ret = 0;
    1137 }
    1138
    1139 @@ -593,7 +593,7 @@ static int vfio_iommu_type1_pin_pages(void *iommu_data,
    1140 continue;
    1141 }
    1142
    1143 - remote_vaddr = dma->vaddr + iova - dma->iova;
    1144 + remote_vaddr = dma->vaddr + (iova - dma->iova);
    1145 ret = vfio_pin_page_external(dma, remote_vaddr, &phys_pfn[i],
    1146 do_accounting);
    1147 if (ret)
    1148 diff --git a/fs/btrfs/block-group.c b/fs/btrfs/block-group.c
    1149 index 95330f40f998..2fead6c3c687 100644
    1150 --- a/fs/btrfs/block-group.c
    1151 +++ b/fs/btrfs/block-group.c
    1152 @@ -910,7 +910,7 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
    1153 path = btrfs_alloc_path();
    1154 if (!path) {
    1155 ret = -ENOMEM;
    1156 - goto out;
    1157 + goto out_put_group;
    1158 }
    1159
    1160 /*
    1161 @@ -948,7 +948,7 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
    1162 ret = btrfs_orphan_add(trans, BTRFS_I(inode));
    1163 if (ret) {
    1164 btrfs_add_delayed_iput(inode);
    1165 - goto out;
    1166 + goto out_put_group;
    1167 }
    1168 clear_nlink(inode);
    1169 /* One for the block groups ref */
    1170 @@ -971,13 +971,13 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
    1171
    1172 ret = btrfs_search_slot(trans, tree_root, &key, path, -1, 1);
    1173 if (ret < 0)
    1174 - goto out;
    1175 + goto out_put_group;
    1176 if (ret > 0)
    1177 btrfs_release_path(path);
    1178 if (ret == 0) {
    1179 ret = btrfs_del_item(trans, tree_root, path);
    1180 if (ret)
    1181 - goto out;
    1182 + goto out_put_group;
    1183 btrfs_release_path(path);
    1184 }
    1185
    1186 @@ -1094,9 +1094,9 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
    1187
    1188 ret = remove_block_group_free_space(trans, block_group);
    1189 if (ret)
    1190 - goto out;
    1191 + goto out_put_group;
    1192
    1193 - btrfs_put_block_group(block_group);
    1194 + /* Once for the block groups rbtree */
    1195 btrfs_put_block_group(block_group);
    1196
    1197 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
    1198 @@ -1119,6 +1119,10 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
    1199 /* once for the tree */
    1200 free_extent_map(em);
    1201 }
    1202 +
    1203 +out_put_group:
    1204 + /* Once for the lookup reference */
    1205 + btrfs_put_block_group(block_group);
    1206 out:
    1207 if (remove_rsv)
    1208 btrfs_delayed_refs_rsv_release(fs_info, 1);
    1209 diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
    1210 index 32a09ed540a2..e890f09e2073 100644
    1211 --- a/fs/btrfs/relocation.c
    1212 +++ b/fs/btrfs/relocation.c
    1213 @@ -4605,6 +4605,7 @@ int btrfs_recover_relocation(struct btrfs_root *root)
    1214 if (IS_ERR(fs_root)) {
    1215 err = PTR_ERR(fs_root);
    1216 list_add_tail(&reloc_root->root_list, &reloc_roots);
    1217 + btrfs_end_transaction(trans);
    1218 goto out_unset;
    1219 }
    1220
    1221 diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
    1222 index 98b6903e3938..cdca0f656594 100644
    1223 --- a/fs/btrfs/transaction.c
    1224 +++ b/fs/btrfs/transaction.c
    1225 @@ -590,10 +590,19 @@ again:
    1226 }
    1227
    1228 got_it:
    1229 - btrfs_record_root_in_trans(h, root);
    1230 -
    1231 if (!current->journal_info)
    1232 current->journal_info = h;
    1233 +
    1234 + /*
    1235 + * btrfs_record_root_in_trans() needs to alloc new extents, and may
    1236 + * call btrfs_join_transaction() while we're also starting a
    1237 + * transaction.
    1238 + *
    1239 + * Thus it need to be called after current->journal_info initialized,
    1240 + * or we can deadlock.
    1241 + */
    1242 + btrfs_record_root_in_trans(h, root);
    1243 +
    1244 return h;
    1245
    1246 join_fail:
    1247 diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
    1248 index 6f2178618c22..7d464b049507 100644
    1249 --- a/fs/btrfs/tree-log.c
    1250 +++ b/fs/btrfs/tree-log.c
    1251 @@ -4242,6 +4242,9 @@ static int btrfs_log_prealloc_extents(struct btrfs_trans_handle *trans,
    1252 const u64 ino = btrfs_ino(inode);
    1253 struct btrfs_path *dst_path = NULL;
    1254 bool dropped_extents = false;
    1255 + u64 truncate_offset = i_size;
    1256 + struct extent_buffer *leaf;
    1257 + int slot;
    1258 int ins_nr = 0;
    1259 int start_slot;
    1260 int ret;
    1261 @@ -4256,9 +4259,43 @@ static int btrfs_log_prealloc_extents(struct btrfs_trans_handle *trans,
    1262 if (ret < 0)
    1263 goto out;
    1264
    1265 + /*
    1266 + * We must check if there is a prealloc extent that starts before the
    1267 + * i_size and crosses the i_size boundary. This is to ensure later we
    1268 + * truncate down to the end of that extent and not to the i_size, as
    1269 + * otherwise we end up losing part of the prealloc extent after a log
    1270 + * replay and with an implicit hole if there is another prealloc extent
    1271 + * that starts at an offset beyond i_size.
    1272 + */
    1273 + ret = btrfs_previous_item(root, path, ino, BTRFS_EXTENT_DATA_KEY);
    1274 + if (ret < 0)
    1275 + goto out;
    1276 +
    1277 + if (ret == 0) {
    1278 + struct btrfs_file_extent_item *ei;
    1279 +
    1280 + leaf = path->nodes[0];
    1281 + slot = path->slots[0];
    1282 + ei = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
    1283 +
    1284 + if (btrfs_file_extent_type(leaf, ei) ==
    1285 + BTRFS_FILE_EXTENT_PREALLOC) {
    1286 + u64 extent_end;
    1287 +
    1288 + btrfs_item_key_to_cpu(leaf, &key, slot);
    1289 + extent_end = key.offset +
    1290 + btrfs_file_extent_num_bytes(leaf, ei);
    1291 +
    1292 + if (extent_end > i_size)
    1293 + truncate_offset = extent_end;
    1294 + }
    1295 + } else {
    1296 + ret = 0;
    1297 + }
    1298 +
    1299 while (true) {
    1300 - struct extent_buffer *leaf = path->nodes[0];
    1301 - int slot = path->slots[0];
    1302 + leaf = path->nodes[0];
    1303 + slot = path->slots[0];
    1304
    1305 if (slot >= btrfs_header_nritems(leaf)) {
    1306 if (ins_nr > 0) {
    1307 @@ -4296,7 +4333,7 @@ static int btrfs_log_prealloc_extents(struct btrfs_trans_handle *trans,
    1308 ret = btrfs_truncate_inode_items(trans,
    1309 root->log_root,
    1310 &inode->vfs_inode,
    1311 - i_size,
    1312 + truncate_offset,
    1313 BTRFS_EXTENT_DATA_KEY);
    1314 } while (ret == -EAGAIN);
    1315 if (ret)
    1316 diff --git a/fs/nfs/nfs3acl.c b/fs/nfs/nfs3acl.c
    1317 index c5c3fc6e6c60..26c94b32d6f4 100644
    1318 --- a/fs/nfs/nfs3acl.c
    1319 +++ b/fs/nfs/nfs3acl.c
    1320 @@ -253,37 +253,45 @@ int nfs3_proc_setacls(struct inode *inode, struct posix_acl *acl,
    1321
    1322 int nfs3_set_acl(struct inode *inode, struct posix_acl *acl, int type)
    1323 {
    1324 - struct posix_acl *alloc = NULL, *dfacl = NULL;
    1325 + struct posix_acl *orig = acl, *dfacl = NULL, *alloc;
    1326 int status;
    1327
    1328 if (S_ISDIR(inode->i_mode)) {
    1329 switch(type) {
    1330 case ACL_TYPE_ACCESS:
    1331 - alloc = dfacl = get_acl(inode, ACL_TYPE_DEFAULT);
    1332 + alloc = get_acl(inode, ACL_TYPE_DEFAULT);
    1333 if (IS_ERR(alloc))
    1334 goto fail;
    1335 + dfacl = alloc;
    1336 break;
    1337
    1338 case ACL_TYPE_DEFAULT:
    1339 - dfacl = acl;
    1340 - alloc = acl = get_acl(inode, ACL_TYPE_ACCESS);
    1341 + alloc = get_acl(inode, ACL_TYPE_ACCESS);
    1342 if (IS_ERR(alloc))
    1343 goto fail;
    1344 + dfacl = acl;
    1345 + acl = alloc;
    1346 break;
    1347 }
    1348 }
    1349
    1350 if (acl == NULL) {
    1351 - alloc = acl = posix_acl_from_mode(inode->i_mode, GFP_KERNEL);
    1352 + alloc = posix_acl_from_mode(inode->i_mode, GFP_KERNEL);
    1353 if (IS_ERR(alloc))
    1354 goto fail;
    1355 + acl = alloc;
    1356 }
    1357 status = __nfs3_proc_setacls(inode, acl, dfacl);
    1358 - posix_acl_release(alloc);
    1359 +out:
    1360 + if (acl != orig)
    1361 + posix_acl_release(acl);
    1362 + if (dfacl != orig)
    1363 + posix_acl_release(dfacl);
    1364 return status;
    1365
    1366 fail:
    1367 - return PTR_ERR(alloc);
    1368 + status = PTR_ERR(alloc);
    1369 + goto out;
    1370 }
    1371
    1372 const struct xattr_handler *nfs3_xattr_handlers[] = {
    1373 diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
    1374 index 6b29703d2fe1..e257653f25ab 100644
    1375 --- a/fs/nfs/nfs4proc.c
    1376 +++ b/fs/nfs/nfs4proc.c
    1377 @@ -7852,6 +7852,7 @@ static void
    1378 nfs4_bind_one_conn_to_session_done(struct rpc_task *task, void *calldata)
    1379 {
    1380 struct nfs41_bind_conn_to_session_args *args = task->tk_msg.rpc_argp;
    1381 + struct nfs41_bind_conn_to_session_res *res = task->tk_msg.rpc_resp;
    1382 struct nfs_client *clp = args->client;
    1383
    1384 switch (task->tk_status) {
    1385 @@ -7860,6 +7861,12 @@ nfs4_bind_one_conn_to_session_done(struct rpc_task *task, void *calldata)
    1386 nfs4_schedule_session_recovery(clp->cl_session,
    1387 task->tk_status);
    1388 }
    1389 + if (args->dir == NFS4_CDFC4_FORE_OR_BOTH &&
    1390 + res->dir != NFS4_CDFS4_BOTH) {
    1391 + rpc_task_close_connection(task);
    1392 + if (args->retries++ < MAX_BIND_CONN_TO_SESSION_RETRIES)
    1393 + rpc_restart_call(task);
    1394 + }
    1395 }
    1396
    1397 static const struct rpc_call_ops nfs4_bind_one_conn_to_session_ops = {
    1398 @@ -7882,6 +7889,7 @@ int nfs4_proc_bind_one_conn_to_session(struct rpc_clnt *clnt,
    1399 struct nfs41_bind_conn_to_session_args args = {
    1400 .client = clp,
    1401 .dir = NFS4_CDFC4_FORE_OR_BOTH,
    1402 + .retries = 0,
    1403 };
    1404 struct nfs41_bind_conn_to_session_res res;
    1405 struct rpc_message msg = {
    1406 diff --git a/fs/ocfs2/dlmfs/dlmfs.c b/fs/ocfs2/dlmfs/dlmfs.c
    1407 index 8e4f1ace467c..1de77f1a600b 100644
    1408 --- a/fs/ocfs2/dlmfs/dlmfs.c
    1409 +++ b/fs/ocfs2/dlmfs/dlmfs.c
    1410 @@ -275,7 +275,6 @@ static ssize_t dlmfs_file_write(struct file *filp,
    1411 loff_t *ppos)
    1412 {
    1413 int bytes_left;
    1414 - ssize_t writelen;
    1415 char *lvb_buf;
    1416 struct inode *inode = file_inode(filp);
    1417
    1418 @@ -285,32 +284,30 @@ static ssize_t dlmfs_file_write(struct file *filp,
    1419 if (*ppos >= i_size_read(inode))
    1420 return -ENOSPC;
    1421
    1422 + /* don't write past the lvb */
    1423 + if (count > i_size_read(inode) - *ppos)
    1424 + count = i_size_read(inode) - *ppos;
    1425 +
    1426 if (!count)
    1427 return 0;
    1428
    1429 if (!access_ok(buf, count))
    1430 return -EFAULT;
    1431
    1432 - /* don't write past the lvb */
    1433 - if ((count + *ppos) > i_size_read(inode))
    1434 - writelen = i_size_read(inode) - *ppos;
    1435 - else
    1436 - writelen = count - *ppos;
    1437 -
    1438 - lvb_buf = kmalloc(writelen, GFP_NOFS);
    1439 + lvb_buf = kmalloc(count, GFP_NOFS);
    1440 if (!lvb_buf)
    1441 return -ENOMEM;
    1442
    1443 - bytes_left = copy_from_user(lvb_buf, buf, writelen);
    1444 - writelen -= bytes_left;
    1445 - if (writelen)
    1446 - user_dlm_write_lvb(inode, lvb_buf, writelen);
    1447 + bytes_left = copy_from_user(lvb_buf, buf, count);
    1448 + count -= bytes_left;
    1449 + if (count)
    1450 + user_dlm_write_lvb(inode, lvb_buf, count);
    1451
    1452 kfree(lvb_buf);
    1453
    1454 - *ppos = *ppos + writelen;
    1455 - mlog(0, "wrote %zd bytes\n", writelen);
    1456 - return writelen;
    1457 + *ppos = *ppos + count;
    1458 + mlog(0, "wrote %zu bytes\n", count);
    1459 + return count;
    1460 }
    1461
    1462 static void dlmfs_init_once(void *foo)
    1463 diff --git a/fs/super.c b/fs/super.c
    1464 index cd352530eca9..a288cd60d2ae 100644
    1465 --- a/fs/super.c
    1466 +++ b/fs/super.c
    1467 @@ -1302,8 +1302,8 @@ int get_tree_bdev(struct fs_context *fc,
    1468 mutex_lock(&bdev->bd_fsfreeze_mutex);
    1469 if (bdev->bd_fsfreeze_count > 0) {
    1470 mutex_unlock(&bdev->bd_fsfreeze_mutex);
    1471 - blkdev_put(bdev, mode);
    1472 warnf(fc, "%pg: Can't mount, blockdev is frozen", bdev);
    1473 + blkdev_put(bdev, mode);
    1474 return -EBUSY;
    1475 }
    1476
    1477 diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
    1478 index 9b8324ec08f3..99d327d0bccb 100644
    1479 --- a/include/linux/nfs_xdr.h
    1480 +++ b/include/linux/nfs_xdr.h
    1481 @@ -1307,11 +1307,13 @@ struct nfs41_impl_id {
    1482 struct nfstime4 date;
    1483 };
    1484
    1485 +#define MAX_BIND_CONN_TO_SESSION_RETRIES 3
    1486 struct nfs41_bind_conn_to_session_args {
    1487 struct nfs_client *client;
    1488 struct nfs4_sessionid sessionid;
    1489 u32 dir;
    1490 bool use_conn_in_rdma_mode;
    1491 + int retries;
    1492 };
    1493
    1494 struct nfs41_bind_conn_to_session_res {
    1495 diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h
    1496 index abc63bd1be2b..336802acc629 100644
    1497 --- a/include/linux/sunrpc/clnt.h
    1498 +++ b/include/linux/sunrpc/clnt.h
    1499 @@ -237,5 +237,10 @@ static inline int rpc_reply_expected(struct rpc_task *task)
    1500 (task->tk_msg.rpc_proc->p_decode != NULL);
    1501 }
    1502
    1503 +static inline void rpc_task_close_connection(struct rpc_task *task)
    1504 +{
    1505 + if (task->tk_xprt)
    1506 + xprt_force_disconnect(task->tk_xprt);
    1507 +}
    1508 #endif /* __KERNEL__ */
    1509 #endif /* _LINUX_SUNRPC_CLNT_H */
    1510 diff --git a/include/uapi/linux/dma-buf.h b/include/uapi/linux/dma-buf.h
    1511 index dbc7092e04b5..7f30393b92c3 100644
    1512 --- a/include/uapi/linux/dma-buf.h
    1513 +++ b/include/uapi/linux/dma-buf.h
    1514 @@ -39,6 +39,12 @@ struct dma_buf_sync {
    1515
    1516 #define DMA_BUF_BASE 'b'
    1517 #define DMA_BUF_IOCTL_SYNC _IOW(DMA_BUF_BASE, 0, struct dma_buf_sync)
    1518 +
    1519 +/* 32/64bitness of this uapi was botched in android, there's no difference
    1520 + * between them in actual uapi, they're just different numbers.
    1521 + */
    1522 #define DMA_BUF_SET_NAME _IOW(DMA_BUF_BASE, 1, const char *)
    1523 +#define DMA_BUF_SET_NAME_A _IOW(DMA_BUF_BASE, 1, u32)
    1524 +#define DMA_BUF_SET_NAME_B _IOW(DMA_BUF_BASE, 1, u64)
    1525
    1526 #endif
    1527 diff --git a/kernel/power/hibernate.c b/kernel/power/hibernate.c
    1528 index 3c0a5a8170b0..b6c5895ced36 100644
    1529 --- a/kernel/power/hibernate.c
    1530 +++ b/kernel/power/hibernate.c
    1531 @@ -898,6 +898,13 @@ static int software_resume(void)
    1532 error = freeze_processes();
    1533 if (error)
    1534 goto Close_Finish;
    1535 +
    1536 + error = freeze_kernel_threads();
    1537 + if (error) {
    1538 + thaw_processes();
    1539 + goto Close_Finish;
    1540 + }
    1541 +
    1542 error = load_image_and_restore();
    1543 thaw_processes();
    1544 Finish:
    1545 diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
    1546 index 39410913a694..552e73d90fd2 100644
    1547 --- a/security/selinux/hooks.c
    1548 +++ b/security/selinux/hooks.c
    1549 @@ -5521,40 +5521,60 @@ static int selinux_tun_dev_open(void *security)
    1550
    1551 static int selinux_nlmsg_perm(struct sock *sk, struct sk_buff *skb)
    1552 {
    1553 - int err = 0;
    1554 - u32 perm;
    1555 + int rc = 0;
    1556 + unsigned int msg_len;
    1557 + unsigned int data_len = skb->len;
    1558 + unsigned char *data = skb->data;
    1559 struct nlmsghdr *nlh;
    1560 struct sk_security_struct *sksec = sk->sk_security;
    1561 + u16 sclass = sksec->sclass;
    1562 + u32 perm;
    1563
    1564 - if (skb->len < NLMSG_HDRLEN) {
    1565 - err = -EINVAL;
    1566 - goto out;
    1567 - }
    1568 - nlh = nlmsg_hdr(skb);
    1569 + while (data_len >= nlmsg_total_size(0)) {
    1570 + nlh = (struct nlmsghdr *)data;
    1571 +
    1572 + /* NOTE: the nlmsg_len field isn't reliably set by some netlink
    1573 + * users which means we can't reject skb's with bogus
    1574 + * length fields; our solution is to follow what
    1575 + * netlink_rcv_skb() does and simply skip processing at
    1576 + * messages with length fields that are clearly junk
    1577 + */
    1578 + if (nlh->nlmsg_len < NLMSG_HDRLEN || nlh->nlmsg_len > data_len)
    1579 + return 0;
    1580
    1581 - err = selinux_nlmsg_lookup(sksec->sclass, nlh->nlmsg_type, &perm);
    1582 - if (err) {
    1583 - if (err == -EINVAL) {
    1584 + rc = selinux_nlmsg_lookup(sclass, nlh->nlmsg_type, &perm);
    1585 + if (rc == 0) {
    1586 + rc = sock_has_perm(sk, perm);
    1587 + if (rc)
    1588 + return rc;
    1589 + } else if (rc == -EINVAL) {
    1590 + /* -EINVAL is a missing msg/perm mapping */
    1591 pr_warn_ratelimited("SELinux: unrecognized netlink"
    1592 - " message: protocol=%hu nlmsg_type=%hu sclass=%s"
    1593 - " pig=%d comm=%s\n",
    1594 - sk->sk_protocol, nlh->nlmsg_type,
    1595 - secclass_map[sksec->sclass - 1].name,
    1596 - task_pid_nr(current), current->comm);
    1597 - if (!enforcing_enabled(&selinux_state) ||
    1598 - security_get_allow_unknown(&selinux_state))
    1599 - err = 0;
    1600 + " message: protocol=%hu nlmsg_type=%hu sclass=%s"
    1601 + " pid=%d comm=%s\n",
    1602 + sk->sk_protocol, nlh->nlmsg_type,
    1603 + secclass_map[sclass - 1].name,
    1604 + task_pid_nr(current), current->comm);
    1605 + if (enforcing_enabled(&selinux_state) &&
    1606 + !security_get_allow_unknown(&selinux_state))
    1607 + return rc;
    1608 + rc = 0;
    1609 + } else if (rc == -ENOENT) {
    1610 + /* -ENOENT is a missing socket/class mapping, ignore */
    1611 + rc = 0;
    1612 + } else {
    1613 + return rc;
    1614 }
    1615
    1616 - /* Ignore */
    1617 - if (err == -ENOENT)
    1618 - err = 0;
    1619 - goto out;
    1620 + /* move to the next message after applying netlink padding */
    1621 + msg_len = NLMSG_ALIGN(nlh->nlmsg_len);
    1622 + if (msg_len >= data_len)
    1623 + return 0;
    1624 + data_len -= msg_len;
    1625 + data += msg_len;
    1626 }
    1627
    1628 - err = sock_has_perm(sk, perm);
    1629 -out:
    1630 - return err;
    1631 + return rc;
    1632 }
    1633
    1634 #ifdef CONFIG_NETFILTER
    1635 diff --git a/sound/core/oss/pcm_plugin.c b/sound/core/oss/pcm_plugin.c
    1636 index 8539047145de..da400da1fafe 100644
    1637 --- a/sound/core/oss/pcm_plugin.c
    1638 +++ b/sound/core/oss/pcm_plugin.c
    1639 @@ -211,21 +211,23 @@ static snd_pcm_sframes_t plug_client_size(struct snd_pcm_substream *plug,
    1640 if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
    1641 plugin = snd_pcm_plug_last(plug);
    1642 while (plugin && drv_frames > 0) {
    1643 - if (check_size && drv_frames > plugin->buf_frames)
    1644 - drv_frames = plugin->buf_frames;
    1645 plugin_prev = plugin->prev;
    1646 if (plugin->src_frames)
    1647 drv_frames = plugin->src_frames(plugin, drv_frames);
    1648 + if (check_size && plugin->buf_frames &&
    1649 + drv_frames > plugin->buf_frames)
    1650 + drv_frames = plugin->buf_frames;
    1651 plugin = plugin_prev;
    1652 }
    1653 } else if (stream == SNDRV_PCM_STREAM_CAPTURE) {
    1654 plugin = snd_pcm_plug_first(plug);
    1655 while (plugin && drv_frames > 0) {
    1656 plugin_next = plugin->next;
    1657 + if (check_size && plugin->buf_frames &&
    1658 + drv_frames > plugin->buf_frames)
    1659 + drv_frames = plugin->buf_frames;
    1660 if (plugin->dst_frames)
    1661 drv_frames = plugin->dst_frames(plugin, drv_frames);
    1662 - if (check_size && drv_frames > plugin->buf_frames)
    1663 - drv_frames = plugin->buf_frames;
    1664 plugin = plugin_next;
    1665 }
    1666 } else
    1667 @@ -251,26 +253,28 @@ static snd_pcm_sframes_t plug_slave_size(struct snd_pcm_substream *plug,
    1668 plugin = snd_pcm_plug_first(plug);
    1669 while (plugin && frames > 0) {
    1670 plugin_next = plugin->next;
    1671 + if (check_size && plugin->buf_frames &&
    1672 + frames > plugin->buf_frames)
    1673 + frames = plugin->buf_frames;
    1674 if (plugin->dst_frames) {
    1675 frames = plugin->dst_frames(plugin, frames);
    1676 if (frames < 0)
    1677 return frames;
    1678 }
    1679 - if (check_size && frames > plugin->buf_frames)
    1680 - frames = plugin->buf_frames;
    1681 plugin = plugin_next;
    1682 }
    1683 } else if (stream == SNDRV_PCM_STREAM_CAPTURE) {
    1684 plugin = snd_pcm_plug_last(plug);
    1685 while (plugin) {
    1686 - if (check_size && frames > plugin->buf_frames)
    1687 - frames = plugin->buf_frames;
    1688 plugin_prev = plugin->prev;
    1689 if (plugin->src_frames) {
    1690 frames = plugin->src_frames(plugin, frames);
    1691 if (frames < 0)
    1692 return frames;
    1693 }
    1694 + if (check_size && plugin->buf_frames &&
    1695 + frames > plugin->buf_frames)
    1696 + frames = plugin->buf_frames;
    1697 plugin = plugin_prev;
    1698 }
    1699 } else
    1700 diff --git a/sound/isa/opti9xx/miro.c b/sound/isa/opti9xx/miro.c
    1701 index 0458934de1c7..9ca5c83de8a7 100644
    1702 --- a/sound/isa/opti9xx/miro.c
    1703 +++ b/sound/isa/opti9xx/miro.c
    1704 @@ -867,10 +867,13 @@ static void snd_miro_write(struct snd_miro *chip, unsigned char reg,
    1705 spin_unlock_irqrestore(&chip->lock, flags);
    1706 }
    1707
    1708 +static inline void snd_miro_write_mask(struct snd_miro *chip,
    1709 + unsigned char reg, unsigned char value, unsigned char mask)
    1710 +{
    1711 + unsigned char oldval = snd_miro_read(chip, reg);
    1712
    1713 -#define snd_miro_write_mask(chip, reg, value, mask) \
    1714 - snd_miro_write(chip, reg, \
    1715 - (snd_miro_read(chip, reg) & ~(mask)) | ((value) & (mask)))
    1716 + snd_miro_write(chip, reg, (oldval & ~mask) | (value & mask));
    1717 +}
    1718
    1719 /*
    1720 * Proc Interface
    1721 diff --git a/sound/isa/opti9xx/opti92x-ad1848.c b/sound/isa/opti9xx/opti92x-ad1848.c
    1722 index fb36bb5d55df..fb87eedc8121 100644
    1723 --- a/sound/isa/opti9xx/opti92x-ad1848.c
    1724 +++ b/sound/isa/opti9xx/opti92x-ad1848.c
    1725 @@ -317,10 +317,13 @@ static void snd_opti9xx_write(struct snd_opti9xx *chip, unsigned char reg,
    1726 }
    1727
    1728
    1729 -#define snd_opti9xx_write_mask(chip, reg, value, mask) \
    1730 - snd_opti9xx_write(chip, reg, \
    1731 - (snd_opti9xx_read(chip, reg) & ~(mask)) | ((value) & (mask)))
    1732 +static inline void snd_opti9xx_write_mask(struct snd_opti9xx *chip,
    1733 + unsigned char reg, unsigned char value, unsigned char mask)
    1734 +{
    1735 + unsigned char oldval = snd_opti9xx_read(chip, reg);
    1736
    1737 + snd_opti9xx_write(chip, reg, (oldval & ~mask) | (value & mask));
    1738 +}
    1739
    1740 static int snd_opti9xx_configure(struct snd_opti9xx *chip,
    1741 long port,
    1742 diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c
    1743 index f1febfc47ba6..663168ddce72 100644
    1744 --- a/sound/pci/hda/patch_hdmi.c
    1745 +++ b/sound/pci/hda/patch_hdmi.c
    1746 @@ -1861,8 +1861,10 @@ static bool check_non_pcm_per_cvt(struct hda_codec *codec, hda_nid_t cvt_nid)
    1747 /* Add sanity check to pass klockwork check.
    1748 * This should never happen.
    1749 */
    1750 - if (WARN_ON(spdif == NULL))
    1751 + if (WARN_ON(spdif == NULL)) {
    1752 + mutex_unlock(&codec->spdif_mutex);
    1753 return true;
    1754 + }
    1755 non_pcm = !!(spdif->status & IEC958_AES0_NONAUDIO);
    1756 mutex_unlock(&codec->spdif_mutex);
    1757 return non_pcm;
    1758 diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
    1759 index ee1b89f2bcd5..64270983ab7d 100644
    1760 --- a/sound/pci/hda/patch_realtek.c
    1761 +++ b/sound/pci/hda/patch_realtek.c
    1762 @@ -7295,6 +7295,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = {
    1763 SND_PCI_QUIRK(0x1558, 0x8560, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC),
    1764 SND_PCI_QUIRK(0x1558, 0x8561, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC),
    1765 SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),
    1766 + SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
    1767 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
    1768 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
    1769 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
    1770 diff --git a/sound/usb/line6/podhd.c b/sound/usb/line6/podhd.c
    1771 index 27bf61c177c0..5d9954a2d05e 100644
    1772 --- a/sound/usb/line6/podhd.c
    1773 +++ b/sound/usb/line6/podhd.c
    1774 @@ -21,8 +21,7 @@
    1775 enum {
    1776 LINE6_PODHD300,
    1777 LINE6_PODHD400,
    1778 - LINE6_PODHD500_0,
    1779 - LINE6_PODHD500_1,
    1780 + LINE6_PODHD500,
    1781 LINE6_PODX3,
    1782 LINE6_PODX3LIVE,
    1783 LINE6_PODHD500X,
    1784 @@ -318,8 +317,7 @@ static const struct usb_device_id podhd_id_table[] = {
    1785 /* TODO: no need to alloc data interfaces when only audio is used */
    1786 { LINE6_DEVICE(0x5057), .driver_info = LINE6_PODHD300 },
    1787 { LINE6_DEVICE(0x5058), .driver_info = LINE6_PODHD400 },
    1788 - { LINE6_IF_NUM(0x414D, 0), .driver_info = LINE6_PODHD500_0 },
    1789 - { LINE6_IF_NUM(0x414D, 1), .driver_info = LINE6_PODHD500_1 },
    1790 + { LINE6_IF_NUM(0x414D, 0), .driver_info = LINE6_PODHD500 },
    1791 { LINE6_IF_NUM(0x414A, 0), .driver_info = LINE6_PODX3 },
    1792 { LINE6_IF_NUM(0x414B, 0), .driver_info = LINE6_PODX3LIVE },
    1793 { LINE6_IF_NUM(0x4159, 0), .driver_info = LINE6_PODHD500X },
    1794 @@ -352,23 +350,13 @@ static const struct line6_properties podhd_properties_table[] = {
    1795 .ep_audio_r = 0x82,
    1796 .ep_audio_w = 0x01,
    1797 },
    1798 - [LINE6_PODHD500_0] = {
    1799 + [LINE6_PODHD500] = {
    1800 .id = "PODHD500",
    1801 .name = "POD HD500",
    1802 - .capabilities = LINE6_CAP_PCM
    1803 + .capabilities = LINE6_CAP_PCM | LINE6_CAP_CONTROL
    1804 | LINE6_CAP_HWMON,
    1805 .altsetting = 1,
    1806 - .ep_ctrl_r = 0x81,
    1807 - .ep_ctrl_w = 0x01,
    1808 - .ep_audio_r = 0x86,
    1809 - .ep_audio_w = 0x02,
    1810 - },
    1811 - [LINE6_PODHD500_1] = {
    1812 - .id = "PODHD500",
    1813 - .name = "POD HD500",
    1814 - .capabilities = LINE6_CAP_PCM
    1815 - | LINE6_CAP_HWMON,
    1816 - .altsetting = 0,
    1817 + .ctrl_if = 1,
    1818 .ep_ctrl_r = 0x81,
    1819 .ep_ctrl_w = 0x01,
    1820 .ep_audio_r = 0x86,
    1821 diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c
    1822 index 7448ab07bd36..5a81c444a18b 100644
    1823 --- a/sound/usb/quirks.c
    1824 +++ b/sound/usb/quirks.c
    1825 @@ -1643,7 +1643,7 @@ u64 snd_usb_interface_dsd_format_quirks(struct snd_usb_audio *chip,
    1826
    1827 case USB_ID(0x0d8c, 0x0316): /* Hegel HD12 DSD */
    1828 case USB_ID(0x10cb, 0x0103): /* The Bit Opus #3; with fp->dsd_raw */
    1829 - case USB_ID(0x16b0, 0x06b2): /* NuPrime DAC-10 */
    1830 + case USB_ID(0x16d0, 0x06b2): /* NuPrime DAC-10 */
    1831 case USB_ID(0x16d0, 0x09dd): /* Encore mDSD */
    1832 case USB_ID(0x16d0, 0x0733): /* Furutech ADL Stratos */
    1833 case USB_ID(0x16d0, 0x09db): /* NuPrime Audio DAC-9 */