From 80159c7b5a8cb63a2055e99ce18fc66c1204aa83 Mon Sep 17 00:00:00 2001 From: Sasha Levin Date: Fri, 2 Sep 2022 00:23:50 -0400 Subject: [PATCH] Fixes for 5.15 Signed-off-by: Sasha Levin --- ...mprove-error-handling-in-rz_ssi_prob.patch | 79 ++++ ...e-helper-for-unlinking-inode-during-.patch | 185 ++++++++ ...p-splat-with-reloc-root-extent-buffe.patch | 367 +++++++++++++++ ...g-during-log-replay-when-bumping-ino.patch | 99 ++++ ...e-lockdep-class-helpers-to-locking.c.patch | 248 ++++++++++ ...longer-needed-logic-for-replaying-di.patch | 301 ++++++++++++ ...oot-argument-from-btrfs_unlink_inode.patch | 229 ++++++++++ ...er-check-for-overlapping-extent-item.patch | 77 ++++ ...ay-avoid-doing-vm_init-multiple-time.patch | 47 ++ ...-amd-display-avoid-mpc-infinite-loop.patch | 66 +++ ...clear-optc-underflow-before-turn-off.patch | 45 ++ ...lay-fix-hdmi-vsif-v3-incorrect-issue.patch | 77 ++++ ...-display-fix-pixel-clock-programming.patch | 50 ++ ...splay-for-stereo-keep-flip_any_frame.patch | 40 ++ ...issing-fini_microcode-interface-for-.patch | 34 ++ ...increase-tlb-flush-timeout-for-sriov.patch | 87 ++++ ...t-skip-tlb-invalidations-once-wedged.patch | 55 +++ ...ntfs3-fix-work-with-fragmented-xattr.patch | 46 ++ ...ve-dos-attribute-xattr-on-o_trunc-op.patch | 55 +++ ...tus_bad_network_name-error-status-if.patch | 53 +++ ...lear-interrupts-when-cqe-off-disable.patch | 60 +++ ...mshc-add-reset-call-back-for-rockchi.patch | 93 ++++ ...mshc-re-enable-support-for-the-bluef.patch | 73 +++ ...i-of-dwcmshc-rename-rk3568-to-rk35xx.patch | 204 +++++++++ ...le-dos-due-to-net-iface-start-stop-l.patch | 129 ++++++ ...ack-nf_conntrack_procfs-should-no-lo.patch | 36 ++ ...-hypfs-avoid-error-message-under-kvm.patch | 60 +++ queue-5.15/series | 28 ++ ...s-nft_flowtable.sh-use-random-netns-.patch | 429 ++++++++++++++++++ 29 files changed, 3352 insertions(+) create mode 100644 queue-5.15/asoc-sh-rz-ssi-improve-error-handling-in-rz_ssi_prob.patch create mode 100644 queue-5.15/btrfs-add-and-use-helper-for-unlinking-inode-during-.patch create mode 100644 queue-5.15/btrfs-fix-lockdep-splat-with-reloc-root-extent-buffe.patch create mode 100644 queue-5.15/btrfs-fix-warning-during-log-replay-when-bumping-ino.patch create mode 100644 queue-5.15/btrfs-move-lockdep-class-helpers-to-locking.c.patch create mode 100644 queue-5.15/btrfs-remove-no-longer-needed-logic-for-replaying-di.patch create mode 100644 queue-5.15/btrfs-remove-root-argument-from-btrfs_unlink_inode.patch create mode 100644 queue-5.15/btrfs-tree-checker-check-for-overlapping-extent-item.patch create mode 100644 queue-5.15/drm-amd-display-avoid-doing-vm_init-multiple-time.patch create mode 100644 queue-5.15/drm-amd-display-avoid-mpc-infinite-loop.patch create mode 100644 queue-5.15/drm-amd-display-clear-optc-underflow-before-turn-off.patch create mode 100644 queue-5.15/drm-amd-display-fix-hdmi-vsif-v3-incorrect-issue.patch create mode 100644 queue-5.15/drm-amd-display-fix-pixel-clock-programming.patch create mode 100644 queue-5.15/drm-amd-display-for-stereo-keep-flip_any_frame.patch create mode 100644 queue-5.15/drm-amd-pm-add-missing-fini_microcode-interface-for-.patch create mode 100644 queue-5.15/drm-amdgpu-increase-tlb-flush-timeout-for-sriov.patch create mode 100644 queue-5.15/drm-i915-gt-skip-tlb-invalidations-once-wedged.patch create mode 100644 queue-5.15/fs-ntfs3-fix-work-with-fragmented-xattr.patch create mode 100644 queue-5.15/ksmbd-don-t-remove-dos-attribute-xattr-on-o_trunc-op.patch create mode 100644 queue-5.15/ksmbd-return-status_bad_network_name-error-status-if.patch create mode 100644 queue-5.15/mmc-mtk-sd-clear-interrupts-when-cqe-off-disable.patch create mode 100644 queue-5.15/mmc-sdhci-of-dwcmshc-add-reset-call-back-for-rockchi.patch create mode 100644 queue-5.15/mmc-sdhci-of-dwcmshc-re-enable-support-for-the-bluef.patch create mode 100644 queue-5.15/mmc-sdhci-of-dwcmshc-rename-rk3568-to-rk35xx.patch create mode 100644 queue-5.15/neigh-fix-possible-dos-due-to-net-iface-start-stop-l.patch create mode 100644 queue-5.15/netfilter-conntrack-nf_conntrack_procfs-should-no-lo.patch create mode 100644 queue-5.15/s390-hypfs-avoid-error-message-under-kvm.patch create mode 100644 queue-5.15/testing-selftests-nft_flowtable.sh-use-random-netns-.patch diff --git a/queue-5.15/asoc-sh-rz-ssi-improve-error-handling-in-rz_ssi_prob.patch b/queue-5.15/asoc-sh-rz-ssi-improve-error-handling-in-rz_ssi_prob.patch new file mode 100644 index 00000000000..da72002a949 --- /dev/null +++ b/queue-5.15/asoc-sh-rz-ssi-improve-error-handling-in-rz_ssi_prob.patch @@ -0,0 +1,79 @@ +From 4da26fc386a31d88fff711eb0cb5f7f562a4e312 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Thu, 28 Jul 2022 10:26:12 +0100 +Subject: ASoC: sh: rz-ssi: Improve error handling in rz_ssi_probe() error path + +From: Biju Das + +[ Upstream commit c75ed9f54ce8d349fee557f2b471a4d637ed2a6b ] + +We usually do cleanup in reverse order of init. Currently in case of +error rz_ssi_release_dma_channels() done in the reverse order. This +patch improves error handling in rz_ssi_probe() error path. + +While at it, use "goto cleanup" style to reduce code duplication. + +Reported-by: Pavel Machek +Signed-off-by: Biju Das +Link: https://lore.kernel.org/r/20220728092612.38858-1-biju.das.jz@bp.renesas.com +Signed-off-by: Mark Brown +Signed-off-by: Sasha Levin +--- + sound/soc/sh/rz-ssi.c | 26 +++++++++++++++----------- + 1 file changed, 15 insertions(+), 11 deletions(-) + +diff --git a/sound/soc/sh/rz-ssi.c b/sound/soc/sh/rz-ssi.c +index 6d794eaaf4c39..2e33a1fa0a6f4 100644 +--- a/sound/soc/sh/rz-ssi.c ++++ b/sound/soc/sh/rz-ssi.c +@@ -1022,32 +1022,36 @@ static int rz_ssi_probe(struct platform_device *pdev) + + ssi->rstc = devm_reset_control_get_exclusive(&pdev->dev, NULL); + if (IS_ERR(ssi->rstc)) { +- rz_ssi_release_dma_channels(ssi); +- return PTR_ERR(ssi->rstc); ++ ret = PTR_ERR(ssi->rstc); ++ goto err_reset; + } + + reset_control_deassert(ssi->rstc); + pm_runtime_enable(&pdev->dev); + ret = pm_runtime_resume_and_get(&pdev->dev); + if (ret < 0) { +- rz_ssi_release_dma_channels(ssi); +- pm_runtime_disable(ssi->dev); +- reset_control_assert(ssi->rstc); +- return dev_err_probe(ssi->dev, ret, "pm_runtime_resume_and_get failed\n"); ++ dev_err(&pdev->dev, "pm_runtime_resume_and_get failed\n"); ++ goto err_pm; + } + + ret = devm_snd_soc_register_component(&pdev->dev, &rz_ssi_soc_component, + rz_ssi_soc_dai, + ARRAY_SIZE(rz_ssi_soc_dai)); + if (ret < 0) { +- rz_ssi_release_dma_channels(ssi); +- +- pm_runtime_put(ssi->dev); +- pm_runtime_disable(ssi->dev); +- reset_control_assert(ssi->rstc); + dev_err(&pdev->dev, "failed to register snd component\n"); ++ goto err_snd_soc; + } + ++ return 0; ++ ++err_snd_soc: ++ pm_runtime_put(ssi->dev); ++err_pm: ++ pm_runtime_disable(ssi->dev); ++ reset_control_assert(ssi->rstc); ++err_reset: ++ rz_ssi_release_dma_channels(ssi); ++ + return ret; + } + +-- +2.35.1 + diff --git a/queue-5.15/btrfs-add-and-use-helper-for-unlinking-inode-during-.patch b/queue-5.15/btrfs-add-and-use-helper-for-unlinking-inode-during-.patch new file mode 100644 index 00000000000..53f5e9c729d --- /dev/null +++ b/queue-5.15/btrfs-add-and-use-helper-for-unlinking-inode-during-.patch @@ -0,0 +1,185 @@ +From 9aa8fa48ee15d28826c5da6fef2925ca9a96d29a Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Mon, 28 Feb 2022 16:29:29 +0000 +Subject: btrfs: add and use helper for unlinking inode during log replay + +From: Filipe Manana + +[ Upstream commit 313ab75399d0c7d0ebc718c545572c1b4d8d22ef ] + +During log replay there is this pattern of running delayed items after +every inode unlink. To avoid repeating this several times, move the +logic into an helper function and use it instead of calling +btrfs_unlink_inode() followed by btrfs_run_delayed_items(). + +Signed-off-by: Filipe Manana +Signed-off-by: David Sterba +Signed-off-by: Sasha Levin +--- + fs/btrfs/tree-log.c | 77 +++++++++++++++++---------------------------- + 1 file changed, 29 insertions(+), 48 deletions(-) + +diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c +index 4ab1bbc344760..c56a89d224bbb 100644 +--- a/fs/btrfs/tree-log.c ++++ b/fs/btrfs/tree-log.c +@@ -884,6 +884,26 @@ static noinline int replay_one_extent(struct btrfs_trans_handle *trans, + return ret; + } + ++static int unlink_inode_for_log_replay(struct btrfs_trans_handle *trans, ++ struct btrfs_inode *dir, ++ struct btrfs_inode *inode, ++ const char *name, ++ int name_len) ++{ ++ int ret; ++ ++ ret = btrfs_unlink_inode(trans, dir, inode, name, name_len); ++ if (ret) ++ return ret; ++ /* ++ * Whenever we need to check if a name exists or not, we check the ++ * fs/subvolume tree. So after an unlink we must run delayed items, so ++ * that future checks for a name during log replay see that the name ++ * does not exists anymore. ++ */ ++ return btrfs_run_delayed_items(trans); ++} ++ + /* + * when cleaning up conflicts between the directory names in the + * subvolume, directory names in the log and directory names in the +@@ -926,12 +946,8 @@ static noinline int drop_one_dir_item(struct btrfs_trans_handle *trans, + if (ret) + goto out; + +- ret = btrfs_unlink_inode(trans, dir, BTRFS_I(inode), name, ++ ret = unlink_inode_for_log_replay(trans, dir, BTRFS_I(inode), name, + name_len); +- if (ret) +- goto out; +- else +- ret = btrfs_run_delayed_items(trans); + out: + kfree(name); + iput(inode); +@@ -1091,12 +1107,9 @@ static inline int __add_inode_ref(struct btrfs_trans_handle *trans, + inc_nlink(&inode->vfs_inode); + btrfs_release_path(path); + +- ret = btrfs_unlink_inode(trans, dir, inode, ++ ret = unlink_inode_for_log_replay(trans, dir, inode, + victim_name, victim_name_len); + kfree(victim_name); +- if (ret) +- return ret; +- ret = btrfs_run_delayed_items(trans); + if (ret) + return ret; + *search_done = 1; +@@ -1165,14 +1178,11 @@ static inline int __add_inode_ref(struct btrfs_trans_handle *trans, + inc_nlink(&inode->vfs_inode); + btrfs_release_path(path); + +- ret = btrfs_unlink_inode(trans, ++ ret = unlink_inode_for_log_replay(trans, + BTRFS_I(victim_parent), + inode, + victim_name, + victim_name_len); +- if (!ret) +- ret = btrfs_run_delayed_items( +- trans); + } + iput(victim_parent); + kfree(victim_name); +@@ -1327,19 +1337,10 @@ static int unlink_old_inode_refs(struct btrfs_trans_handle *trans, + kfree(name); + goto out; + } +- ret = btrfs_unlink_inode(trans, BTRFS_I(dir), ++ ret = unlink_inode_for_log_replay(trans, BTRFS_I(dir), + inode, name, namelen); + kfree(name); + iput(dir); +- /* +- * Whenever we need to check if a name exists or not, we +- * check the subvolume tree. So after an unlink we must +- * run delayed items, so that future checks for a name +- * during log replay see that the name does not exists +- * anymore. +- */ +- if (!ret) +- ret = btrfs_run_delayed_items(trans); + if (ret) + goto out; + goto again; +@@ -1434,8 +1435,8 @@ static int add_link(struct btrfs_trans_handle *trans, struct btrfs_root *root, + ret = -ENOENT; + goto out; + } +- ret = btrfs_unlink_inode(trans, BTRFS_I(dir), BTRFS_I(other_inode), +- name, namelen); ++ ret = unlink_inode_for_log_replay(trans, BTRFS_I(dir), BTRFS_I(other_inode), ++ name, namelen); + if (ret) + goto out; + /* +@@ -1444,10 +1445,6 @@ static int add_link(struct btrfs_trans_handle *trans, struct btrfs_root *root, + */ + if (other_inode->i_nlink == 0) + inc_nlink(other_inode); +- +- ret = btrfs_run_delayed_items(trans); +- if (ret) +- goto out; + add_link: + ret = btrfs_add_link(trans, BTRFS_I(dir), BTRFS_I(inode), + name, namelen, 0, ref_index); +@@ -1580,7 +1577,7 @@ static noinline int add_inode_ref(struct btrfs_trans_handle *trans, + ret = btrfs_inode_ref_exists(inode, dir, key->type, + name, namelen); + if (ret > 0) { +- ret = btrfs_unlink_inode(trans, ++ ret = unlink_inode_for_log_replay(trans, + BTRFS_I(dir), + BTRFS_I(inode), + name, namelen); +@@ -1591,15 +1588,6 @@ static noinline int add_inode_ref(struct btrfs_trans_handle *trans, + */ + if (!ret && inode->i_nlink == 0) + inc_nlink(inode); +- /* +- * Whenever we need to check if a name exists or +- * not, we check the subvolume tree. So after an +- * unlink we must run delayed items, so that future +- * checks for a name during log replay see that the +- * name does not exists anymore. +- */ +- if (!ret) +- ret = btrfs_run_delayed_items(trans); + } + if (ret < 0) + goto out; +@@ -2339,15 +2327,8 @@ static noinline int check_item_in_log(struct btrfs_trans_handle *trans, + goto out; + + inc_nlink(inode); +- ret = btrfs_unlink_inode(trans, BTRFS_I(dir), BTRFS_I(inode), name, +- name_len); +- if (ret) +- goto out; +- +- ret = btrfs_run_delayed_items(trans); +- if (ret) +- goto out; +- ++ ret = unlink_inode_for_log_replay(trans, BTRFS_I(dir), BTRFS_I(inode), ++ name, name_len); + /* + * Unlike dir item keys, dir index keys can only have one name (entry) in + * them, as there are no key collisions since each key has a unique offset +-- +2.35.1 + diff --git a/queue-5.15/btrfs-fix-lockdep-splat-with-reloc-root-extent-buffe.patch b/queue-5.15/btrfs-fix-lockdep-splat-with-reloc-root-extent-buffe.patch new file mode 100644 index 00000000000..38a270d3ea0 --- /dev/null +++ b/queue-5.15/btrfs-fix-lockdep-splat-with-reloc-root-extent-buffe.patch @@ -0,0 +1,367 @@ +From 842c60bfdd33d582d5be9fe93206b713d6c99bcb Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Tue, 26 Jul 2022 16:24:04 -0400 +Subject: btrfs: fix lockdep splat with reloc root extent buffers + +From: Josef Bacik + +[ Upstream commit b40130b23ca4a08c5785d5a3559805916bddba3c ] + +We have been hitting the following lockdep splat with btrfs/187 recently + + WARNING: possible circular locking dependency detected + 5.19.0-rc8+ #775 Not tainted + ------------------------------------------------------ + btrfs/752500 is trying to acquire lock: + ffff97e1875a97b8 (btrfs-treloc-02#2){+.+.}-{3:3}, at: __btrfs_tree_lock+0x24/0x110 + + but task is already holding lock: + ffff97e1875a9278 (btrfs-tree-01/1){+.+.}-{3:3}, at: __btrfs_tree_lock+0x24/0x110 + + which lock already depends on the new lock. + + the existing dependency chain (in reverse order) is: + + -> #2 (btrfs-tree-01/1){+.+.}-{3:3}: + down_write_nested+0x41/0x80 + __btrfs_tree_lock+0x24/0x110 + btrfs_init_new_buffer+0x7d/0x2c0 + btrfs_alloc_tree_block+0x120/0x3b0 + __btrfs_cow_block+0x136/0x600 + btrfs_cow_block+0x10b/0x230 + btrfs_search_slot+0x53b/0xb70 + btrfs_lookup_inode+0x2a/0xa0 + __btrfs_update_delayed_inode+0x5f/0x280 + btrfs_async_run_delayed_root+0x24c/0x290 + btrfs_work_helper+0xf2/0x3e0 + process_one_work+0x271/0x590 + worker_thread+0x52/0x3b0 + kthread+0xf0/0x120 + ret_from_fork+0x1f/0x30 + + -> #1 (btrfs-tree-01){++++}-{3:3}: + down_write_nested+0x41/0x80 + __btrfs_tree_lock+0x24/0x110 + btrfs_search_slot+0x3c3/0xb70 + do_relocation+0x10c/0x6b0 + relocate_tree_blocks+0x317/0x6d0 + relocate_block_group+0x1f1/0x560 + btrfs_relocate_block_group+0x23e/0x400 + btrfs_relocate_chunk+0x4c/0x140 + btrfs_balance+0x755/0xe40 + btrfs_ioctl+0x1ea2/0x2c90 + __x64_sys_ioctl+0x88/0xc0 + do_syscall_64+0x38/0x90 + entry_SYSCALL_64_after_hwframe+0x63/0xcd + + -> #0 (btrfs-treloc-02#2){+.+.}-{3:3}: + __lock_acquire+0x1122/0x1e10 + lock_acquire+0xc2/0x2d0 + down_write_nested+0x41/0x80 + __btrfs_tree_lock+0x24/0x110 + btrfs_lock_root_node+0x31/0x50 + btrfs_search_slot+0x1cb/0xb70 + replace_path+0x541/0x9f0 + merge_reloc_root+0x1d6/0x610 + merge_reloc_roots+0xe2/0x260 + relocate_block_group+0x2c8/0x560 + btrfs_relocate_block_group+0x23e/0x400 + btrfs_relocate_chunk+0x4c/0x140 + btrfs_balance+0x755/0xe40 + btrfs_ioctl+0x1ea2/0x2c90 + __x64_sys_ioctl+0x88/0xc0 + do_syscall_64+0x38/0x90 + entry_SYSCALL_64_after_hwframe+0x63/0xcd + + other info that might help us debug this: + + Chain exists of: + btrfs-treloc-02#2 --> btrfs-tree-01 --> btrfs-tree-01/1 + + Possible unsafe locking scenario: + + CPU0 CPU1 + ---- ---- + lock(btrfs-tree-01/1); + lock(btrfs-tree-01); + lock(btrfs-tree-01/1); + lock(btrfs-treloc-02#2); + + *** DEADLOCK *** + + 7 locks held by btrfs/752500: + #0: ffff97e292fdf460 (sb_writers#12){.+.+}-{0:0}, at: btrfs_ioctl+0x208/0x2c90 + #1: ffff97e284c02050 (&fs_info->reclaim_bgs_lock){+.+.}-{3:3}, at: btrfs_balance+0x55f/0xe40 + #2: ffff97e284c00878 (&fs_info->cleaner_mutex){+.+.}-{3:3}, at: btrfs_relocate_block_group+0x236/0x400 + #3: ffff97e292fdf650 (sb_internal#2){.+.+}-{0:0}, at: merge_reloc_root+0xef/0x610 + #4: ffff97e284c02378 (btrfs_trans_num_writers){++++}-{0:0}, at: join_transaction+0x1a8/0x5a0 + #5: ffff97e284c023a0 (btrfs_trans_num_extwriters){++++}-{0:0}, at: join_transaction+0x1a8/0x5a0 + #6: ffff97e1875a9278 (btrfs-tree-01/1){+.+.}-{3:3}, at: __btrfs_tree_lock+0x24/0x110 + + stack backtrace: + CPU: 1 PID: 752500 Comm: btrfs Not tainted 5.19.0-rc8+ #775 + Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.13.0-2.fc32 04/01/2014 + Call Trace: + + dump_stack_lvl+0x56/0x73 + check_noncircular+0xd6/0x100 + ? lock_is_held_type+0xe2/0x140 + __lock_acquire+0x1122/0x1e10 + lock_acquire+0xc2/0x2d0 + ? __btrfs_tree_lock+0x24/0x110 + down_write_nested+0x41/0x80 + ? __btrfs_tree_lock+0x24/0x110 + __btrfs_tree_lock+0x24/0x110 + btrfs_lock_root_node+0x31/0x50 + btrfs_search_slot+0x1cb/0xb70 + ? lock_release+0x137/0x2d0 + ? _raw_spin_unlock+0x29/0x50 + ? release_extent_buffer+0x128/0x180 + replace_path+0x541/0x9f0 + merge_reloc_root+0x1d6/0x610 + merge_reloc_roots+0xe2/0x260 + relocate_block_group+0x2c8/0x560 + btrfs_relocate_block_group+0x23e/0x400 + btrfs_relocate_chunk+0x4c/0x140 + btrfs_balance+0x755/0xe40 + btrfs_ioctl+0x1ea2/0x2c90 + ? lock_is_held_type+0xe2/0x140 + ? lock_is_held_type+0xe2/0x140 + ? __x64_sys_ioctl+0x88/0xc0 + __x64_sys_ioctl+0x88/0xc0 + do_syscall_64+0x38/0x90 + entry_SYSCALL_64_after_hwframe+0x63/0xcd + +This isn't necessarily new, it's just tricky to hit in practice. There +are two competing things going on here. With relocation we create a +snapshot of every fs tree with a reloc tree. Any extent buffers that +get initialized here are initialized with the reloc root lockdep key. +However since it is a snapshot, any blocks that are currently in cache +that originally belonged to the fs tree will have the normal tree +lockdep key set. This creates the lock dependency of + + reloc tree -> normal tree + +for the extent buffer locking during the first phase of the relocation +as we walk down the reloc root to relocate blocks. + +However this is problematic because the final phase of the relocation is +merging the reloc root into the original fs root. This involves +searching down to any keys that exist in the original fs root and then +swapping the relocated block and the original fs root block. We have to +search down to the fs root first, and then go search the reloc root for +the block we need to replace. This creates the dependency of + + normal tree -> reloc tree + +which is why lockdep complains. + +Additionally even if we were to fix this particular mismatch with a +different nesting for the merge case, we're still slotting in a block +that has a owner of the reloc root objectid into a normal tree, so that +block will have its lockdep key set to the tree reloc root, and create a +lockdep splat later on when we wander into that block from the fs root. + +Unfortunately the only solution here is to make sure we do not set the +lockdep key to the reloc tree lockdep key normally, and then reset any +blocks we wander into from the reloc root when we're doing the merged. + +This solves the problem of having mixed tree reloc keys intermixed with +normal tree keys, and then allows us to make sure in the merge case we +maintain the lock order of + + normal tree -> reloc tree + +We handle this by setting a bit on the reloc root when we do the search +for the block we want to relocate, and any block we search into or COW +at that point gets set to the reloc tree key. This works correctly +because we only ever COW down to the parent node, so we aren't resetting +the key for the block we're linking into the fs root. + +With this patch we no longer have the lockdep splat in btrfs/187. + +Signed-off-by: Josef Bacik +Reviewed-by: David Sterba +Signed-off-by: David Sterba +Signed-off-by: Sasha Levin +--- + fs/btrfs/ctree.c | 3 +++ + fs/btrfs/ctree.h | 2 ++ + fs/btrfs/extent-tree.c | 18 +++++++++++++++++- + fs/btrfs/extent_io.c | 11 ++++++++++- + fs/btrfs/locking.c | 11 +++++++++++ + fs/btrfs/locking.h | 5 +++++ + fs/btrfs/relocation.c | 2 ++ + 7 files changed, 50 insertions(+), 2 deletions(-) + +diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c +index 341ce90d24b15..fb7e331b69756 100644 +--- a/fs/btrfs/ctree.c ++++ b/fs/btrfs/ctree.c +@@ -1938,6 +1938,9 @@ int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root *root, + + if (!p->skip_locking) { + level = btrfs_header_level(b); ++ ++ btrfs_maybe_reset_lockdep_class(root, b); ++ + if (level <= write_lock_level) { + btrfs_tree_lock(b); + p->locks[level] = BTRFS_WRITE_LOCK; +diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h +index cd72570d11f65..319af4c4fffbe 100644 +--- a/fs/btrfs/ctree.h ++++ b/fs/btrfs/ctree.h +@@ -1105,6 +1105,8 @@ enum { + BTRFS_ROOT_QGROUP_FLUSHING, + /* This root has a drop operation that was started previously. */ + BTRFS_ROOT_UNFINISHED_DROP, ++ /* This reloc root needs to have its buffers lockdep class reset. */ ++ BTRFS_ROOT_RESET_LOCKDEP_CLASS, + }; + + static inline void btrfs_wake_unfinished_drop(struct btrfs_fs_info *fs_info) +diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c +index 248ea15c97346..c71f6480d4d4c 100644 +--- a/fs/btrfs/extent-tree.c ++++ b/fs/btrfs/extent-tree.c +@@ -4781,6 +4781,7 @@ btrfs_init_new_buffer(struct btrfs_trans_handle *trans, struct btrfs_root *root, + { + struct btrfs_fs_info *fs_info = root->fs_info; + struct extent_buffer *buf; ++ u64 lockdep_owner = owner; + + buf = btrfs_find_create_tree_block(fs_info, bytenr, owner, level); + if (IS_ERR(buf)) +@@ -4799,12 +4800,27 @@ btrfs_init_new_buffer(struct btrfs_trans_handle *trans, struct btrfs_root *root, + return ERR_PTR(-EUCLEAN); + } + ++ /* ++ * The reloc trees are just snapshots, so we need them to appear to be ++ * just like any other fs tree WRT lockdep. ++ * ++ * The exception however is in replace_path() in relocation, where we ++ * hold the lock on the original fs root and then search for the reloc ++ * root. At that point we need to make sure any reloc root buffers are ++ * set to the BTRFS_TREE_RELOC_OBJECTID lockdep class in order to make ++ * lockdep happy. ++ */ ++ if (lockdep_owner == BTRFS_TREE_RELOC_OBJECTID && ++ !test_bit(BTRFS_ROOT_RESET_LOCKDEP_CLASS, &root->state)) ++ lockdep_owner = BTRFS_FS_TREE_OBJECTID; ++ + /* + * This needs to stay, because we could allocate a freed block from an + * old tree into a new tree, so we need to make sure this new block is + * set to the appropriate level and owner. + */ +- btrfs_set_buffer_lockdep_class(owner, buf, level); ++ btrfs_set_buffer_lockdep_class(lockdep_owner, buf, level); ++ + __btrfs_tree_lock(buf, nest); + btrfs_clean_tree_block(buf); + clear_bit(EXTENT_BUFFER_STALE, &buf->bflags); +diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c +index a72a8d4d4a72e..7bd704779a99b 100644 +--- a/fs/btrfs/extent_io.c ++++ b/fs/btrfs/extent_io.c +@@ -6109,6 +6109,7 @@ struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info, + struct extent_buffer *exists = NULL; + struct page *p; + struct address_space *mapping = fs_info->btree_inode->i_mapping; ++ u64 lockdep_owner = owner_root; + int uptodate = 1; + int ret; + +@@ -6143,7 +6144,15 @@ struct extent_buffer *alloc_extent_buffer(struct btrfs_fs_info *fs_info, + eb = __alloc_extent_buffer(fs_info, start, len); + if (!eb) + return ERR_PTR(-ENOMEM); +- btrfs_set_buffer_lockdep_class(owner_root, eb, level); ++ ++ /* ++ * The reloc trees are just snapshots, so we need them to appear to be ++ * just like any other fs tree WRT lockdep. ++ */ ++ if (lockdep_owner == BTRFS_TREE_RELOC_OBJECTID) ++ lockdep_owner = BTRFS_FS_TREE_OBJECTID; ++ ++ btrfs_set_buffer_lockdep_class(lockdep_owner, eb, level); + + num_pages = num_extent_pages(eb); + for (i = 0; i < num_pages; i++, index++) { +diff --git a/fs/btrfs/locking.c b/fs/btrfs/locking.c +index 5747c63929df7..9063072b399bd 100644 +--- a/fs/btrfs/locking.c ++++ b/fs/btrfs/locking.c +@@ -91,6 +91,13 @@ void btrfs_set_buffer_lockdep_class(u64 objectid, struct extent_buffer *eb, int + lockdep_set_class_and_name(&eb->lock, &ks->keys[level], ks->names[level]); + } + ++void btrfs_maybe_reset_lockdep_class(struct btrfs_root *root, struct extent_buffer *eb) ++{ ++ if (test_bit(BTRFS_ROOT_RESET_LOCKDEP_CLASS, &root->state)) ++ btrfs_set_buffer_lockdep_class(root->root_key.objectid, ++ eb, btrfs_header_level(eb)); ++} ++ + #endif + + /* +@@ -244,6 +251,8 @@ struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root) + + while (1) { + eb = btrfs_root_node(root); ++ ++ btrfs_maybe_reset_lockdep_class(root, eb); + btrfs_tree_lock(eb); + if (eb == root->node) + break; +@@ -265,6 +274,8 @@ struct extent_buffer *btrfs_read_lock_root_node(struct btrfs_root *root) + + while (1) { + eb = btrfs_root_node(root); ++ ++ btrfs_maybe_reset_lockdep_class(root, eb); + btrfs_tree_read_lock(eb); + if (eb == root->node) + break; +diff --git a/fs/btrfs/locking.h b/fs/btrfs/locking.h +index 97370ec0cd297..26a2f962c268e 100644 +--- a/fs/btrfs/locking.h ++++ b/fs/btrfs/locking.h +@@ -132,11 +132,16 @@ void btrfs_drew_read_unlock(struct btrfs_drew_lock *lock); + + #ifdef CONFIG_DEBUG_LOCK_ALLOC + void btrfs_set_buffer_lockdep_class(u64 objectid, struct extent_buffer *eb, int level); ++void btrfs_maybe_reset_lockdep_class(struct btrfs_root *root, struct extent_buffer *eb); + #else + static inline void btrfs_set_buffer_lockdep_class(u64 objectid, + struct extent_buffer *eb, int level) + { + } ++static inline void btrfs_maybe_reset_lockdep_class(struct btrfs_root *root, ++ struct extent_buffer *eb) ++{ ++} + #endif + + #endif +diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c +index 673e11fcf3fc9..becf3396d533d 100644 +--- a/fs/btrfs/relocation.c ++++ b/fs/btrfs/relocation.c +@@ -1326,7 +1326,9 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc, + btrfs_release_path(path); + + path->lowest_level = level; ++ set_bit(BTRFS_ROOT_RESET_LOCKDEP_CLASS, &src->state); + ret = btrfs_search_slot(trans, src, &key, path, 0, 1); ++ clear_bit(BTRFS_ROOT_RESET_LOCKDEP_CLASS, &src->state); + path->lowest_level = 0; + if (ret) { + if (ret > 0) +-- +2.35.1 + diff --git a/queue-5.15/btrfs-fix-warning-during-log-replay-when-bumping-ino.patch b/queue-5.15/btrfs-fix-warning-during-log-replay-when-bumping-ino.patch new file mode 100644 index 00000000000..f554938284a --- /dev/null +++ b/queue-5.15/btrfs-fix-warning-during-log-replay-when-bumping-ino.patch @@ -0,0 +1,99 @@ +From 74ce5651401949bf21172a50270715fcde463286 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Mon, 1 Aug 2022 14:57:52 +0100 +Subject: btrfs: fix warning during log replay when bumping inode link count + +From: Filipe Manana + +[ Upstream commit 769030e11847c5412270c0726ff21d3a1f0a3131 ] + +During log replay, at add_link(), we may increment the link count of +another inode that has a reference that conflicts with a new reference +for the inode currently being processed. + +During log replay, at add_link(), we may drop (unlink) a reference from +some inode in the subvolume tree if that reference conflicts with a new +reference found in the log for the inode we are currently processing. + +After the unlink, If the link count has decreased from 1 to 0, then we +increment the link count to prevent the inode from being deleted if it's +evicted by an iput() call, because we may have references to add to that +inode later on (and we will fixup its link count later during log replay). + +However incrementing the link count from 0 to 1 triggers a warning: + + $ cat fs/inode.c + (...) + void inc_nlink(struct inode *inode) + { + if (unlikely(inode->i_nlink == 0)) { + WARN_ON(!(inode->i_state & I_LINKABLE)); + atomic_long_dec(&inode->i_sb->s_remove_count); + } + (...) + +The I_LINKABLE flag is only set when creating an O_TMPFILE file, so it's +never set during log replay. + +Most of the time, the warning isn't triggered even if we dropped the last +reference of the conflicting inode, and this is because: + +1) The conflicting inode was previously marked for fixup, through a call + to link_to_fixup_dir(), which increments the inode's link count; + +2) And the last iput() on the inode has not triggered eviction of the + inode, nor was eviction triggered after the iput(). So at add_link(), + even if we unlink the last reference of the inode, its link count ends + up being 1 and not 0. + +So this means that if eviction is triggered after link_to_fixup_dir() is +called, at add_link() we will read the inode back from the subvolume tree +and have it with a correct link count, matching the number of references +it has on the subvolume tree. So if when we are at add_link() the inode +has exactly one reference only, its link count is 1, and after the unlink +its link count becomes 0. + +So fix this by using set_nlink() instead of inc_nlink(), as the former +accepts a transition from 0 to 1 and it's what we use in other similar +contexts (like at link_to_fixup_dir(). + +Also make add_inode_ref() use set_nlink() instead of inc_nlink() to +bump the link count from 0 to 1. + +The warning is actually harmless, but it may scare users. Josef also ran +into it recently. + +CC: stable@vger.kernel.org # 5.1+ +Signed-off-by: Filipe Manana +Reviewed-by: David Sterba +Signed-off-by: David Sterba +Signed-off-by: Sasha Levin +--- + fs/btrfs/tree-log.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c +index c56a89d224bbb..7272896587302 100644 +--- a/fs/btrfs/tree-log.c ++++ b/fs/btrfs/tree-log.c +@@ -1444,7 +1444,7 @@ static int add_link(struct btrfs_trans_handle *trans, struct btrfs_root *root, + * on the inode will not free it. We will fixup the link count later. + */ + if (other_inode->i_nlink == 0) +- inc_nlink(other_inode); ++ set_nlink(other_inode, 1); + add_link: + ret = btrfs_add_link(trans, BTRFS_I(dir), BTRFS_I(inode), + name, namelen, 0, ref_index); +@@ -1587,7 +1587,7 @@ static noinline int add_inode_ref(struct btrfs_trans_handle *trans, + * free it. We will fixup the link count later. + */ + if (!ret && inode->i_nlink == 0) +- inc_nlink(inode); ++ set_nlink(inode, 1); + } + if (ret < 0) + goto out; +-- +2.35.1 + diff --git a/queue-5.15/btrfs-move-lockdep-class-helpers-to-locking.c.patch b/queue-5.15/btrfs-move-lockdep-class-helpers-to-locking.c.patch new file mode 100644 index 00000000000..97a1cd2d17f --- /dev/null +++ b/queue-5.15/btrfs-move-lockdep-class-helpers-to-locking.c.patch @@ -0,0 +1,248 @@ +From b263b0ab60e33b1403066b6b6294d362655a6e35 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Tue, 26 Jul 2022 16:24:03 -0400 +Subject: btrfs: move lockdep class helpers to locking.c + +From: Josef Bacik + +[ Upstream commit 0a27a0474d146eb79e09ec88bf0d4229f4cfc1b8 ] + +These definitions exist in disk-io.c, which is not related to the +locking. Move this over to locking.h/c where it makes more sense. + +Reviewed-by: Johannes Thumshirn +Signed-off-by: Josef Bacik +Reviewed-by: David Sterba +Signed-off-by: David Sterba +Signed-off-by: Sasha Levin +--- + fs/btrfs/disk-io.c | 82 ---------------------------------------------- + fs/btrfs/disk-io.h | 10 ------ + fs/btrfs/locking.c | 80 ++++++++++++++++++++++++++++++++++++++++++++ + fs/btrfs/locking.h | 9 +++++ + 4 files changed, 89 insertions(+), 92 deletions(-) + +diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c +index 247d7f9ced3b0..c76c360bece59 100644 +--- a/fs/btrfs/disk-io.c ++++ b/fs/btrfs/disk-io.c +@@ -121,88 +121,6 @@ struct async_submit_bio { + blk_status_t status; + }; + +-/* +- * Lockdep class keys for extent_buffer->lock's in this root. For a given +- * eb, the lockdep key is determined by the btrfs_root it belongs to and +- * the level the eb occupies in the tree. +- * +- * Different roots are used for different purposes and may nest inside each +- * other and they require separate keysets. As lockdep keys should be +- * static, assign keysets according to the purpose of the root as indicated +- * by btrfs_root->root_key.objectid. This ensures that all special purpose +- * roots have separate keysets. +- * +- * Lock-nesting across peer nodes is always done with the immediate parent +- * node locked thus preventing deadlock. As lockdep doesn't know this, use +- * subclass to avoid triggering lockdep warning in such cases. +- * +- * The key is set by the readpage_end_io_hook after the buffer has passed +- * csum validation but before the pages are unlocked. It is also set by +- * btrfs_init_new_buffer on freshly allocated blocks. +- * +- * We also add a check to make sure the highest level of the tree is the +- * same as our lockdep setup here. If BTRFS_MAX_LEVEL changes, this code +- * needs update as well. +- */ +-#ifdef CONFIG_DEBUG_LOCK_ALLOC +-# if BTRFS_MAX_LEVEL != 8 +-# error +-# endif +- +-#define DEFINE_LEVEL(stem, level) \ +- .names[level] = "btrfs-" stem "-0" #level, +- +-#define DEFINE_NAME(stem) \ +- DEFINE_LEVEL(stem, 0) \ +- DEFINE_LEVEL(stem, 1) \ +- DEFINE_LEVEL(stem, 2) \ +- DEFINE_LEVEL(stem, 3) \ +- DEFINE_LEVEL(stem, 4) \ +- DEFINE_LEVEL(stem, 5) \ +- DEFINE_LEVEL(stem, 6) \ +- DEFINE_LEVEL(stem, 7) +- +-static struct btrfs_lockdep_keyset { +- u64 id; /* root objectid */ +- /* Longest entry: btrfs-free-space-00 */ +- char names[BTRFS_MAX_LEVEL][20]; +- struct lock_class_key keys[BTRFS_MAX_LEVEL]; +-} btrfs_lockdep_keysets[] = { +- { .id = BTRFS_ROOT_TREE_OBJECTID, DEFINE_NAME("root") }, +- { .id = BTRFS_EXTENT_TREE_OBJECTID, DEFINE_NAME("extent") }, +- { .id = BTRFS_CHUNK_TREE_OBJECTID, DEFINE_NAME("chunk") }, +- { .id = BTRFS_DEV_TREE_OBJECTID, DEFINE_NAME("dev") }, +- { .id = BTRFS_CSUM_TREE_OBJECTID, DEFINE_NAME("csum") }, +- { .id = BTRFS_QUOTA_TREE_OBJECTID, DEFINE_NAME("quota") }, +- { .id = BTRFS_TREE_LOG_OBJECTID, DEFINE_NAME("log") }, +- { .id = BTRFS_TREE_RELOC_OBJECTID, DEFINE_NAME("treloc") }, +- { .id = BTRFS_DATA_RELOC_TREE_OBJECTID, DEFINE_NAME("dreloc") }, +- { .id = BTRFS_UUID_TREE_OBJECTID, DEFINE_NAME("uuid") }, +- { .id = BTRFS_FREE_SPACE_TREE_OBJECTID, DEFINE_NAME("free-space") }, +- { .id = 0, DEFINE_NAME("tree") }, +-}; +- +-#undef DEFINE_LEVEL +-#undef DEFINE_NAME +- +-void btrfs_set_buffer_lockdep_class(u64 objectid, struct extent_buffer *eb, +- int level) +-{ +- struct btrfs_lockdep_keyset *ks; +- +- BUG_ON(level >= ARRAY_SIZE(ks->keys)); +- +- /* find the matching keyset, id 0 is the default entry */ +- for (ks = btrfs_lockdep_keysets; ks->id; ks++) +- if (ks->id == objectid) +- break; +- +- lockdep_set_class_and_name(&eb->lock, +- &ks->keys[level], ks->names[level]); +-} +- +-#endif +- + /* + * Compute the csum of a btree block and store the result to provided buffer. + */ +diff --git a/fs/btrfs/disk-io.h b/fs/btrfs/disk-io.h +index 0e7e9526b6a83..1b8fd3deafc92 100644 +--- a/fs/btrfs/disk-io.h ++++ b/fs/btrfs/disk-io.h +@@ -140,14 +140,4 @@ int btrfs_init_root_free_objectid(struct btrfs_root *root); + int __init btrfs_end_io_wq_init(void); + void __cold btrfs_end_io_wq_exit(void); + +-#ifdef CONFIG_DEBUG_LOCK_ALLOC +-void btrfs_set_buffer_lockdep_class(u64 objectid, +- struct extent_buffer *eb, int level); +-#else +-static inline void btrfs_set_buffer_lockdep_class(u64 objectid, +- struct extent_buffer *eb, int level) +-{ +-} +-#endif +- + #endif +diff --git a/fs/btrfs/locking.c b/fs/btrfs/locking.c +index 33461b4f9c8b5..5747c63929df7 100644 +--- a/fs/btrfs/locking.c ++++ b/fs/btrfs/locking.c +@@ -13,6 +13,86 @@ + #include "extent_io.h" + #include "locking.h" + ++/* ++ * Lockdep class keys for extent_buffer->lock's in this root. For a given ++ * eb, the lockdep key is determined by the btrfs_root it belongs to and ++ * the level the eb occupies in the tree. ++ * ++ * Different roots are used for different purposes and may nest inside each ++ * other and they require separate keysets. As lockdep keys should be ++ * static, assign keysets according to the purpose of the root as indicated ++ * by btrfs_root->root_key.objectid. This ensures that all special purpose ++ * roots have separate keysets. ++ * ++ * Lock-nesting across peer nodes is always done with the immediate parent ++ * node locked thus preventing deadlock. As lockdep doesn't know this, use ++ * subclass to avoid triggering lockdep warning in such cases. ++ * ++ * The key is set by the readpage_end_io_hook after the buffer has passed ++ * csum validation but before the pages are unlocked. It is also set by ++ * btrfs_init_new_buffer on freshly allocated blocks. ++ * ++ * We also add a check to make sure the highest level of the tree is the ++ * same as our lockdep setup here. If BTRFS_MAX_LEVEL changes, this code ++ * needs update as well. ++ */ ++#ifdef CONFIG_DEBUG_LOCK_ALLOC ++#if BTRFS_MAX_LEVEL != 8 ++#error ++#endif ++ ++#define DEFINE_LEVEL(stem, level) \ ++ .names[level] = "btrfs-" stem "-0" #level, ++ ++#define DEFINE_NAME(stem) \ ++ DEFINE_LEVEL(stem, 0) \ ++ DEFINE_LEVEL(stem, 1) \ ++ DEFINE_LEVEL(stem, 2) \ ++ DEFINE_LEVEL(stem, 3) \ ++ DEFINE_LEVEL(stem, 4) \ ++ DEFINE_LEVEL(stem, 5) \ ++ DEFINE_LEVEL(stem, 6) \ ++ DEFINE_LEVEL(stem, 7) ++ ++static struct btrfs_lockdep_keyset { ++ u64 id; /* root objectid */ ++ /* Longest entry: btrfs-free-space-00 */ ++ char names[BTRFS_MAX_LEVEL][20]; ++ struct lock_class_key keys[BTRFS_MAX_LEVEL]; ++} btrfs_lockdep_keysets[] = { ++ { .id = BTRFS_ROOT_TREE_OBJECTID, DEFINE_NAME("root") }, ++ { .id = BTRFS_EXTENT_TREE_OBJECTID, DEFINE_NAME("extent") }, ++ { .id = BTRFS_CHUNK_TREE_OBJECTID, DEFINE_NAME("chunk") }, ++ { .id = BTRFS_DEV_TREE_OBJECTID, DEFINE_NAME("dev") }, ++ { .id = BTRFS_CSUM_TREE_OBJECTID, DEFINE_NAME("csum") }, ++ { .id = BTRFS_QUOTA_TREE_OBJECTID, DEFINE_NAME("quota") }, ++ { .id = BTRFS_TREE_LOG_OBJECTID, DEFINE_NAME("log") }, ++ { .id = BTRFS_TREE_RELOC_OBJECTID, DEFINE_NAME("treloc") }, ++ { .id = BTRFS_DATA_RELOC_TREE_OBJECTID, DEFINE_NAME("dreloc") }, ++ { .id = BTRFS_UUID_TREE_OBJECTID, DEFINE_NAME("uuid") }, ++ { .id = BTRFS_FREE_SPACE_TREE_OBJECTID, DEFINE_NAME("free-space") }, ++ { .id = 0, DEFINE_NAME("tree") }, ++}; ++ ++#undef DEFINE_LEVEL ++#undef DEFINE_NAME ++ ++void btrfs_set_buffer_lockdep_class(u64 objectid, struct extent_buffer *eb, int level) ++{ ++ struct btrfs_lockdep_keyset *ks; ++ ++ BUG_ON(level >= ARRAY_SIZE(ks->keys)); ++ ++ /* Find the matching keyset, id 0 is the default entry */ ++ for (ks = btrfs_lockdep_keysets; ks->id; ks++) ++ if (ks->id == objectid) ++ break; ++ ++ lockdep_set_class_and_name(&eb->lock, &ks->keys[level], ks->names[level]); ++} ++ ++#endif ++ + /* + * Extent buffer locking + * ===================== +diff --git a/fs/btrfs/locking.h b/fs/btrfs/locking.h +index a2e1f1f5c6e34..97370ec0cd297 100644 +--- a/fs/btrfs/locking.h ++++ b/fs/btrfs/locking.h +@@ -130,4 +130,13 @@ void btrfs_drew_write_unlock(struct btrfs_drew_lock *lock); + void btrfs_drew_read_lock(struct btrfs_drew_lock *lock); + void btrfs_drew_read_unlock(struct btrfs_drew_lock *lock); + ++#ifdef CONFIG_DEBUG_LOCK_ALLOC ++void btrfs_set_buffer_lockdep_class(u64 objectid, struct extent_buffer *eb, int level); ++#else ++static inline void btrfs_set_buffer_lockdep_class(u64 objectid, ++ struct extent_buffer *eb, int level) ++{ ++} ++#endif ++ + #endif +-- +2.35.1 + diff --git a/queue-5.15/btrfs-remove-no-longer-needed-logic-for-replaying-di.patch b/queue-5.15/btrfs-remove-no-longer-needed-logic-for-replaying-di.patch new file mode 100644 index 00000000000..6f0733acba7 --- /dev/null +++ b/queue-5.15/btrfs-remove-no-longer-needed-logic-for-replaying-di.patch @@ -0,0 +1,301 @@ +From 4ad7082f475dc3be269391fea513e8a8b2cb94d6 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Mon, 25 Oct 2021 17:31:54 +0100 +Subject: btrfs: remove no longer needed logic for replaying directory deletes + +From: Filipe Manana + +[ Upstream commit ccae4a19c9140a34a0c5f0658812496dd8bbdeaf ] + +Now that we log only dir index keys when logging a directory, we no longer +need to deal with dir item keys in the log replay code for replaying +directory deletes. This is also true for the case when we replay a log +tree created by a kernel that still logs dir items. + +So remove the remaining code of the replay of directory deletes algorithm +that deals with dir item keys. + +Reviewed-by: Josef Bacik +Signed-off-by: Filipe Manana +Signed-off-by: David Sterba +Signed-off-by: Sasha Levin +--- + fs/btrfs/tree-log.c | 158 ++++++++++++++------------------ + include/uapi/linux/btrfs_tree.h | 4 +- + 2 files changed, 72 insertions(+), 90 deletions(-) + +diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c +index 6f51c4d922d48..4ab1bbc344760 100644 +--- a/fs/btrfs/tree-log.c ++++ b/fs/btrfs/tree-log.c +@@ -2197,7 +2197,7 @@ static noinline int replay_one_dir_item(struct btrfs_trans_handle *trans, + */ + static noinline int find_dir_range(struct btrfs_root *root, + struct btrfs_path *path, +- u64 dirid, int key_type, ++ u64 dirid, + u64 *start_ret, u64 *end_ret) + { + struct btrfs_key key; +@@ -2210,7 +2210,7 @@ static noinline int find_dir_range(struct btrfs_root *root, + return 1; + + key.objectid = dirid; +- key.type = key_type; ++ key.type = BTRFS_DIR_LOG_INDEX_KEY; + key.offset = *start_ret; + + ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); +@@ -2224,7 +2224,7 @@ static noinline int find_dir_range(struct btrfs_root *root, + if (ret != 0) + btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]); + +- if (key.type != key_type || key.objectid != dirid) { ++ if (key.type != BTRFS_DIR_LOG_INDEX_KEY || key.objectid != dirid) { + ret = 1; + goto next; + } +@@ -2251,7 +2251,7 @@ static noinline int find_dir_range(struct btrfs_root *root, + + btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]); + +- if (key.type != key_type || key.objectid != dirid) { ++ if (key.type != BTRFS_DIR_LOG_INDEX_KEY || key.objectid != dirid) { + ret = 1; + goto out; + } +@@ -2282,95 +2282,82 @@ static noinline int check_item_in_log(struct btrfs_trans_handle *trans, + int ret; + struct extent_buffer *eb; + int slot; +- u32 item_size; + struct btrfs_dir_item *di; +- struct btrfs_dir_item *log_di; + int name_len; +- unsigned long ptr; +- unsigned long ptr_end; + char *name; +- struct inode *inode; ++ struct inode *inode = NULL; + struct btrfs_key location; + +-again: ++ /* ++ * Currenly we only log dir index keys. Even if we replay a log created ++ * by an older kernel that logged both dir index and dir item keys, all ++ * we need to do is process the dir index keys, we (and our caller) can ++ * safely ignore dir item keys (key type BTRFS_DIR_ITEM_KEY). ++ */ ++ ASSERT(dir_key->type == BTRFS_DIR_INDEX_KEY); ++ + eb = path->nodes[0]; + slot = path->slots[0]; +- item_size = btrfs_item_size_nr(eb, slot); +- ptr = btrfs_item_ptr_offset(eb, slot); +- ptr_end = ptr + item_size; +- while (ptr < ptr_end) { +- di = (struct btrfs_dir_item *)ptr; +- name_len = btrfs_dir_name_len(eb, di); +- name = kmalloc(name_len, GFP_NOFS); +- if (!name) { +- ret = -ENOMEM; +- goto out; +- } +- read_extent_buffer(eb, name, (unsigned long)(di + 1), +- name_len); +- log_di = NULL; +- if (log && dir_key->type == BTRFS_DIR_ITEM_KEY) { +- log_di = btrfs_lookup_dir_item(trans, log, log_path, +- dir_key->objectid, +- name, name_len, 0); +- } else if (log && dir_key->type == BTRFS_DIR_INDEX_KEY) { +- log_di = btrfs_lookup_dir_index_item(trans, log, +- log_path, +- dir_key->objectid, +- dir_key->offset, +- name, name_len, 0); +- } +- if (!log_di) { +- btrfs_dir_item_key_to_cpu(eb, di, &location); +- btrfs_release_path(path); +- btrfs_release_path(log_path); +- inode = read_one_inode(root, location.objectid); +- if (!inode) { +- kfree(name); +- return -EIO; +- } ++ di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item); ++ name_len = btrfs_dir_name_len(eb, di); ++ name = kmalloc(name_len, GFP_NOFS); ++ if (!name) { ++ ret = -ENOMEM; ++ goto out; ++ } + +- ret = link_to_fixup_dir(trans, root, +- path, location.objectid); +- if (ret) { +- kfree(name); +- iput(inode); +- goto out; +- } ++ read_extent_buffer(eb, name, (unsigned long)(di + 1), name_len); + +- inc_nlink(inode); +- ret = btrfs_unlink_inode(trans, BTRFS_I(dir), +- BTRFS_I(inode), name, name_len); +- if (!ret) +- ret = btrfs_run_delayed_items(trans); +- kfree(name); +- iput(inode); +- if (ret) +- goto out; ++ if (log) { ++ struct btrfs_dir_item *log_di; + +- /* there might still be more names under this key +- * check and repeat if required +- */ +- ret = btrfs_search_slot(NULL, root, dir_key, path, +- 0, 0); +- if (ret == 0) +- goto again; ++ log_di = btrfs_lookup_dir_index_item(trans, log, log_path, ++ dir_key->objectid, ++ dir_key->offset, ++ name, name_len, 0); ++ if (IS_ERR(log_di)) { ++ ret = PTR_ERR(log_di); ++ goto out; ++ } else if (log_di) { ++ /* The dentry exists in the log, we have nothing to do. */ + ret = 0; + goto out; +- } else if (IS_ERR(log_di)) { +- kfree(name); +- return PTR_ERR(log_di); + } +- btrfs_release_path(log_path); +- kfree(name); ++ } + +- ptr = (unsigned long)(di + 1); +- ptr += name_len; ++ btrfs_dir_item_key_to_cpu(eb, di, &location); ++ btrfs_release_path(path); ++ btrfs_release_path(log_path); ++ inode = read_one_inode(root, location.objectid); ++ if (!inode) { ++ ret = -EIO; ++ goto out; + } +- ret = 0; ++ ++ ret = link_to_fixup_dir(trans, root, path, location.objectid); ++ if (ret) ++ goto out; ++ ++ inc_nlink(inode); ++ ret = btrfs_unlink_inode(trans, BTRFS_I(dir), BTRFS_I(inode), name, ++ name_len); ++ if (ret) ++ goto out; ++ ++ ret = btrfs_run_delayed_items(trans); ++ if (ret) ++ goto out; ++ ++ /* ++ * Unlike dir item keys, dir index keys can only have one name (entry) in ++ * them, as there are no key collisions since each key has a unique offset ++ * (an index number), so we're done. ++ */ + out: + btrfs_release_path(path); + btrfs_release_path(log_path); ++ kfree(name); ++ iput(inode); + return ret; + } + +@@ -2490,7 +2477,6 @@ static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans, + { + u64 range_start; + u64 range_end; +- int key_type = BTRFS_DIR_LOG_ITEM_KEY; + int ret = 0; + struct btrfs_key dir_key; + struct btrfs_key found_key; +@@ -2498,7 +2484,7 @@ static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans, + struct inode *dir; + + dir_key.objectid = dirid; +- dir_key.type = BTRFS_DIR_ITEM_KEY; ++ dir_key.type = BTRFS_DIR_INDEX_KEY; + log_path = btrfs_alloc_path(); + if (!log_path) + return -ENOMEM; +@@ -2512,14 +2498,14 @@ static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans, + btrfs_free_path(log_path); + return 0; + } +-again: ++ + range_start = 0; + range_end = 0; + while (1) { + if (del_all) + range_end = (u64)-1; + else { +- ret = find_dir_range(log, path, dirid, key_type, ++ ret = find_dir_range(log, path, dirid, + &range_start, &range_end); + if (ret < 0) + goto out; +@@ -2546,8 +2532,10 @@ static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans, + btrfs_item_key_to_cpu(path->nodes[0], &found_key, + path->slots[0]); + if (found_key.objectid != dirid || +- found_key.type != dir_key.type) +- goto next_type; ++ found_key.type != dir_key.type) { ++ ret = 0; ++ goto out; ++ } + + if (found_key.offset > range_end) + break; +@@ -2566,15 +2554,7 @@ static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans, + break; + range_start = range_end + 1; + } +- +-next_type: + ret = 0; +- if (key_type == BTRFS_DIR_LOG_ITEM_KEY) { +- key_type = BTRFS_DIR_LOG_INDEX_KEY; +- dir_key.type = BTRFS_DIR_INDEX_KEY; +- btrfs_release_path(path); +- goto again; +- } + out: + btrfs_release_path(path); + btrfs_free_path(log_path); +diff --git a/include/uapi/linux/btrfs_tree.h b/include/uapi/linux/btrfs_tree.h +index e1c4c732aabac..5416f1f1a77a8 100644 +--- a/include/uapi/linux/btrfs_tree.h ++++ b/include/uapi/linux/btrfs_tree.h +@@ -146,7 +146,9 @@ + + /* + * dir items are the name -> inode pointers in a directory. There is one +- * for every name in a directory. ++ * for every name in a directory. BTRFS_DIR_LOG_ITEM_KEY is no longer used ++ * but it's still defined here for documentation purposes and to help avoid ++ * having its numerical value reused in the future. + */ + #define BTRFS_DIR_LOG_ITEM_KEY 60 + #define BTRFS_DIR_LOG_INDEX_KEY 72 +-- +2.35.1 + diff --git a/queue-5.15/btrfs-remove-root-argument-from-btrfs_unlink_inode.patch b/queue-5.15/btrfs-remove-root-argument-from-btrfs_unlink_inode.patch new file mode 100644 index 00000000000..fc259a4cd70 --- /dev/null +++ b/queue-5.15/btrfs-remove-root-argument-from-btrfs_unlink_inode.patch @@ -0,0 +1,229 @@ +From af630617cfd076c70818d3e0e9456d226c211298 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Mon, 25 Oct 2021 17:31:50 +0100 +Subject: btrfs: remove root argument from btrfs_unlink_inode() + +From: Filipe Manana + +[ Upstream commit 4467af8809299c12529b5c21481c1d44a3b209f9 ] + +The root argument passed to btrfs_unlink_inode() and its callee, +__btrfs_unlink_inode(), always matches the root of the given directory and +the given inode. So remove the argument and make __btrfs_unlink_inode() +use the root of the directory. + +Signed-off-by: Filipe Manana +Reviewed-by: David Sterba +Signed-off-by: David Sterba +Signed-off-by: Sasha Levin +--- + fs/btrfs/ctree.h | 1 - + fs/btrfs/inode.c | 25 +++++++++++-------------- + fs/btrfs/tree-log.c | 14 +++++++------- + 3 files changed, 18 insertions(+), 22 deletions(-) + +diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h +index 1831135fef1ab..cd72570d11f65 100644 +--- a/fs/btrfs/ctree.h ++++ b/fs/btrfs/ctree.h +@@ -3166,7 +3166,6 @@ void __btrfs_del_delalloc_inode(struct btrfs_root *root, + struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry); + int btrfs_set_inode_index(struct btrfs_inode *dir, u64 *index); + int btrfs_unlink_inode(struct btrfs_trans_handle *trans, +- struct btrfs_root *root, + struct btrfs_inode *dir, struct btrfs_inode *inode, + const char *name, int name_len); + int btrfs_add_link(struct btrfs_trans_handle *trans, +diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c +index 428a56f248bba..f8a01964a2169 100644 +--- a/fs/btrfs/inode.c ++++ b/fs/btrfs/inode.c +@@ -4097,11 +4097,11 @@ int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans, + * also drops the back refs in the inode to the directory + */ + static int __btrfs_unlink_inode(struct btrfs_trans_handle *trans, +- struct btrfs_root *root, + struct btrfs_inode *dir, + struct btrfs_inode *inode, + const char *name, int name_len) + { ++ struct btrfs_root *root = dir->root; + struct btrfs_fs_info *fs_info = root->fs_info; + struct btrfs_path *path; + int ret = 0; +@@ -4201,15 +4201,14 @@ static int __btrfs_unlink_inode(struct btrfs_trans_handle *trans, + } + + int btrfs_unlink_inode(struct btrfs_trans_handle *trans, +- struct btrfs_root *root, + struct btrfs_inode *dir, struct btrfs_inode *inode, + const char *name, int name_len) + { + int ret; +- ret = __btrfs_unlink_inode(trans, root, dir, inode, name, name_len); ++ ret = __btrfs_unlink_inode(trans, dir, inode, name, name_len); + if (!ret) { + drop_nlink(&inode->vfs_inode); +- ret = btrfs_update_inode(trans, root, inode); ++ ret = btrfs_update_inode(trans, inode->root, inode); + } + return ret; + } +@@ -4238,7 +4237,6 @@ static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir) + + static int btrfs_unlink(struct inode *dir, struct dentry *dentry) + { +- struct btrfs_root *root = BTRFS_I(dir)->root; + struct btrfs_trans_handle *trans; + struct inode *inode = d_inode(dentry); + int ret; +@@ -4250,7 +4248,7 @@ static int btrfs_unlink(struct inode *dir, struct dentry *dentry) + btrfs_record_unlink_dir(trans, BTRFS_I(dir), BTRFS_I(d_inode(dentry)), + 0); + +- ret = btrfs_unlink_inode(trans, root, BTRFS_I(dir), ++ ret = btrfs_unlink_inode(trans, BTRFS_I(dir), + BTRFS_I(d_inode(dentry)), dentry->d_name.name, + dentry->d_name.len); + if (ret) +@@ -4264,7 +4262,7 @@ static int btrfs_unlink(struct inode *dir, struct dentry *dentry) + + out: + btrfs_end_transaction(trans); +- btrfs_btree_balance_dirty(root->fs_info); ++ btrfs_btree_balance_dirty(BTRFS_I(dir)->root->fs_info); + return ret; + } + +@@ -4622,7 +4620,6 @@ static int btrfs_rmdir(struct inode *dir, struct dentry *dentry) + { + struct inode *inode = d_inode(dentry); + int err = 0; +- struct btrfs_root *root = BTRFS_I(dir)->root; + struct btrfs_trans_handle *trans; + u64 last_unlink_trans; + +@@ -4647,7 +4644,7 @@ static int btrfs_rmdir(struct inode *dir, struct dentry *dentry) + last_unlink_trans = BTRFS_I(inode)->last_unlink_trans; + + /* now the directory is empty */ +- err = btrfs_unlink_inode(trans, root, BTRFS_I(dir), ++ err = btrfs_unlink_inode(trans, BTRFS_I(dir), + BTRFS_I(d_inode(dentry)), dentry->d_name.name, + dentry->d_name.len); + if (!err) { +@@ -4668,7 +4665,7 @@ static int btrfs_rmdir(struct inode *dir, struct dentry *dentry) + } + out: + btrfs_end_transaction(trans); +- btrfs_btree_balance_dirty(root->fs_info); ++ btrfs_btree_balance_dirty(BTRFS_I(dir)->root->fs_info); + + return err; + } +@@ -9571,7 +9568,7 @@ static int btrfs_rename_exchange(struct inode *old_dir, + if (old_ino == BTRFS_FIRST_FREE_OBJECTID) { + ret = btrfs_unlink_subvol(trans, old_dir, old_dentry); + } else { /* src is an inode */ +- ret = __btrfs_unlink_inode(trans, root, BTRFS_I(old_dir), ++ ret = __btrfs_unlink_inode(trans, BTRFS_I(old_dir), + BTRFS_I(old_dentry->d_inode), + old_dentry->d_name.name, + old_dentry->d_name.len); +@@ -9587,7 +9584,7 @@ static int btrfs_rename_exchange(struct inode *old_dir, + if (new_ino == BTRFS_FIRST_FREE_OBJECTID) { + ret = btrfs_unlink_subvol(trans, new_dir, new_dentry); + } else { /* dest is an inode */ +- ret = __btrfs_unlink_inode(trans, dest, BTRFS_I(new_dir), ++ ret = __btrfs_unlink_inode(trans, BTRFS_I(new_dir), + BTRFS_I(new_dentry->d_inode), + new_dentry->d_name.name, + new_dentry->d_name.len); +@@ -9862,7 +9859,7 @@ static int btrfs_rename(struct user_namespace *mnt_userns, + */ + btrfs_pin_log_trans(root); + log_pinned = true; +- ret = __btrfs_unlink_inode(trans, root, BTRFS_I(old_dir), ++ ret = __btrfs_unlink_inode(trans, BTRFS_I(old_dir), + BTRFS_I(d_inode(old_dentry)), + old_dentry->d_name.name, + old_dentry->d_name.len); +@@ -9882,7 +9879,7 @@ static int btrfs_rename(struct user_namespace *mnt_userns, + ret = btrfs_unlink_subvol(trans, new_dir, new_dentry); + BUG_ON(new_inode->i_nlink == 0); + } else { +- ret = btrfs_unlink_inode(trans, dest, BTRFS_I(new_dir), ++ ret = btrfs_unlink_inode(trans, BTRFS_I(new_dir), + BTRFS_I(d_inode(new_dentry)), + new_dentry->d_name.name, + new_dentry->d_name.len); +diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c +index 1d7e9812f55e1..6f51c4d922d48 100644 +--- a/fs/btrfs/tree-log.c ++++ b/fs/btrfs/tree-log.c +@@ -926,7 +926,7 @@ static noinline int drop_one_dir_item(struct btrfs_trans_handle *trans, + if (ret) + goto out; + +- ret = btrfs_unlink_inode(trans, root, dir, BTRFS_I(inode), name, ++ ret = btrfs_unlink_inode(trans, dir, BTRFS_I(inode), name, + name_len); + if (ret) + goto out; +@@ -1091,7 +1091,7 @@ static inline int __add_inode_ref(struct btrfs_trans_handle *trans, + inc_nlink(&inode->vfs_inode); + btrfs_release_path(path); + +- ret = btrfs_unlink_inode(trans, root, dir, inode, ++ ret = btrfs_unlink_inode(trans, dir, inode, + victim_name, victim_name_len); + kfree(victim_name); + if (ret) +@@ -1165,7 +1165,7 @@ static inline int __add_inode_ref(struct btrfs_trans_handle *trans, + inc_nlink(&inode->vfs_inode); + btrfs_release_path(path); + +- ret = btrfs_unlink_inode(trans, root, ++ ret = btrfs_unlink_inode(trans, + BTRFS_I(victim_parent), + inode, + victim_name, +@@ -1327,7 +1327,7 @@ static int unlink_old_inode_refs(struct btrfs_trans_handle *trans, + kfree(name); + goto out; + } +- ret = btrfs_unlink_inode(trans, root, BTRFS_I(dir), ++ ret = btrfs_unlink_inode(trans, BTRFS_I(dir), + inode, name, namelen); + kfree(name); + iput(dir); +@@ -1434,7 +1434,7 @@ static int add_link(struct btrfs_trans_handle *trans, struct btrfs_root *root, + ret = -ENOENT; + goto out; + } +- ret = btrfs_unlink_inode(trans, root, BTRFS_I(dir), BTRFS_I(other_inode), ++ ret = btrfs_unlink_inode(trans, BTRFS_I(dir), BTRFS_I(other_inode), + name, namelen); + if (ret) + goto out; +@@ -1580,7 +1580,7 @@ static noinline int add_inode_ref(struct btrfs_trans_handle *trans, + ret = btrfs_inode_ref_exists(inode, dir, key->type, + name, namelen); + if (ret > 0) { +- ret = btrfs_unlink_inode(trans, root, ++ ret = btrfs_unlink_inode(trans, + BTRFS_I(dir), + BTRFS_I(inode), + name, namelen); +@@ -2339,7 +2339,7 @@ static noinline int check_item_in_log(struct btrfs_trans_handle *trans, + } + + inc_nlink(inode); +- ret = btrfs_unlink_inode(trans, root, BTRFS_I(dir), ++ ret = btrfs_unlink_inode(trans, BTRFS_I(dir), + BTRFS_I(inode), name, name_len); + if (!ret) + ret = btrfs_run_delayed_items(trans); +-- +2.35.1 + diff --git a/queue-5.15/btrfs-tree-checker-check-for-overlapping-extent-item.patch b/queue-5.15/btrfs-tree-checker-check-for-overlapping-extent-item.patch new file mode 100644 index 00000000000..a8df98c90c4 --- /dev/null +++ b/queue-5.15/btrfs-tree-checker-check-for-overlapping-extent-item.patch @@ -0,0 +1,77 @@ +From abe93dd3e11f7cb8d9fcfd2198f033119a4e0e25 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 3 Aug 2022 14:28:47 -0400 +Subject: btrfs: tree-checker: check for overlapping extent items + +From: Josef Bacik + +[ Upstream commit 899b7f69f244e539ea5df1b4d756046337de44a5 ] + +We're seeing a weird problem in production where we have overlapping +extent items in the extent tree. It's unclear where these are coming +from, and in debugging we realized there's no check in the tree checker +for this sort of problem. Add a check to the tree-checker to make sure +that the extents do not overlap each other. + +Reviewed-by: Qu Wenruo +Signed-off-by: Josef Bacik +Reviewed-by: David Sterba +Signed-off-by: David Sterba +Signed-off-by: Sasha Levin +--- + fs/btrfs/tree-checker.c | 25 +++++++++++++++++++++++-- + 1 file changed, 23 insertions(+), 2 deletions(-) + +diff --git a/fs/btrfs/tree-checker.c b/fs/btrfs/tree-checker.c +index 51382d2be3d44..a84d2d4895104 100644 +--- a/fs/btrfs/tree-checker.c ++++ b/fs/btrfs/tree-checker.c +@@ -1216,7 +1216,8 @@ static void extent_err(const struct extent_buffer *eb, int slot, + } + + static int check_extent_item(struct extent_buffer *leaf, +- struct btrfs_key *key, int slot) ++ struct btrfs_key *key, int slot, ++ struct btrfs_key *prev_key) + { + struct btrfs_fs_info *fs_info = leaf->fs_info; + struct btrfs_extent_item *ei; +@@ -1436,6 +1437,26 @@ static int check_extent_item(struct extent_buffer *leaf, + total_refs, inline_refs); + return -EUCLEAN; + } ++ ++ if ((prev_key->type == BTRFS_EXTENT_ITEM_KEY) || ++ (prev_key->type == BTRFS_METADATA_ITEM_KEY)) { ++ u64 prev_end = prev_key->objectid; ++ ++ if (prev_key->type == BTRFS_METADATA_ITEM_KEY) ++ prev_end += fs_info->nodesize; ++ else ++ prev_end += prev_key->offset; ++ ++ if (unlikely(prev_end > key->objectid)) { ++ extent_err(leaf, slot, ++ "previous extent [%llu %u %llu] overlaps current extent [%llu %u %llu]", ++ prev_key->objectid, prev_key->type, ++ prev_key->offset, key->objectid, key->type, ++ key->offset); ++ return -EUCLEAN; ++ } ++ } ++ + return 0; + } + +@@ -1604,7 +1625,7 @@ static int check_leaf_item(struct extent_buffer *leaf, + break; + case BTRFS_EXTENT_ITEM_KEY: + case BTRFS_METADATA_ITEM_KEY: +- ret = check_extent_item(leaf, key, slot); ++ ret = check_extent_item(leaf, key, slot, prev_key); + break; + case BTRFS_TREE_BLOCK_REF_KEY: + case BTRFS_SHARED_DATA_REF_KEY: +-- +2.35.1 + diff --git a/queue-5.15/drm-amd-display-avoid-doing-vm_init-multiple-time.patch b/queue-5.15/drm-amd-display-avoid-doing-vm_init-multiple-time.patch new file mode 100644 index 00000000000..454f00641c0 --- /dev/null +++ b/queue-5.15/drm-amd-display-avoid-doing-vm_init-multiple-time.patch @@ -0,0 +1,47 @@ +From 19e18a471eb6645dae26bf4a1aa57cbbd47b6a4e Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 5 Aug 2022 12:59:47 -0400 +Subject: drm/amd/display: avoid doing vm_init multiple time + +From: Charlene Liu + +[ Upstream commit 5544a7b5a07480192eb5fd3536462faed2c21528 ] + +[why] +this is to ensure that driver will not reprogram hvm_prefetch_req again if +it is done. + +Reviewed-by: Martin Leung +Acked-by: Brian Chang +Signed-off-by: Charlene Liu +Tested-by: Daniel Wheeler +Signed-off-by: Alex Deucher +Signed-off-by: Sasha Levin +--- + drivers/gpu/drm/amd/display/dc/dcn21/dcn21_hubbub.c | 8 +++++++- + 1 file changed, 7 insertions(+), 1 deletion(-) + +diff --git a/drivers/gpu/drm/amd/display/dc/dcn21/dcn21_hubbub.c b/drivers/gpu/drm/amd/display/dc/dcn21/dcn21_hubbub.c +index 36044cb8ec834..1c0f56d8ba8bb 100644 +--- a/drivers/gpu/drm/amd/display/dc/dcn21/dcn21_hubbub.c ++++ b/drivers/gpu/drm/amd/display/dc/dcn21/dcn21_hubbub.c +@@ -67,9 +67,15 @@ static uint32_t convert_and_clamp( + void dcn21_dchvm_init(struct hubbub *hubbub) + { + struct dcn20_hubbub *hubbub1 = TO_DCN20_HUBBUB(hubbub); +- uint32_t riommu_active; ++ uint32_t riommu_active, prefetch_done; + int i; + ++ REG_GET(DCHVM_RIOMMU_STAT0, HOSTVM_PREFETCH_DONE, &prefetch_done); ++ ++ if (prefetch_done) { ++ hubbub->riommu_active = true; ++ return; ++ } + //Init DCHVM block + REG_UPDATE(DCHVM_CTRL0, HOSTVM_INIT_REQ, 1); + +-- +2.35.1 + diff --git a/queue-5.15/drm-amd-display-avoid-mpc-infinite-loop.patch b/queue-5.15/drm-amd-display-avoid-mpc-infinite-loop.patch new file mode 100644 index 00000000000..db0e1207aa6 --- /dev/null +++ b/queue-5.15/drm-amd-display-avoid-mpc-infinite-loop.patch @@ -0,0 +1,66 @@ +From 5472712d2e13fec91ffa771fce65c37ec36feb75 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Thu, 21 Jul 2022 15:33:00 -0400 +Subject: drm/amd/display: Avoid MPC infinite loop + +From: Josip Pavic + +[ Upstream commit 8de297dc046c180651c0500f8611663ae1c3828a ] + +[why] +In some cases MPC tree bottom pipe ends up point to itself. This causes +iterating from top to bottom to hang the system in an infinite loop. + +[how] +When looping to next MPC bottom pipe, check that the pointer is not same +as current to avoid infinite loop. + +Reviewed-by: Josip Pavic +Reviewed-by: Jun Lei +Acked-by: Alex Hung +Signed-off-by: Aric Cyr +Tested-by: Daniel Wheeler +Signed-off-by: Alex Deucher +Signed-off-by: Sasha Levin +--- + drivers/gpu/drm/amd/display/dc/dcn10/dcn10_mpc.c | 6 ++++++ + drivers/gpu/drm/amd/display/dc/dcn20/dcn20_mpc.c | 6 ++++++ + 2 files changed, 12 insertions(+) + +diff --git a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_mpc.c b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_mpc.c +index 11019c2c62ccb..8192f1967e924 100644 +--- a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_mpc.c ++++ b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_mpc.c +@@ -126,6 +126,12 @@ struct mpcc *mpc1_get_mpcc_for_dpp(struct mpc_tree *tree, int dpp_id) + while (tmp_mpcc != NULL) { + if (tmp_mpcc->dpp_id == dpp_id) + return tmp_mpcc; ++ ++ /* avoid circular linked list */ ++ ASSERT(tmp_mpcc != tmp_mpcc->mpcc_bot); ++ if (tmp_mpcc == tmp_mpcc->mpcc_bot) ++ break; ++ + tmp_mpcc = tmp_mpcc->mpcc_bot; + } + return NULL; +diff --git a/drivers/gpu/drm/amd/display/dc/dcn20/dcn20_mpc.c b/drivers/gpu/drm/amd/display/dc/dcn20/dcn20_mpc.c +index 947eb0df3f125..142fc0a3a536c 100644 +--- a/drivers/gpu/drm/amd/display/dc/dcn20/dcn20_mpc.c ++++ b/drivers/gpu/drm/amd/display/dc/dcn20/dcn20_mpc.c +@@ -532,6 +532,12 @@ struct mpcc *mpc2_get_mpcc_for_dpp(struct mpc_tree *tree, int dpp_id) + while (tmp_mpcc != NULL) { + if (tmp_mpcc->dpp_id == 0xf || tmp_mpcc->dpp_id == dpp_id) + return tmp_mpcc; ++ ++ /* avoid circular linked list */ ++ ASSERT(tmp_mpcc != tmp_mpcc->mpcc_bot); ++ if (tmp_mpcc == tmp_mpcc->mpcc_bot) ++ break; ++ + tmp_mpcc = tmp_mpcc->mpcc_bot; + } + return NULL; +-- +2.35.1 + diff --git a/queue-5.15/drm-amd-display-clear-optc-underflow-before-turn-off.patch b/queue-5.15/drm-amd-display-clear-optc-underflow-before-turn-off.patch new file mode 100644 index 00000000000..948566b715e --- /dev/null +++ b/queue-5.15/drm-amd-display-clear-optc-underflow-before-turn-off.patch @@ -0,0 +1,45 @@ +From 089d2a1db21fe5c79c4cd071d12d9c4209398bd6 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 27 Jul 2022 12:01:29 +0800 +Subject: drm/amd/display: clear optc underflow before turn off odm clock + +From: Fudong Wang + +[ Upstream commit b2a93490201300a749ad261b5c5d05cb50179c44 ] + +[Why] +After ODM clock off, optc underflow bit will be kept there always and clear not work. +We need to clear that before clock off. + +[How] +Clear that if have when clock off. + +Reviewed-by: Alvin Lee +Acked-by: Tom Chung +Signed-off-by: Fudong Wang +Tested-by: Daniel Wheeler +Signed-off-by: Alex Deucher +Signed-off-by: Sasha Levin +--- + drivers/gpu/drm/amd/display/dc/dcn10/dcn10_optc.c | 5 +++++ + 1 file changed, 5 insertions(+) + +diff --git a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_optc.c b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_optc.c +index 37848f4577b18..92fee47278e5a 100644 +--- a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_optc.c ++++ b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_optc.c +@@ -480,6 +480,11 @@ void optc1_enable_optc_clock(struct timing_generator *optc, bool enable) + OTG_CLOCK_ON, 1, + 1, 1000); + } else { ++ ++ //last chance to clear underflow, otherwise, it will always there due to clock is off. ++ if (optc->funcs->is_optc_underflow_occurred(optc) == true) ++ optc->funcs->clear_optc_underflow(optc); ++ + REG_UPDATE_2(OTG_CLOCK_CONTROL, + OTG_CLOCK_GATE_DIS, 0, + OTG_CLOCK_EN, 0); +-- +2.35.1 + diff --git a/queue-5.15/drm-amd-display-fix-hdmi-vsif-v3-incorrect-issue.patch b/queue-5.15/drm-amd-display-fix-hdmi-vsif-v3-incorrect-issue.patch new file mode 100644 index 00000000000..edb38eba91b --- /dev/null +++ b/queue-5.15/drm-amd-display-fix-hdmi-vsif-v3-incorrect-issue.patch @@ -0,0 +1,77 @@ +From b21163f51ed81da870693b2604af4135f76970c3 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 22 Jul 2022 13:42:58 -0400 +Subject: drm/amd/display: Fix HDMI VSIF V3 incorrect issue + +From: Leo Ma + +[ Upstream commit 0591183699fceeafb4c4141072d47775de83ecfb ] + +[Why] +Reported from customer the checksum in AMD VSIF V3 is incorrect and +causing blank screen issue. + +[How] +Fix the packet length issue on AMD HDMI VSIF V3. + +Reviewed-by: Anthony Koo +Acked-by: Tom Chung +Signed-off-by: Leo Ma +Tested-by: Daniel Wheeler +Signed-off-by: Alex Deucher +Signed-off-by: Sasha Levin +--- + .../drm/amd/display/modules/freesync/freesync.c | 15 +++------------ + 1 file changed, 3 insertions(+), 12 deletions(-) + +diff --git a/drivers/gpu/drm/amd/display/modules/freesync/freesync.c b/drivers/gpu/drm/amd/display/modules/freesync/freesync.c +index b99aa232bd8b1..4bee6d018bfa9 100644 +--- a/drivers/gpu/drm/amd/display/modules/freesync/freesync.c ++++ b/drivers/gpu/drm/amd/display/modules/freesync/freesync.c +@@ -567,10 +567,6 @@ static void build_vrr_infopacket_data_v1(const struct mod_vrr_params *vrr, + * Note: We should never go above the field rate of the mode timing set. + */ + infopacket->sb[8] = (unsigned char)((vrr->max_refresh_in_uhz + 500000) / 1000000); +- +- /* FreeSync HDR */ +- infopacket->sb[9] = 0; +- infopacket->sb[10] = 0; + } + + static void build_vrr_infopacket_data_v3(const struct mod_vrr_params *vrr, +@@ -638,10 +634,6 @@ static void build_vrr_infopacket_data_v3(const struct mod_vrr_params *vrr, + + /* PB16 : Reserved bits 7:1, FixedRate bit 0 */ + infopacket->sb[16] = (vrr->state == VRR_STATE_ACTIVE_FIXED) ? 1 : 0; +- +- //FreeSync HDR +- infopacket->sb[9] = 0; +- infopacket->sb[10] = 0; + } + + static void build_vrr_infopacket_fs2_data(enum color_transfer_func app_tf, +@@ -726,8 +718,7 @@ static void build_vrr_infopacket_header_v2(enum signal_type signal, + /* HB2 = [Bits 7:5 = 0] [Bits 4:0 = Length = 0x09] */ + infopacket->hb2 = 0x09; + +- *payload_size = 0x0A; +- ++ *payload_size = 0x09; + } else if (dc_is_dp_signal(signal)) { + + /* HEADER */ +@@ -776,9 +767,9 @@ static void build_vrr_infopacket_header_v3(enum signal_type signal, + infopacket->hb1 = version; + + /* HB2 = [Bits 7:5 = 0] [Bits 4:0 = Length] */ +- *payload_size = 0x10; +- infopacket->hb2 = *payload_size - 1; //-1 for checksum ++ infopacket->hb2 = 0x10; + ++ *payload_size = 0x10; + } else if (dc_is_dp_signal(signal)) { + + /* HEADER */ +-- +2.35.1 + diff --git a/queue-5.15/drm-amd-display-fix-pixel-clock-programming.patch b/queue-5.15/drm-amd-display-fix-pixel-clock-programming.patch new file mode 100644 index 00000000000..876b79dbc62 --- /dev/null +++ b/queue-5.15/drm-amd-display-fix-pixel-clock-programming.patch @@ -0,0 +1,50 @@ +From b832a4494463be6abd66a1ceb266cc64f109fbbd Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Tue, 26 Jul 2022 16:19:38 -0400 +Subject: drm/amd/display: Fix pixel clock programming + +From: Ilya Bakoulin + +[ Upstream commit 04fb918bf421b299feaee1006e82921d7d381f18 ] + +[Why] +Some pixel clock values could cause HDMI TMDS SSCPs to be misaligned +between different HDMI lanes when using YCbCr420 10-bit pixel format. + +BIOS functions for transmitter/encoder control take pixel clock in kHz +increments, whereas the function for setting the pixel clock is in 100Hz +increments. Setting pixel clock to a value that is not on a kHz boundary +will cause the issue. + +[How] +Round pixel clock down to nearest kHz in 10/12-bpc cases. + +Reviewed-by: Aric Cyr +Acked-by: Brian Chang +Signed-off-by: Ilya Bakoulin +Tested-by: Daniel Wheeler +Signed-off-by: Alex Deucher +Signed-off-by: Sasha Levin +--- + drivers/gpu/drm/amd/display/dc/dce/dce_clock_source.c | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/drivers/gpu/drm/amd/display/dc/dce/dce_clock_source.c b/drivers/gpu/drm/amd/display/dc/dce/dce_clock_source.c +index 054823d12403d..5f1b735da5063 100644 +--- a/drivers/gpu/drm/amd/display/dc/dce/dce_clock_source.c ++++ b/drivers/gpu/drm/amd/display/dc/dce/dce_clock_source.c +@@ -545,9 +545,11 @@ static void dce112_get_pix_clk_dividers_helper ( + switch (pix_clk_params->color_depth) { + case COLOR_DEPTH_101010: + actual_pixel_clock_100hz = (actual_pixel_clock_100hz * 5) >> 2; ++ actual_pixel_clock_100hz -= actual_pixel_clock_100hz % 10; + break; + case COLOR_DEPTH_121212: + actual_pixel_clock_100hz = (actual_pixel_clock_100hz * 6) >> 2; ++ actual_pixel_clock_100hz -= actual_pixel_clock_100hz % 10; + break; + case COLOR_DEPTH_161616: + actual_pixel_clock_100hz = actual_pixel_clock_100hz * 2; +-- +2.35.1 + diff --git a/queue-5.15/drm-amd-display-for-stereo-keep-flip_any_frame.patch b/queue-5.15/drm-amd-display-for-stereo-keep-flip_any_frame.patch new file mode 100644 index 00000000000..0eb38d8f711 --- /dev/null +++ b/queue-5.15/drm-amd-display-for-stereo-keep-flip_any_frame.patch @@ -0,0 +1,40 @@ +From ab65e3d56b640d5506a94c63ae47ea3c5552247b Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Thu, 28 Jul 2022 09:51:05 -0400 +Subject: drm/amd/display: For stereo keep "FLIP_ANY_FRAME" + +From: Alvin Lee + +[ Upstream commit 84ef99c728079dfd21d6bc70b4c3e4af20602b3c ] + +[Description] +Observed in stereomode that programming FLIP_LEFT_EYE +can cause hangs. Keep FLIP_ANY_FRAME in stereo mode so +the surface flip can take place before left or right eye + +Reviewed-by: Martin Leung +Acked-by: Tom Chung +Signed-off-by: Alvin Lee +Tested-by: Daniel Wheeler +Signed-off-by: Alex Deucher +Signed-off-by: Sasha Levin +--- + drivers/gpu/drm/amd/display/dc/dcn30/dcn30_hubp.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/drivers/gpu/drm/amd/display/dc/dcn30/dcn30_hubp.c b/drivers/gpu/drm/amd/display/dc/dcn30/dcn30_hubp.c +index f246125232482..33c2337c4edf3 100644 +--- a/drivers/gpu/drm/amd/display/dc/dcn30/dcn30_hubp.c ++++ b/drivers/gpu/drm/amd/display/dc/dcn30/dcn30_hubp.c +@@ -86,7 +86,7 @@ bool hubp3_program_surface_flip_and_addr( + VMID, address->vmid); + + if (address->type == PLN_ADDR_TYPE_GRPH_STEREO) { +- REG_UPDATE(DCSURF_FLIP_CONTROL, SURFACE_FLIP_MODE_FOR_STEREOSYNC, 0x1); ++ REG_UPDATE(DCSURF_FLIP_CONTROL, SURFACE_FLIP_MODE_FOR_STEREOSYNC, 0); + REG_UPDATE(DCSURF_FLIP_CONTROL, SURFACE_FLIP_IN_STEREOSYNC, 0x1); + + } else { +-- +2.35.1 + diff --git a/queue-5.15/drm-amd-pm-add-missing-fini_microcode-interface-for-.patch b/queue-5.15/drm-amd-pm-add-missing-fini_microcode-interface-for-.patch new file mode 100644 index 00000000000..c7d535f8741 --- /dev/null +++ b/queue-5.15/drm-amd-pm-add-missing-fini_microcode-interface-for-.patch @@ -0,0 +1,34 @@ +From 36616a1b18bef7c3c51385d8c661ef654747ec1d Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 10 Aug 2022 11:08:31 +0800 +Subject: drm/amd/pm: add missing ->fini_microcode interface for Sienna Cichlid + +From: Evan Quan + +[ Upstream commit 0a2d922a5618377cdf8fa476351362733ef55342 ] + +To avoid any potential memory leak. + +Signed-off-by: Evan Quan +Reviewed-by: Alex Deucher +Signed-off-by: Alex Deucher +Signed-off-by: Sasha Levin +--- + drivers/gpu/drm/amd/pm/swsmu/smu11/sienna_cichlid_ppt.c | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/drivers/gpu/drm/amd/pm/swsmu/smu11/sienna_cichlid_ppt.c b/drivers/gpu/drm/amd/pm/swsmu/smu11/sienna_cichlid_ppt.c +index 918d5c7c2328b..79976921dc46f 100644 +--- a/drivers/gpu/drm/amd/pm/swsmu/smu11/sienna_cichlid_ppt.c ++++ b/drivers/gpu/drm/amd/pm/swsmu/smu11/sienna_cichlid_ppt.c +@@ -3915,6 +3915,7 @@ static const struct pptable_funcs sienna_cichlid_ppt_funcs = { + .dump_pptable = sienna_cichlid_dump_pptable, + .init_microcode = smu_v11_0_init_microcode, + .load_microcode = smu_v11_0_load_microcode, ++ .fini_microcode = smu_v11_0_fini_microcode, + .init_smc_tables = sienna_cichlid_init_smc_tables, + .fini_smc_tables = smu_v11_0_fini_smc_tables, + .init_power = smu_v11_0_init_power, +-- +2.35.1 + diff --git a/queue-5.15/drm-amdgpu-increase-tlb-flush-timeout-for-sriov.patch b/queue-5.15/drm-amdgpu-increase-tlb-flush-timeout-for-sriov.patch new file mode 100644 index 00000000000..6431248ac8c --- /dev/null +++ b/queue-5.15/drm-amdgpu-increase-tlb-flush-timeout-for-sriov.patch @@ -0,0 +1,87 @@ +From b147bc60a5ca450806943ce77d307e6910993899 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 10 Aug 2022 09:43:15 +0200 +Subject: drm/amdgpu: Increase tlb flush timeout for sriov + +From: Dusica Milinkovic + +[ Upstream commit 373008bfc9cdb0f050258947fa5a095f0657e1bc ] + +[Why] +During multi-vf executing benchmark (Luxmark) observed kiq error timeout. +It happenes because all of VFs do the tlb invalidation at the same time. +Although each VF has the invalidate register set, from hardware side +the invalidate requests are queue to execute. + +[How] +In case of 12 VF increase timeout on 12*100ms + +Signed-off-by: Dusica Milinkovic +Acked-by: Shaoyun Liu +Acked-by: Alex Deucher +Signed-off-by: Alex Deucher +Signed-off-by: Sasha Levin +--- + drivers/gpu/drm/amd/amdgpu/amdgpu.h | 2 +- + drivers/gpu/drm/amd/amdgpu/gmc_v10_0.c | 3 ++- + drivers/gpu/drm/amd/amdgpu/gmc_v9_0.c | 3 ++- + 3 files changed, 5 insertions(+), 3 deletions(-) + +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu.h b/drivers/gpu/drm/amd/amdgpu/amdgpu.h +index 5f95d03fd46a0..4f62f422bcb78 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu.h ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu.h +@@ -312,7 +312,7 @@ enum amdgpu_kiq_irq { + AMDGPU_CP_KIQ_IRQ_DRIVER0 = 0, + AMDGPU_CP_KIQ_IRQ_LAST + }; +- ++#define SRIOV_USEC_TIMEOUT 1200000 /* wait 12 * 100ms for SRIOV */ + #define MAX_KIQ_REG_WAIT 5000 /* in usecs, 5ms */ + #define MAX_KIQ_REG_BAILOUT_INTERVAL 5 /* in msecs, 5ms */ + #define MAX_KIQ_REG_TRY 1000 +diff --git a/drivers/gpu/drm/amd/amdgpu/gmc_v10_0.c b/drivers/gpu/drm/amd/amdgpu/gmc_v10_0.c +index 93a4da4284ede..9c07ec8b97327 100644 +--- a/drivers/gpu/drm/amd/amdgpu/gmc_v10_0.c ++++ b/drivers/gpu/drm/amd/amdgpu/gmc_v10_0.c +@@ -414,6 +414,7 @@ static int gmc_v10_0_flush_gpu_tlb_pasid(struct amdgpu_device *adev, + uint32_t seq; + uint16_t queried_pasid; + bool ret; ++ u32 usec_timeout = amdgpu_sriov_vf(adev) ? SRIOV_USEC_TIMEOUT : adev->usec_timeout; + struct amdgpu_ring *ring = &adev->gfx.kiq.ring; + struct amdgpu_kiq *kiq = &adev->gfx.kiq; + +@@ -432,7 +433,7 @@ static int gmc_v10_0_flush_gpu_tlb_pasid(struct amdgpu_device *adev, + + amdgpu_ring_commit(ring); + spin_unlock(&adev->gfx.kiq.ring_lock); +- r = amdgpu_fence_wait_polling(ring, seq, adev->usec_timeout); ++ r = amdgpu_fence_wait_polling(ring, seq, usec_timeout); + if (r < 1) { + dev_err(adev->dev, "wait for kiq fence error: %ld.\n", r); + return -ETIME; +diff --git a/drivers/gpu/drm/amd/amdgpu/gmc_v9_0.c b/drivers/gpu/drm/amd/amdgpu/gmc_v9_0.c +index 0e731016921be..70d24b522df8d 100644 +--- a/drivers/gpu/drm/amd/amdgpu/gmc_v9_0.c ++++ b/drivers/gpu/drm/amd/amdgpu/gmc_v9_0.c +@@ -863,6 +863,7 @@ static int gmc_v9_0_flush_gpu_tlb_pasid(struct amdgpu_device *adev, + uint32_t seq; + uint16_t queried_pasid; + bool ret; ++ u32 usec_timeout = amdgpu_sriov_vf(adev) ? SRIOV_USEC_TIMEOUT : adev->usec_timeout; + struct amdgpu_ring *ring = &adev->gfx.kiq.ring; + struct amdgpu_kiq *kiq = &adev->gfx.kiq; + +@@ -902,7 +903,7 @@ static int gmc_v9_0_flush_gpu_tlb_pasid(struct amdgpu_device *adev, + + amdgpu_ring_commit(ring); + spin_unlock(&adev->gfx.kiq.ring_lock); +- r = amdgpu_fence_wait_polling(ring, seq, adev->usec_timeout); ++ r = amdgpu_fence_wait_polling(ring, seq, usec_timeout); + if (r < 1) { + dev_err(adev->dev, "wait for kiq fence error: %ld.\n", r); + up_read(&adev->reset_sem); +-- +2.35.1 + diff --git a/queue-5.15/drm-i915-gt-skip-tlb-invalidations-once-wedged.patch b/queue-5.15/drm-i915-gt-skip-tlb-invalidations-once-wedged.patch new file mode 100644 index 00000000000..2d645415ba5 --- /dev/null +++ b/queue-5.15/drm-i915-gt-skip-tlb-invalidations-once-wedged.patch @@ -0,0 +1,55 @@ +From 0522830554d7c4391d36bcc64a08e81b3153d129 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 27 Jul 2022 14:29:54 +0200 +Subject: drm/i915/gt: Skip TLB invalidations once wedged +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +From: Chris Wilson + +[ Upstream commit e5a95c83ed1492c0f442b448b20c90c8faaf702b ] + +Skip all further TLB invalidations once the device is wedged and +had been reset, as, on such cases, it can no longer process instructions +on the GPU and the user no longer has access to the TLB's in each engine. + +So, an attempt to do a TLB cache invalidation will produce a timeout. + +That helps to reduce the performance regression introduced by TLB +invalidate logic. + +Cc: stable@vger.kernel.org +Fixes: 7938d61591d3 ("drm/i915: Flush TLBs before releasing backing store") +Signed-off-by: Chris Wilson +Cc: Fei Yang +Cc: Tvrtko Ursulin +Reviewed-by: Andi Shyti +Acked-by: Thomas Hellström +Signed-off-by: Mauro Carvalho Chehab +Signed-off-by: Andi Shyti +Link: https://patchwork.freedesktop.org/patch/msgid/5aa86564b9ec5fe7fe605c1dd7de76855401ed73.1658924372.git.mchehab@kernel.org +(cherry picked from commit be0366f168033374a93e4c43fdaa1a90ab905184) +Signed-off-by: Rodrigo Vivi +Signed-off-by: Sasha Levin +--- + drivers/gpu/drm/i915/gt/intel_gt.c | 3 +++ + 1 file changed, 3 insertions(+) + +diff --git a/drivers/gpu/drm/i915/gt/intel_gt.c b/drivers/gpu/drm/i915/gt/intel_gt.c +index 3a76000d15bfd..ed8ad3b263959 100644 +--- a/drivers/gpu/drm/i915/gt/intel_gt.c ++++ b/drivers/gpu/drm/i915/gt/intel_gt.c +@@ -949,6 +949,9 @@ void intel_gt_invalidate_tlbs(struct intel_gt *gt) + if (I915_SELFTEST_ONLY(gt->awake == -ENODEV)) + return; + ++ if (intel_gt_is_wedged(gt)) ++ return; ++ + if (GRAPHICS_VER(i915) == 12) { + regs = gen12_regs; + num = ARRAY_SIZE(gen12_regs); +-- +2.35.1 + diff --git a/queue-5.15/fs-ntfs3-fix-work-with-fragmented-xattr.patch b/queue-5.15/fs-ntfs3-fix-work-with-fragmented-xattr.patch new file mode 100644 index 00000000000..4067f0b5645 --- /dev/null +++ b/queue-5.15/fs-ntfs3-fix-work-with-fragmented-xattr.patch @@ -0,0 +1,46 @@ +From 2f9b55b46e49b90d3850e1d8a7a88f0170167cdf Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 13 May 2022 19:54:23 +0300 +Subject: fs/ntfs3: Fix work with fragmented xattr + +From: Konstantin Komarov + +[ Upstream commit 42f86b1226a42bfc79a7125af435432ad4680a32 ] + +In some cases xattr is too fragmented, +so we need to load it before writing. + +Signed-off-by: Konstantin Komarov +Signed-off-by: Sasha Levin +--- + fs/ntfs3/xattr.c | 7 ++++++- + 1 file changed, 6 insertions(+), 1 deletion(-) + +diff --git a/fs/ntfs3/xattr.c b/fs/ntfs3/xattr.c +index e8bfa709270d1..4652b97969957 100644 +--- a/fs/ntfs3/xattr.c ++++ b/fs/ntfs3/xattr.c +@@ -118,7 +118,7 @@ static int ntfs_read_ea(struct ntfs_inode *ni, struct EA_FULL **ea, + + run_init(&run); + +- err = attr_load_runs(attr_ea, ni, &run, NULL); ++ err = attr_load_runs_range(ni, ATTR_EA, NULL, 0, &run, 0, size); + if (!err) + err = ntfs_read_run_nb(sbi, &run, 0, ea_p, size, NULL); + run_close(&run); +@@ -443,6 +443,11 @@ static noinline int ntfs_set_ea(struct inode *inode, const char *name, + /* Delete xattr, ATTR_EA */ + ni_remove_attr_le(ni, attr, mi, le); + } else if (attr->non_res) { ++ err = attr_load_runs_range(ni, ATTR_EA, NULL, 0, &ea_run, 0, ++ size); ++ if (err) ++ goto out; ++ + err = ntfs_sb_write_run(sbi, &ea_run, 0, ea_all, size, 0); + if (err) + goto out; +-- +2.35.1 + diff --git a/queue-5.15/ksmbd-don-t-remove-dos-attribute-xattr-on-o_trunc-op.patch b/queue-5.15/ksmbd-don-t-remove-dos-attribute-xattr-on-o_trunc-op.patch new file mode 100644 index 00000000000..1a3e8b1fdca --- /dev/null +++ b/queue-5.15/ksmbd-don-t-remove-dos-attribute-xattr-on-o_trunc-op.patch @@ -0,0 +1,55 @@ +From c669924a327607d4de539fe41366965e97c08235 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Sun, 14 Aug 2022 22:40:25 +0900 +Subject: ksmbd: don't remove dos attribute xattr on O_TRUNC open + +From: Namjae Jeon + +[ Upstream commit 17661ecf6a64eb11ae7f1108fe88686388b2acd5 ] + +When smb client open file in ksmbd share with O_TRUNC, dos attribute +xattr is removed as well as data in file. This cause the FSCTL_SET_SPARSE +request from the client fails because ksmbd can't update the dos attribute +after setting ATTR_SPARSE_FILE. And this patch fix xfstests generic/469 +test also. + +Signed-off-by: Namjae Jeon +Reviewed-by: Hyunchul Lee +Signed-off-by: Steve French +Signed-off-by: Sasha Levin +--- + fs/ksmbd/smb2pdu.c | 18 +++++++++--------- + 1 file changed, 9 insertions(+), 9 deletions(-) + +diff --git a/fs/ksmbd/smb2pdu.c b/fs/ksmbd/smb2pdu.c +index 824f17a101a9e..55ee639703ff0 100644 +--- a/fs/ksmbd/smb2pdu.c ++++ b/fs/ksmbd/smb2pdu.c +@@ -2319,15 +2319,15 @@ static int smb2_remove_smb_xattrs(struct path *path) + name += strlen(name) + 1) { + ksmbd_debug(SMB, "%s, len %zd\n", name, strlen(name)); + +- if (strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) && +- strncmp(&name[XATTR_USER_PREFIX_LEN], DOS_ATTRIBUTE_PREFIX, +- DOS_ATTRIBUTE_PREFIX_LEN) && +- strncmp(&name[XATTR_USER_PREFIX_LEN], STREAM_PREFIX, STREAM_PREFIX_LEN)) +- continue; +- +- err = ksmbd_vfs_remove_xattr(user_ns, path->dentry, name); +- if (err) +- ksmbd_debug(SMB, "remove xattr failed : %s\n", name); ++ if (!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) && ++ !strncmp(&name[XATTR_USER_PREFIX_LEN], STREAM_PREFIX, ++ STREAM_PREFIX_LEN)) { ++ err = ksmbd_vfs_remove_xattr(user_ns, path->dentry, ++ name); ++ if (err) ++ ksmbd_debug(SMB, "remove xattr failed : %s\n", ++ name); ++ } + } + out: + kvfree(xattr_list); +-- +2.35.1 + diff --git a/queue-5.15/ksmbd-return-status_bad_network_name-error-status-if.patch b/queue-5.15/ksmbd-return-status_bad_network_name-error-status-if.patch new file mode 100644 index 00000000000..0a489a23716 --- /dev/null +++ b/queue-5.15/ksmbd-return-status_bad_network_name-error-status-if.patch @@ -0,0 +1,53 @@ +From af90843d00414cd522231424a4184af25d304783 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Mon, 8 Aug 2022 21:56:48 +0900 +Subject: ksmbd: return STATUS_BAD_NETWORK_NAME error status if share is not + configured + +From: Namjae Jeon + +[ Upstream commit fe54833dc8d97ef387e86f7c80537d51c503ca75 ] + +If share is not configured in smb.conf, smb2 tree connect should return +STATUS_BAD_NETWORK_NAME instead of STATUS_BAD_NETWORK_PATH. + +Signed-off-by: Namjae Jeon +Reviewed-by: Hyunchul Lee +Signed-off-by: Steve French +Signed-off-by: Sasha Levin +--- + fs/ksmbd/mgmt/tree_connect.c | 2 +- + fs/ksmbd/smb2pdu.c | 3 ++- + 2 files changed, 3 insertions(+), 2 deletions(-) + +diff --git a/fs/ksmbd/mgmt/tree_connect.c b/fs/ksmbd/mgmt/tree_connect.c +index 0d28e723a28c7..940385c6a9135 100644 +--- a/fs/ksmbd/mgmt/tree_connect.c ++++ b/fs/ksmbd/mgmt/tree_connect.c +@@ -18,7 +18,7 @@ + struct ksmbd_tree_conn_status + ksmbd_tree_conn_connect(struct ksmbd_session *sess, char *share_name) + { +- struct ksmbd_tree_conn_status status = {-EINVAL, NULL}; ++ struct ksmbd_tree_conn_status status = {-ENOENT, NULL}; + struct ksmbd_tree_connect_response *resp = NULL; + struct ksmbd_share_config *sc; + struct ksmbd_tree_connect *tree_conn = NULL; +diff --git a/fs/ksmbd/smb2pdu.c b/fs/ksmbd/smb2pdu.c +index 28b5d20c8766e..824f17a101a9e 100644 +--- a/fs/ksmbd/smb2pdu.c ++++ b/fs/ksmbd/smb2pdu.c +@@ -1932,8 +1932,9 @@ int smb2_tree_connect(struct ksmbd_work *work) + rsp->hdr.Status = STATUS_SUCCESS; + rc = 0; + break; ++ case -ENOENT: + case KSMBD_TREE_CONN_STATUS_NO_SHARE: +- rsp->hdr.Status = STATUS_BAD_NETWORK_PATH; ++ rsp->hdr.Status = STATUS_BAD_NETWORK_NAME; + break; + case -ENOMEM: + case KSMBD_TREE_CONN_STATUS_NOMEM: +-- +2.35.1 + diff --git a/queue-5.15/mmc-mtk-sd-clear-interrupts-when-cqe-off-disable.patch b/queue-5.15/mmc-mtk-sd-clear-interrupts-when-cqe-off-disable.patch new file mode 100644 index 00000000000..2fbda742a48 --- /dev/null +++ b/queue-5.15/mmc-mtk-sd-clear-interrupts-when-cqe-off-disable.patch @@ -0,0 +1,60 @@ +From a262e822c92f2cb8e13f9d10298cd9a76169a9d9 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Thu, 28 Jul 2022 16:00:48 +0800 +Subject: mmc: mtk-sd: Clear interrupts when cqe off/disable + +From: Wenbin Mei + +[ Upstream commit cc5d1692600613e72f32af60e27330fe0c79f4fe ] + +Currently we don't clear MSDC interrupts when cqe off/disable, which led +to the data complete interrupt will be reserved for the next command. +If the next command with data transfer after cqe off/disable, we process +the CMD ready interrupt and trigger DMA start for data, but the data +complete interrupt is already exists, then SW assume that the data transfer +is complete, SW will trigger DMA stop, but the data may not be transmitted +yet or is transmitting, so we may encounter the following error: +mtk-msdc 11230000.mmc: CMD bus busy detected. + +Signed-off-by: Wenbin Mei +Fixes: 88bd652b3c74 ("mmc: mediatek: command queue support") +Cc: stable@vger.kernel.org +Link: https://lore.kernel.org/r/20220728080048.21336-1-wenbin.mei@mediatek.com +Signed-off-by: Ulf Hansson +Signed-off-by: Sasha Levin +--- + drivers/mmc/host/mtk-sd.c | 6 ++++++ + 1 file changed, 6 insertions(+) + +diff --git a/drivers/mmc/host/mtk-sd.c b/drivers/mmc/host/mtk-sd.c +index f9b2897569bb4..99d8881a7d6c2 100644 +--- a/drivers/mmc/host/mtk-sd.c ++++ b/drivers/mmc/host/mtk-sd.c +@@ -2345,6 +2345,9 @@ static void msdc_cqe_disable(struct mmc_host *mmc, bool recovery) + /* disable busy check */ + sdr_clr_bits(host->base + MSDC_PATCH_BIT1, MSDC_PB1_BUSY_CHECK_SEL); + ++ val = readl(host->base + MSDC_INT); ++ writel(val, host->base + MSDC_INT); ++ + if (recovery) { + sdr_set_field(host->base + MSDC_DMA_CTRL, + MSDC_DMA_CTRL_STOP, 1); +@@ -2785,11 +2788,14 @@ static int __maybe_unused msdc_suspend(struct device *dev) + { + struct mmc_host *mmc = dev_get_drvdata(dev); + int ret; ++ u32 val; + + if (mmc->caps2 & MMC_CAP2_CQE) { + ret = cqhci_suspend(mmc); + if (ret) + return ret; ++ val = readl(((struct msdc_host *)mmc_priv(mmc))->base + MSDC_INT); ++ writel(val, ((struct msdc_host *)mmc_priv(mmc))->base + MSDC_INT); + } + + return pm_runtime_force_suspend(dev); +-- +2.35.1 + diff --git a/queue-5.15/mmc-sdhci-of-dwcmshc-add-reset-call-back-for-rockchi.patch b/queue-5.15/mmc-sdhci-of-dwcmshc-add-reset-call-back-for-rockchi.patch new file mode 100644 index 00000000000..60f381d19a9 --- /dev/null +++ b/queue-5.15/mmc-sdhci-of-dwcmshc-add-reset-call-back-for-rockchi.patch @@ -0,0 +1,93 @@ +From ef91e3c1abe13cd66ef79627ae00022bb1c4c335 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 4 May 2022 23:32:39 +0200 +Subject: mmc: sdhci-of-dwcmshc: add reset call back for rockchip Socs + +From: Yifeng Zhao + +[ Upstream commit 70f832206fe72e9998b46363e8e59e89b0b757bc ] + +The reset function build in the SDHCI will not reset the logic +circuit related to the tuning function, which may cause data +reading errors. Resetting the complete SDHCI controller through +the reset controller fixes the issue. + +Signed-off-by: Yifeng Zhao +[rebase, use optional variant of reset getter] +Acked-by: Adrian Hunter +Signed-off-by: Sebastian Reichel +Link: https://lore.kernel.org/r/20220504213251.264819-10-sebastian.reichel@collabora.com +Signed-off-by: Ulf Hansson +Signed-off-by: Sasha Levin +--- + drivers/mmc/host/sdhci-of-dwcmshc.c | 26 +++++++++++++++++++++++++- + 1 file changed, 25 insertions(+), 1 deletion(-) + +diff --git a/drivers/mmc/host/sdhci-of-dwcmshc.c b/drivers/mmc/host/sdhci-of-dwcmshc.c +index bac874ab0b33a..3a1b5ba364051 100644 +--- a/drivers/mmc/host/sdhci-of-dwcmshc.c ++++ b/drivers/mmc/host/sdhci-of-dwcmshc.c +@@ -15,6 +15,7 @@ + #include + #include + #include ++#include + #include + + #include "sdhci-pltfm.h" +@@ -63,6 +64,7 @@ + struct rk3568_priv { + /* Rockchip specified optional clocks */ + struct clk_bulk_data rockchip_clks[RK3568_MAX_CLKS]; ++ struct reset_control *reset; + u8 txclk_tapnum; + }; + +@@ -255,6 +257,21 @@ static void dwcmshc_rk3568_set_clock(struct sdhci_host *host, unsigned int clock + sdhci_writel(host, extra, DWCMSHC_EMMC_DLL_STRBIN); + } + ++static void rk35xx_sdhci_reset(struct sdhci_host *host, u8 mask) ++{ ++ struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); ++ struct dwcmshc_priv *dwc_priv = sdhci_pltfm_priv(pltfm_host); ++ struct rk35xx_priv *priv = dwc_priv->priv; ++ ++ if (mask & SDHCI_RESET_ALL && priv->reset) { ++ reset_control_assert(priv->reset); ++ udelay(1); ++ reset_control_deassert(priv->reset); ++ } ++ ++ sdhci_reset(host, mask); ++} ++ + static const struct sdhci_ops sdhci_dwcmshc_ops = { + .set_clock = sdhci_set_clock, + .set_bus_width = sdhci_set_bus_width, +@@ -269,7 +286,7 @@ static const struct sdhci_ops sdhci_dwcmshc_rk3568_ops = { + .set_bus_width = sdhci_set_bus_width, + .set_uhs_signaling = dwcmshc_set_uhs_signaling, + .get_max_clock = sdhci_pltfm_clk_get_max_clock, +- .reset = sdhci_reset, ++ .reset = rk35xx_sdhci_reset, + .adma_write_desc = dwcmshc_adma_write_desc, + }; + +@@ -292,6 +309,13 @@ static int dwcmshc_rk3568_init(struct sdhci_host *host, struct dwcmshc_priv *dwc + int err; + struct rk3568_priv *priv = dwc_priv->priv; + ++ priv->reset = devm_reset_control_array_get_optional_exclusive(mmc_dev(host->mmc)); ++ if (IS_ERR(priv->reset)) { ++ err = PTR_ERR(priv->reset); ++ dev_err(mmc_dev(host->mmc), "failed to get reset control %d\n", err); ++ return err; ++ } ++ + priv->rockchip_clks[0].id = "axi"; + priv->rockchip_clks[1].id = "block"; + priv->rockchip_clks[2].id = "timer"; +-- +2.35.1 + diff --git a/queue-5.15/mmc-sdhci-of-dwcmshc-re-enable-support-for-the-bluef.patch b/queue-5.15/mmc-sdhci-of-dwcmshc-re-enable-support-for-the-bluef.patch new file mode 100644 index 00000000000..2aa60988c0f --- /dev/null +++ b/queue-5.15/mmc-sdhci-of-dwcmshc-re-enable-support-for-the-bluef.patch @@ -0,0 +1,73 @@ +From 608a9f4d831bdf87b2b9b858107f58a2fcfbd59b Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Tue, 9 Aug 2022 13:37:42 -0400 +Subject: mmc: sdhci-of-dwcmshc: Re-enable support for the BlueField-3 SoC + +From: Liming Sun + +[ Upstream commit a0753ef66c34c1739580219dca664eda648164b7 ] + +The commit 08f3dff799d4 (mmc: sdhci-of-dwcmshc: add rockchip platform +support") introduces the use of_device_get_match_data() to check for some +chips. Unfortunately, it also breaks the BlueField-3 FW, which uses ACPI. + +To fix the problem, let's add the ACPI match data and the corresponding +quirks to re-enable the support for the BlueField-3 SoC. + +Reviewed-by: David Woods +Signed-off-by: Liming Sun +Acked-by: Adrian Hunter +Fixes: 08f3dff799d4 ("mmc: sdhci-of-dwcmshc: add rockchip platform support") +Cc: stable@vger.kernel.org +Link: https://lore.kernel.org/r/20220809173742.178440-1-limings@nvidia.com +[Ulf: Clarified the commit message a bit] +Signed-off-by: Ulf Hansson +Signed-off-by: Sasha Levin +--- + drivers/mmc/host/sdhci-of-dwcmshc.c | 16 ++++++++++++++-- + 1 file changed, 14 insertions(+), 2 deletions(-) + +diff --git a/drivers/mmc/host/sdhci-of-dwcmshc.c b/drivers/mmc/host/sdhci-of-dwcmshc.c +index f5fd88c7adef1..335c88fd849c4 100644 +--- a/drivers/mmc/host/sdhci-of-dwcmshc.c ++++ b/drivers/mmc/host/sdhci-of-dwcmshc.c +@@ -296,6 +296,15 @@ static const struct sdhci_pltfm_data sdhci_dwcmshc_pdata = { + .quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN, + }; + ++#ifdef CONFIG_ACPI ++static const struct sdhci_pltfm_data sdhci_dwcmshc_bf3_pdata = { ++ .ops = &sdhci_dwcmshc_ops, ++ .quirks = SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN, ++ .quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN | ++ SDHCI_QUIRK2_ACMD23_BROKEN, ++}; ++#endif ++ + static const struct sdhci_pltfm_data sdhci_dwcmshc_rk35xx_pdata = { + .ops = &sdhci_dwcmshc_rk35xx_ops, + .quirks = SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN | +@@ -360,7 +369,10 @@ MODULE_DEVICE_TABLE(of, sdhci_dwcmshc_dt_ids); + + #ifdef CONFIG_ACPI + static const struct acpi_device_id sdhci_dwcmshc_acpi_ids[] = { +- { .id = "MLNXBF30" }, ++ { ++ .id = "MLNXBF30", ++ .driver_data = (kernel_ulong_t)&sdhci_dwcmshc_bf3_pdata, ++ }, + {} + }; + #endif +@@ -376,7 +388,7 @@ static int dwcmshc_probe(struct platform_device *pdev) + int err; + u32 extra; + +- pltfm_data = of_device_get_match_data(&pdev->dev); ++ pltfm_data = device_get_match_data(&pdev->dev); + if (!pltfm_data) { + dev_err(&pdev->dev, "Error: No device match data found\n"); + return -ENODEV; +-- +2.35.1 + diff --git a/queue-5.15/mmc-sdhci-of-dwcmshc-rename-rk3568-to-rk35xx.patch b/queue-5.15/mmc-sdhci-of-dwcmshc-rename-rk3568-to-rk35xx.patch new file mode 100644 index 00000000000..e3fc5b345eb --- /dev/null +++ b/queue-5.15/mmc-sdhci-of-dwcmshc-rename-rk3568-to-rk35xx.patch @@ -0,0 +1,204 @@ +From 0f99a3e6ce68043123c35121379f3019fc8b7df0 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 4 May 2022 23:32:40 +0200 +Subject: mmc: sdhci-of-dwcmshc: rename rk3568 to rk35xx + +From: Sebastian Reichel + +[ Upstream commit 86e1a8e1f9b555af342c53ae06284eeeab9a4263 ] + +Prepare driver for rk3588 support by renaming the internal data +structures. + +Acked-by: Adrian Hunter +Signed-off-by: Sebastian Reichel +Link: https://lore.kernel.org/r/20220504213251.264819-11-sebastian.reichel@collabora.com +Signed-off-by: Ulf Hansson +Signed-off-by: Sasha Levin +--- + drivers/mmc/host/sdhci-of-dwcmshc.c | 46 ++++++++++++++--------------- + 1 file changed, 23 insertions(+), 23 deletions(-) + +diff --git a/drivers/mmc/host/sdhci-of-dwcmshc.c b/drivers/mmc/host/sdhci-of-dwcmshc.c +index 3a1b5ba364051..f5fd88c7adef1 100644 +--- a/drivers/mmc/host/sdhci-of-dwcmshc.c ++++ b/drivers/mmc/host/sdhci-of-dwcmshc.c +@@ -56,14 +56,14 @@ + #define DLL_LOCK_WO_TMOUT(x) \ + ((((x) & DWCMSHC_EMMC_DLL_LOCKED) == DWCMSHC_EMMC_DLL_LOCKED) && \ + (((x) & DWCMSHC_EMMC_DLL_TIMEOUT) == 0)) +-#define RK3568_MAX_CLKS 3 ++#define RK35xx_MAX_CLKS 3 + + #define BOUNDARY_OK(addr, len) \ + ((addr | (SZ_128M - 1)) == ((addr + len - 1) | (SZ_128M - 1))) + +-struct rk3568_priv { ++struct rk35xx_priv { + /* Rockchip specified optional clocks */ +- struct clk_bulk_data rockchip_clks[RK3568_MAX_CLKS]; ++ struct clk_bulk_data rockchip_clks[RK35xx_MAX_CLKS]; + struct reset_control *reset; + u8 txclk_tapnum; + }; +@@ -178,7 +178,7 @@ static void dwcmshc_rk3568_set_clock(struct sdhci_host *host, unsigned int clock + { + struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); + struct dwcmshc_priv *dwc_priv = sdhci_pltfm_priv(pltfm_host); +- struct rk3568_priv *priv = dwc_priv->priv; ++ struct rk35xx_priv *priv = dwc_priv->priv; + u8 txclk_tapnum = DLL_TXCLK_TAPNUM_DEFAULT; + u32 extra, reg; + int err; +@@ -281,7 +281,7 @@ static const struct sdhci_ops sdhci_dwcmshc_ops = { + .adma_write_desc = dwcmshc_adma_write_desc, + }; + +-static const struct sdhci_ops sdhci_dwcmshc_rk3568_ops = { ++static const struct sdhci_ops sdhci_dwcmshc_rk35xx_ops = { + .set_clock = dwcmshc_rk3568_set_clock, + .set_bus_width = sdhci_set_bus_width, + .set_uhs_signaling = dwcmshc_set_uhs_signaling, +@@ -296,18 +296,18 @@ static const struct sdhci_pltfm_data sdhci_dwcmshc_pdata = { + .quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN, + }; + +-static const struct sdhci_pltfm_data sdhci_dwcmshc_rk3568_pdata = { +- .ops = &sdhci_dwcmshc_rk3568_ops, ++static const struct sdhci_pltfm_data sdhci_dwcmshc_rk35xx_pdata = { ++ .ops = &sdhci_dwcmshc_rk35xx_ops, + .quirks = SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN | + SDHCI_QUIRK_BROKEN_TIMEOUT_VAL, + .quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN | + SDHCI_QUIRK2_CLOCK_DIV_ZERO_BROKEN, + }; + +-static int dwcmshc_rk3568_init(struct sdhci_host *host, struct dwcmshc_priv *dwc_priv) ++static int dwcmshc_rk35xx_init(struct sdhci_host *host, struct dwcmshc_priv *dwc_priv) + { + int err; +- struct rk3568_priv *priv = dwc_priv->priv; ++ struct rk35xx_priv *priv = dwc_priv->priv; + + priv->reset = devm_reset_control_array_get_optional_exclusive(mmc_dev(host->mmc)); + if (IS_ERR(priv->reset)) { +@@ -319,14 +319,14 @@ static int dwcmshc_rk3568_init(struct sdhci_host *host, struct dwcmshc_priv *dwc + priv->rockchip_clks[0].id = "axi"; + priv->rockchip_clks[1].id = "block"; + priv->rockchip_clks[2].id = "timer"; +- err = devm_clk_bulk_get_optional(mmc_dev(host->mmc), RK3568_MAX_CLKS, ++ err = devm_clk_bulk_get_optional(mmc_dev(host->mmc), RK35xx_MAX_CLKS, + priv->rockchip_clks); + if (err) { + dev_err(mmc_dev(host->mmc), "failed to get clocks %d\n", err); + return err; + } + +- err = clk_bulk_prepare_enable(RK3568_MAX_CLKS, priv->rockchip_clks); ++ err = clk_bulk_prepare_enable(RK35xx_MAX_CLKS, priv->rockchip_clks); + if (err) { + dev_err(mmc_dev(host->mmc), "failed to enable clocks %d\n", err); + return err; +@@ -348,7 +348,7 @@ static int dwcmshc_rk3568_init(struct sdhci_host *host, struct dwcmshc_priv *dwc + static const struct of_device_id sdhci_dwcmshc_dt_ids[] = { + { + .compatible = "rockchip,rk3568-dwcmshc", +- .data = &sdhci_dwcmshc_rk3568_pdata, ++ .data = &sdhci_dwcmshc_rk35xx_pdata, + }, + { + .compatible = "snps,dwcmshc-sdhci", +@@ -371,7 +371,7 @@ static int dwcmshc_probe(struct platform_device *pdev) + struct sdhci_pltfm_host *pltfm_host; + struct sdhci_host *host; + struct dwcmshc_priv *priv; +- struct rk3568_priv *rk_priv = NULL; ++ struct rk35xx_priv *rk_priv = NULL; + const struct sdhci_pltfm_data *pltfm_data; + int err; + u32 extra; +@@ -426,8 +426,8 @@ static int dwcmshc_probe(struct platform_device *pdev) + host->mmc_host_ops.request = dwcmshc_request; + host->mmc_host_ops.hs400_enhanced_strobe = dwcmshc_hs400_enhanced_strobe; + +- if (pltfm_data == &sdhci_dwcmshc_rk3568_pdata) { +- rk_priv = devm_kzalloc(&pdev->dev, sizeof(struct rk3568_priv), GFP_KERNEL); ++ if (pltfm_data == &sdhci_dwcmshc_rk35xx_pdata) { ++ rk_priv = devm_kzalloc(&pdev->dev, sizeof(struct rk35xx_priv), GFP_KERNEL); + if (!rk_priv) { + err = -ENOMEM; + goto err_clk; +@@ -435,7 +435,7 @@ static int dwcmshc_probe(struct platform_device *pdev) + + priv->priv = rk_priv; + +- err = dwcmshc_rk3568_init(host, priv); ++ err = dwcmshc_rk35xx_init(host, priv); + if (err) + goto err_clk; + } +@@ -452,7 +452,7 @@ static int dwcmshc_probe(struct platform_device *pdev) + clk_disable_unprepare(pltfm_host->clk); + clk_disable_unprepare(priv->bus_clk); + if (rk_priv) +- clk_bulk_disable_unprepare(RK3568_MAX_CLKS, ++ clk_bulk_disable_unprepare(RK35xx_MAX_CLKS, + rk_priv->rockchip_clks); + free_pltfm: + sdhci_pltfm_free(pdev); +@@ -464,14 +464,14 @@ static int dwcmshc_remove(struct platform_device *pdev) + struct sdhci_host *host = platform_get_drvdata(pdev); + struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); + struct dwcmshc_priv *priv = sdhci_pltfm_priv(pltfm_host); +- struct rk3568_priv *rk_priv = priv->priv; ++ struct rk35xx_priv *rk_priv = priv->priv; + + sdhci_remove_host(host, 0); + + clk_disable_unprepare(pltfm_host->clk); + clk_disable_unprepare(priv->bus_clk); + if (rk_priv) +- clk_bulk_disable_unprepare(RK3568_MAX_CLKS, ++ clk_bulk_disable_unprepare(RK35xx_MAX_CLKS, + rk_priv->rockchip_clks); + sdhci_pltfm_free(pdev); + +@@ -484,7 +484,7 @@ static int dwcmshc_suspend(struct device *dev) + struct sdhci_host *host = dev_get_drvdata(dev); + struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); + struct dwcmshc_priv *priv = sdhci_pltfm_priv(pltfm_host); +- struct rk3568_priv *rk_priv = priv->priv; ++ struct rk35xx_priv *rk_priv = priv->priv; + int ret; + + ret = sdhci_suspend_host(host); +@@ -496,7 +496,7 @@ static int dwcmshc_suspend(struct device *dev) + clk_disable_unprepare(priv->bus_clk); + + if (rk_priv) +- clk_bulk_disable_unprepare(RK3568_MAX_CLKS, ++ clk_bulk_disable_unprepare(RK35xx_MAX_CLKS, + rk_priv->rockchip_clks); + + return ret; +@@ -507,7 +507,7 @@ static int dwcmshc_resume(struct device *dev) + struct sdhci_host *host = dev_get_drvdata(dev); + struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); + struct dwcmshc_priv *priv = sdhci_pltfm_priv(pltfm_host); +- struct rk3568_priv *rk_priv = priv->priv; ++ struct rk35xx_priv *rk_priv = priv->priv; + int ret; + + ret = clk_prepare_enable(pltfm_host->clk); +@@ -521,7 +521,7 @@ static int dwcmshc_resume(struct device *dev) + } + + if (rk_priv) { +- ret = clk_bulk_prepare_enable(RK3568_MAX_CLKS, ++ ret = clk_bulk_prepare_enable(RK35xx_MAX_CLKS, + rk_priv->rockchip_clks); + if (ret) + return ret; +-- +2.35.1 + diff --git a/queue-5.15/neigh-fix-possible-dos-due-to-net-iface-start-stop-l.patch b/queue-5.15/neigh-fix-possible-dos-due-to-net-iface-start-stop-l.patch new file mode 100644 index 00000000000..9091d8c763b --- /dev/null +++ b/queue-5.15/neigh-fix-possible-dos-due-to-net-iface-start-stop-l.patch @@ -0,0 +1,129 @@ +From 9069033a64108e6c83ed84e55f9f8c413abf9edf Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Thu, 11 Aug 2022 18:20:11 +0300 +Subject: neigh: fix possible DoS due to net iface start/stop loop + +From: Denis V. Lunev + +[ Upstream commit 66ba215cb51323e4e55e38fd5f250e0fae0cbc94 ] + +Normal processing of ARP request (usually this is Ethernet broadcast +packet) coming to the host is looking like the following: +* the packet comes to arp_process() call and is passed through routing + procedure +* the request is put into the queue using pneigh_enqueue() if + corresponding ARP record is not local (common case for container + records on the host) +* the request is processed by timer (within 80 jiffies by default) and + ARP reply is sent from the same arp_process() using + NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED condition (flag is set inside + pneigh_enqueue()) + +And here the problem comes. Linux kernel calls pneigh_queue_purge() +which destroys the whole queue of ARP requests on ANY network interface +start/stop event through __neigh_ifdown(). + +This is actually not a problem within the original world as network +interface start/stop was accessible to the host 'root' only, which +could do more destructive things. But the world is changed and there +are Linux containers available. Here container 'root' has an access +to this API and could be considered as untrusted user in the hosting +(container's) world. + +Thus there is an attack vector to other containers on node when +container's root will endlessly start/stop interfaces. We have observed +similar situation on a real production node when docker container was +doing such activity and thus other containers on the node become not +accessible. + +The patch proposed doing very simple thing. It drops only packets from +the same namespace in the pneigh_queue_purge() where network interface +state change is detected. This is enough to prevent the problem for the +whole node preserving original semantics of the code. + +v2: + - do del_timer_sync() if queue is empty after pneigh_queue_purge() +v3: + - rebase to net tree + +Cc: "David S. Miller" +Cc: Eric Dumazet +Cc: Jakub Kicinski +Cc: Paolo Abeni +Cc: Daniel Borkmann +Cc: David Ahern +Cc: Yajun Deng +Cc: Roopa Prabhu +Cc: Christian Brauner +Cc: netdev@vger.kernel.org +Cc: linux-kernel@vger.kernel.org +Cc: Alexey Kuznetsov +Cc: Alexander Mikhalitsyn +Cc: Konstantin Khorenko +Cc: kernel@openvz.org +Cc: devel@openvz.org +Investigated-by: Alexander Mikhalitsyn +Signed-off-by: Denis V. Lunev +Signed-off-by: David S. Miller +Signed-off-by: Sasha Levin +--- + net/core/neighbour.c | 25 +++++++++++++++++-------- + 1 file changed, 17 insertions(+), 8 deletions(-) + +diff --git a/net/core/neighbour.c b/net/core/neighbour.c +index ff049733cceeb..f0be42c140b91 100644 +--- a/net/core/neighbour.c ++++ b/net/core/neighbour.c +@@ -279,14 +279,23 @@ static int neigh_del_timer(struct neighbour *n) + return 0; + } + +-static void pneigh_queue_purge(struct sk_buff_head *list) ++static void pneigh_queue_purge(struct sk_buff_head *list, struct net *net) + { ++ unsigned long flags; + struct sk_buff *skb; + +- while ((skb = skb_dequeue(list)) != NULL) { +- dev_put(skb->dev); +- kfree_skb(skb); ++ spin_lock_irqsave(&list->lock, flags); ++ skb = skb_peek(list); ++ while (skb != NULL) { ++ struct sk_buff *skb_next = skb_peek_next(skb, list); ++ if (net == NULL || net_eq(dev_net(skb->dev), net)) { ++ __skb_unlink(skb, list); ++ dev_put(skb->dev); ++ kfree_skb(skb); ++ } ++ skb = skb_next; + } ++ spin_unlock_irqrestore(&list->lock, flags); + } + + static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev, +@@ -357,9 +366,9 @@ static int __neigh_ifdown(struct neigh_table *tbl, struct net_device *dev, + write_lock_bh(&tbl->lock); + neigh_flush_dev(tbl, dev, skip_perm); + pneigh_ifdown_and_unlock(tbl, dev); +- +- del_timer_sync(&tbl->proxy_timer); +- pneigh_queue_purge(&tbl->proxy_queue); ++ pneigh_queue_purge(&tbl->proxy_queue, dev_net(dev)); ++ if (skb_queue_empty_lockless(&tbl->proxy_queue)) ++ del_timer_sync(&tbl->proxy_timer); + return 0; + } + +@@ -1735,7 +1744,7 @@ int neigh_table_clear(int index, struct neigh_table *tbl) + /* It is not clean... Fix it to unload IPv6 module safely */ + cancel_delayed_work_sync(&tbl->gc_work); + del_timer_sync(&tbl->proxy_timer); +- pneigh_queue_purge(&tbl->proxy_queue); ++ pneigh_queue_purge(&tbl->proxy_queue, NULL); + neigh_ifdown(tbl, NULL); + if (atomic_read(&tbl->entries)) + pr_crit("neighbour leakage\n"); +-- +2.35.1 + diff --git a/queue-5.15/netfilter-conntrack-nf_conntrack_procfs-should-no-lo.patch b/queue-5.15/netfilter-conntrack-nf_conntrack_procfs-should-no-lo.patch new file mode 100644 index 00000000000..436ed020bf6 --- /dev/null +++ b/queue-5.15/netfilter-conntrack-nf_conntrack_procfs-should-no-lo.patch @@ -0,0 +1,36 @@ +From d00debb91f9e40589c856fdca60a70201ed94bc1 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Mon, 15 Aug 2022 12:39:20 +0200 +Subject: netfilter: conntrack: NF_CONNTRACK_PROCFS should no longer default to + y + +From: Geert Uytterhoeven + +[ Upstream commit aa5762c34213aba7a72dc58e70601370805fa794 ] + +NF_CONNTRACK_PROCFS was marked obsolete in commit 54b07dca68557b09 +("netfilter: provide config option to disable ancient procfs parts") in +v3.3. + +Signed-off-by: Geert Uytterhoeven +Signed-off-by: Florian Westphal +Signed-off-by: Sasha Levin +--- + net/netfilter/Kconfig | 1 - + 1 file changed, 1 deletion(-) + +diff --git a/net/netfilter/Kconfig b/net/netfilter/Kconfig +index 92a747896f808..4f645d51c2573 100644 +--- a/net/netfilter/Kconfig ++++ b/net/netfilter/Kconfig +@@ -133,7 +133,6 @@ config NF_CONNTRACK_ZONES + + config NF_CONNTRACK_PROCFS + bool "Supply CT list in procfs (OBSOLETE)" +- default y + depends on PROC_FS + help + This option enables for the list of known conntrack entries +-- +2.35.1 + diff --git a/queue-5.15/s390-hypfs-avoid-error-message-under-kvm.patch b/queue-5.15/s390-hypfs-avoid-error-message-under-kvm.patch new file mode 100644 index 00000000000..738d2c27b6f --- /dev/null +++ b/queue-5.15/s390-hypfs-avoid-error-message-under-kvm.patch @@ -0,0 +1,60 @@ +From eb132978ce3df9a44756e01c303baf2810546afe Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Mon, 20 Jun 2022 11:45:34 +0200 +Subject: s390/hypfs: avoid error message under KVM + +From: Juergen Gross + +[ Upstream commit 7b6670b03641ac308aaa6fa2e6f964ac993b5ea3 ] + +When booting under KVM the following error messages are issued: + +hypfs.7f5705: The hardware system does not support hypfs +hypfs.7a79f0: Initialization of hypfs failed with rc=-61 + +Demote the severity of first message from "error" to "info" and issue +the second message only in other error cases. + +Signed-off-by: Juergen Gross +Acked-by: Heiko Carstens +Acked-by: Christian Borntraeger +Link: https://lore.kernel.org/r/20220620094534.18967-1-jgross@suse.com +[arch/s390/hypfs/hypfs_diag.c changed description] +Signed-off-by: Alexander Gordeev +Signed-off-by: Sasha Levin +--- + arch/s390/hypfs/hypfs_diag.c | 2 +- + arch/s390/hypfs/inode.c | 2 +- + 2 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/arch/s390/hypfs/hypfs_diag.c b/arch/s390/hypfs/hypfs_diag.c +index f0bc4dc3e9bf0..6511d15ace45e 100644 +--- a/arch/s390/hypfs/hypfs_diag.c ++++ b/arch/s390/hypfs/hypfs_diag.c +@@ -437,7 +437,7 @@ __init int hypfs_diag_init(void) + int rc; + + if (diag204_probe()) { +- pr_err("The hardware system does not support hypfs\n"); ++ pr_info("The hardware system does not support hypfs\n"); + return -ENODATA; + } + +diff --git a/arch/s390/hypfs/inode.c b/arch/s390/hypfs/inode.c +index 5c97f48cea91d..ee919bfc81867 100644 +--- a/arch/s390/hypfs/inode.c ++++ b/arch/s390/hypfs/inode.c +@@ -496,9 +496,9 @@ static int __init hypfs_init(void) + hypfs_vm_exit(); + fail_hypfs_diag_exit: + hypfs_diag_exit(); ++ pr_err("Initialization of hypfs failed with rc=%i\n", rc); + fail_dbfs_exit: + hypfs_dbfs_exit(); +- pr_err("Initialization of hypfs failed with rc=%i\n", rc); + return rc; + } + device_initcall(hypfs_init) +-- +2.35.1 + diff --git a/queue-5.15/series b/queue-5.15/series index 108e9f1d577..b87d8c2597d 100644 --- a/queue-5.15/series +++ b/queue-5.15/series @@ -38,3 +38,31 @@ hid-add-lenovo-yoga-c630-battery-quirk.patch hid-amd_sfh-add-a-dmi-quirk-entry-for-chromebooks.patch hid-asus-rog-nkey-ignore-portion-of-0x5a-report.patch hid-thrustmaster-add-sparco-wheel-and-fix-array-length.patch +drm-i915-gt-skip-tlb-invalidations-once-wedged.patch +mmc-mtk-sd-clear-interrupts-when-cqe-off-disable.patch +mmc-sdhci-of-dwcmshc-add-reset-call-back-for-rockchi.patch +mmc-sdhci-of-dwcmshc-rename-rk3568-to-rk35xx.patch +mmc-sdhci-of-dwcmshc-re-enable-support-for-the-bluef.patch +btrfs-remove-root-argument-from-btrfs_unlink_inode.patch +btrfs-remove-no-longer-needed-logic-for-replaying-di.patch +btrfs-add-and-use-helper-for-unlinking-inode-during-.patch +btrfs-fix-warning-during-log-replay-when-bumping-ino.patch +fs-ntfs3-fix-work-with-fragmented-xattr.patch +asoc-sh-rz-ssi-improve-error-handling-in-rz_ssi_prob.patch +drm-amd-display-avoid-mpc-infinite-loop.patch +drm-amd-display-fix-hdmi-vsif-v3-incorrect-issue.patch +drm-amd-display-for-stereo-keep-flip_any_frame.patch +drm-amd-display-clear-optc-underflow-before-turn-off.patch +ksmbd-return-status_bad_network_name-error-status-if.patch +neigh-fix-possible-dos-due-to-net-iface-start-stop-l.patch +s390-hypfs-avoid-error-message-under-kvm.patch +ksmbd-don-t-remove-dos-attribute-xattr-on-o_trunc-op.patch +drm-amd-pm-add-missing-fini_microcode-interface-for-.patch +drm-amd-display-fix-pixel-clock-programming.patch +drm-amdgpu-increase-tlb-flush-timeout-for-sriov.patch +drm-amd-display-avoid-doing-vm_init-multiple-time.patch +netfilter-conntrack-nf_conntrack_procfs-should-no-lo.patch +testing-selftests-nft_flowtable.sh-use-random-netns-.patch +btrfs-move-lockdep-class-helpers-to-locking.c.patch +btrfs-fix-lockdep-splat-with-reloc-root-extent-buffe.patch +btrfs-tree-checker-check-for-overlapping-extent-item.patch diff --git a/queue-5.15/testing-selftests-nft_flowtable.sh-use-random-netns-.patch b/queue-5.15/testing-selftests-nft_flowtable.sh-use-random-netns-.patch new file mode 100644 index 00000000000..b576fa5dc39 --- /dev/null +++ b/queue-5.15/testing-selftests-nft_flowtable.sh-use-random-netns-.patch @@ -0,0 +1,429 @@ +From 8055017dc394ce6d3b63262bd9509ae747322cc6 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Tue, 16 Aug 2022 14:15:21 +0200 +Subject: testing: selftests: nft_flowtable.sh: use random netns names + +From: Florian Westphal + +[ Upstream commit b71b7bfeac38c7a21c423ddafb29aa6258949df8 ] + +"ns1" is a too generic name, use a random suffix to avoid +errors when such a netns exists. Also allows to run multiple +instances of the script in parallel. + +Signed-off-by: Florian Westphal +Signed-off-by: Sasha Levin +--- + .../selftests/netfilter/nft_flowtable.sh | 246 +++++++++--------- + 1 file changed, 128 insertions(+), 118 deletions(-) + +diff --git a/tools/testing/selftests/netfilter/nft_flowtable.sh b/tools/testing/selftests/netfilter/nft_flowtable.sh +index d4ffebb989f88..c336e6c148d1f 100755 +--- a/tools/testing/selftests/netfilter/nft_flowtable.sh ++++ b/tools/testing/selftests/netfilter/nft_flowtable.sh +@@ -14,6 +14,11 @@ + # nft_flowtable.sh -o8000 -l1500 -r2000 + # + ++sfx=$(mktemp -u "XXXXXXXX") ++ns1="ns1-$sfx" ++ns2="ns2-$sfx" ++nsr1="nsr1-$sfx" ++nsr2="nsr2-$sfx" + + # Kselftest framework requirement - SKIP code is 4. + ksft_skip=4 +@@ -36,18 +41,17 @@ checktool (){ + checktool "nft --version" "run test without nft tool" + checktool "ip -Version" "run test without ip tool" + checktool "which nc" "run test without nc (netcat)" +-checktool "ip netns add nsr1" "create net namespace" ++checktool "ip netns add $nsr1" "create net namespace $nsr1" + +-ip netns add ns1 +-ip netns add ns2 +- +-ip netns add nsr2 ++ip netns add $ns1 ++ip netns add $ns2 ++ip netns add $nsr2 + + cleanup() { +- for i in 1 2; do +- ip netns del ns$i +- ip netns del nsr$i +- done ++ ip netns del $ns1 ++ ip netns del $ns2 ++ ip netns del $nsr1 ++ ip netns del $nsr2 + + rm -f "$ns1in" "$ns1out" + rm -f "$ns2in" "$ns2out" +@@ -59,22 +63,21 @@ trap cleanup EXIT + + sysctl -q net.netfilter.nf_log_all_netns=1 + +-ip link add veth0 netns nsr1 type veth peer name eth0 netns ns1 +-ip link add veth1 netns nsr1 type veth peer name veth0 netns nsr2 ++ip link add veth0 netns $nsr1 type veth peer name eth0 netns $ns1 ++ip link add veth1 netns $nsr1 type veth peer name veth0 netns $nsr2 + +-ip link add veth1 netns nsr2 type veth peer name eth0 netns ns2 ++ip link add veth1 netns $nsr2 type veth peer name eth0 netns $ns2 + + for dev in lo veth0 veth1; do +- for i in 1 2; do +- ip -net nsr$i link set $dev up +- done ++ ip -net $nsr1 link set $dev up ++ ip -net $nsr2 link set $dev up + done + +-ip -net nsr1 addr add 10.0.1.1/24 dev veth0 +-ip -net nsr1 addr add dead:1::1/64 dev veth0 ++ip -net $nsr1 addr add 10.0.1.1/24 dev veth0 ++ip -net $nsr1 addr add dead:1::1/64 dev veth0 + +-ip -net nsr2 addr add 10.0.2.1/24 dev veth1 +-ip -net nsr2 addr add dead:2::1/64 dev veth1 ++ip -net $nsr2 addr add 10.0.2.1/24 dev veth1 ++ip -net $nsr2 addr add dead:2::1/64 dev veth1 + + # set different MTUs so we need to push packets coming from ns1 (large MTU) + # to ns2 (smaller MTU) to stack either to perform fragmentation (ip_no_pmtu_disc=1), +@@ -106,49 +109,56 @@ do + esac + done + +-if ! ip -net nsr1 link set veth0 mtu $omtu; then ++if ! ip -net $nsr1 link set veth0 mtu $omtu; then + exit 1 + fi + +-ip -net ns1 link set eth0 mtu $omtu ++ip -net $ns1 link set eth0 mtu $omtu + +-if ! ip -net nsr2 link set veth1 mtu $rmtu; then ++if ! ip -net $nsr2 link set veth1 mtu $rmtu; then + exit 1 + fi + +-ip -net ns2 link set eth0 mtu $rmtu ++ip -net $ns2 link set eth0 mtu $rmtu + + # transfer-net between nsr1 and nsr2. + # these addresses are not used for connections. +-ip -net nsr1 addr add 192.168.10.1/24 dev veth1 +-ip -net nsr1 addr add fee1:2::1/64 dev veth1 +- +-ip -net nsr2 addr add 192.168.10.2/24 dev veth0 +-ip -net nsr2 addr add fee1:2::2/64 dev veth0 +- +-for i in 1 2; do +- ip netns exec nsr$i sysctl net.ipv4.conf.veth0.forwarding=1 > /dev/null +- ip netns exec nsr$i sysctl net.ipv4.conf.veth1.forwarding=1 > /dev/null +- +- ip -net ns$i link set lo up +- ip -net ns$i link set eth0 up +- ip -net ns$i addr add 10.0.$i.99/24 dev eth0 +- ip -net ns$i route add default via 10.0.$i.1 +- ip -net ns$i addr add dead:$i::99/64 dev eth0 +- ip -net ns$i route add default via dead:$i::1 +- if ! ip netns exec ns$i sysctl net.ipv4.tcp_no_metrics_save=1 > /dev/null; then ++ip -net $nsr1 addr add 192.168.10.1/24 dev veth1 ++ip -net $nsr1 addr add fee1:2::1/64 dev veth1 ++ ++ip -net $nsr2 addr add 192.168.10.2/24 dev veth0 ++ip -net $nsr2 addr add fee1:2::2/64 dev veth0 ++ ++for i in 0 1; do ++ ip netns exec $nsr1 sysctl net.ipv4.conf.veth$i.forwarding=1 > /dev/null ++ ip netns exec $nsr2 sysctl net.ipv4.conf.veth$i.forwarding=1 > /dev/null ++done ++ ++for ns in $ns1 $ns2;do ++ ip -net $ns link set lo up ++ ip -net $ns link set eth0 up ++ ++ if ! ip netns exec $ns sysctl net.ipv4.tcp_no_metrics_save=1 > /dev/null; then + echo "ERROR: Check Originator/Responder values (problem during address addition)" + exit 1 + fi +- + # don't set ip DF bit for first two tests +- ip netns exec ns$i sysctl net.ipv4.ip_no_pmtu_disc=1 > /dev/null ++ ip netns exec $ns sysctl net.ipv4.ip_no_pmtu_disc=1 > /dev/null + done + +-ip -net nsr1 route add default via 192.168.10.2 +-ip -net nsr2 route add default via 192.168.10.1 ++ip -net $ns1 addr add 10.0.1.99/24 dev eth0 ++ip -net $ns2 addr add 10.0.2.99/24 dev eth0 ++ip -net $ns1 route add default via 10.0.1.1 ++ip -net $ns2 route add default via 10.0.2.1 ++ip -net $ns1 addr add dead:1::99/64 dev eth0 ++ip -net $ns2 addr add dead:2::99/64 dev eth0 ++ip -net $ns1 route add default via dead:1::1 ++ip -net $ns2 route add default via dead:2::1 ++ ++ip -net $nsr1 route add default via 192.168.10.2 ++ip -net $nsr2 route add default via 192.168.10.1 + +-ip netns exec nsr1 nft -f - < /dev/null; then +- echo "ERROR: ns1 cannot reach ns2" 1>&2 ++if ! ip netns exec $ns1 ping -c 1 -q 10.0.2.99 > /dev/null; then ++ echo "ERROR: $ns1 cannot reach ns2" 1>&2 + exit 1 + fi + +-if ! ip netns exec ns2 ping -c 1 -q 10.0.1.99 > /dev/null; then +- echo "ERROR: ns2 cannot reach ns1" 1>&2 ++if ! ip netns exec $ns2 ping -c 1 -q 10.0.1.99 > /dev/null; then ++ echo "ERROR: $ns2 cannot reach $ns1" 1>&2 + exit 1 + fi + + if [ $ret -eq 0 ];then +- echo "PASS: netns routing/connectivity: ns1 can reach ns2" ++ echo "PASS: netns routing/connectivity: $ns1 can reach $ns2" + fi + + ns1in=$(mktemp) +@@ -312,24 +322,24 @@ make_file "$ns2in" + + # First test: + # No PMTU discovery, nsr1 is expected to fragment packets from ns1 to ns2 as needed. +-if test_tcp_forwarding ns1 ns2; then ++if test_tcp_forwarding $ns1 $ns2; then + echo "PASS: flow offloaded for ns1/ns2" + else + echo "FAIL: flow offload for ns1/ns2:" 1>&2 +- ip netns exec nsr1 nft list ruleset ++ ip netns exec $nsr1 nft list ruleset + ret=1 + fi + + # delete default route, i.e. ns2 won't be able to reach ns1 and + # will depend on ns1 being masqueraded in nsr1. + # expect ns1 has nsr1 address. +-ip -net ns2 route del default via 10.0.2.1 +-ip -net ns2 route del default via dead:2::1 +-ip -net ns2 route add 192.168.10.1 via 10.0.2.1 ++ip -net $ns2 route del default via 10.0.2.1 ++ip -net $ns2 route del default via dead:2::1 ++ip -net $ns2 route add 192.168.10.1 via 10.0.2.1 + + # Second test: + # Same, but with NAT enabled. +-ip netns exec nsr1 nft -f - <&2 +- ip netns exec nsr1 nft list ruleset ++ ip netns exec $nsr1 nft list ruleset + ret=1 + fi + + # Third test: + # Same as second test, but with PMTU discovery enabled. +-handle=$(ip netns exec nsr1 nft -a list table inet filter | grep something-to-grep-for | cut -d \# -f 2) ++handle=$(ip netns exec $nsr1 nft -a list table inet filter | grep something-to-grep-for | cut -d \# -f 2) + +-if ! ip netns exec nsr1 nft delete rule inet filter forward $handle; then ++if ! ip netns exec $nsr1 nft delete rule inet filter forward $handle; then + echo "FAIL: Could not delete large-packet accept rule" + exit 1 + fi + +-ip netns exec ns1 sysctl net.ipv4.ip_no_pmtu_disc=0 > /dev/null +-ip netns exec ns2 sysctl net.ipv4.ip_no_pmtu_disc=0 > /dev/null ++ip netns exec $ns1 sysctl net.ipv4.ip_no_pmtu_disc=0 > /dev/null ++ip netns exec $ns2 sysctl net.ipv4.ip_no_pmtu_disc=0 > /dev/null + +-if test_tcp_forwarding_nat ns1 ns2; then ++if test_tcp_forwarding_nat $ns1 $ns2; then + echo "PASS: flow offloaded for ns1/ns2 with NAT and pmtu discovery" + else + echo "FAIL: flow offload for ns1/ns2 with NAT and pmtu discovery" 1>&2 +- ip netns exec nsr1 nft list ruleset ++ ip netns exec $nsr1 nft list ruleset + fi + + # Another test: + # Add bridge interface br0 to Router1, with NAT enabled. +-ip -net nsr1 link add name br0 type bridge +-ip -net nsr1 addr flush dev veth0 +-ip -net nsr1 link set up dev veth0 +-ip -net nsr1 link set veth0 master br0 +-ip -net nsr1 addr add 10.0.1.1/24 dev br0 +-ip -net nsr1 addr add dead:1::1/64 dev br0 +-ip -net nsr1 link set up dev br0 ++ip -net $nsr1 link add name br0 type bridge ++ip -net $nsr1 addr flush dev veth0 ++ip -net $nsr1 link set up dev veth0 ++ip -net $nsr1 link set veth0 master br0 ++ip -net $nsr1 addr add 10.0.1.1/24 dev br0 ++ip -net $nsr1 addr add dead:1::1/64 dev br0 ++ip -net $nsr1 link set up dev br0 + +-ip netns exec nsr1 sysctl net.ipv4.conf.br0.forwarding=1 > /dev/null ++ip netns exec $nsr1 sysctl net.ipv4.conf.br0.forwarding=1 > /dev/null + + # br0 with NAT enabled. +-ip netns exec nsr1 nft -f - <&2 +- ip netns exec nsr1 nft list ruleset ++ ip netns exec $nsr1 nft list ruleset + ret=1 + fi + + # Another test: + # Add bridge interface br0 to Router1, with NAT and VLAN. +-ip -net nsr1 link set veth0 nomaster +-ip -net nsr1 link set down dev veth0 +-ip -net nsr1 link add link veth0 name veth0.10 type vlan id 10 +-ip -net nsr1 link set up dev veth0 +-ip -net nsr1 link set up dev veth0.10 +-ip -net nsr1 link set veth0.10 master br0 +- +-ip -net ns1 addr flush dev eth0 +-ip -net ns1 link add link eth0 name eth0.10 type vlan id 10 +-ip -net ns1 link set eth0 up +-ip -net ns1 link set eth0.10 up +-ip -net ns1 addr add 10.0.1.99/24 dev eth0.10 +-ip -net ns1 route add default via 10.0.1.1 +-ip -net ns1 addr add dead:1::99/64 dev eth0.10 +- +-if test_tcp_forwarding_nat ns1 ns2; then ++ip -net $nsr1 link set veth0 nomaster ++ip -net $nsr1 link set down dev veth0 ++ip -net $nsr1 link add link veth0 name veth0.10 type vlan id 10 ++ip -net $nsr1 link set up dev veth0 ++ip -net $nsr1 link set up dev veth0.10 ++ip -net $nsr1 link set veth0.10 master br0 ++ ++ip -net $ns1 addr flush dev eth0 ++ip -net $ns1 link add link eth0 name eth0.10 type vlan id 10 ++ip -net $ns1 link set eth0 up ++ip -net $ns1 link set eth0.10 up ++ip -net $ns1 addr add 10.0.1.99/24 dev eth0.10 ++ip -net $ns1 route add default via 10.0.1.1 ++ip -net $ns1 addr add dead:1::99/64 dev eth0.10 ++ ++if test_tcp_forwarding_nat $ns1 $ns2; then + echo "PASS: flow offloaded for ns1/ns2 with bridge NAT and VLAN" + else + echo "FAIL: flow offload for ns1/ns2 with bridge NAT and VLAN" 1>&2 +- ip netns exec nsr1 nft list ruleset ++ ip netns exec $nsr1 nft list ruleset + ret=1 + fi + + # restore test topology (remove bridge and VLAN) +-ip -net nsr1 link set veth0 nomaster +-ip -net nsr1 link set veth0 down +-ip -net nsr1 link set veth0.10 down +-ip -net nsr1 link delete veth0.10 type vlan +-ip -net nsr1 link delete br0 type bridge +-ip -net ns1 addr flush dev eth0.10 +-ip -net ns1 link set eth0.10 down +-ip -net ns1 link set eth0 down +-ip -net ns1 link delete eth0.10 type vlan ++ip -net $nsr1 link set veth0 nomaster ++ip -net $nsr1 link set veth0 down ++ip -net $nsr1 link set veth0.10 down ++ip -net $nsr1 link delete veth0.10 type vlan ++ip -net $nsr1 link delete br0 type bridge ++ip -net $ns1 addr flush dev eth0.10 ++ip -net $ns1 link set eth0.10 down ++ip -net $ns1 link set eth0 down ++ip -net $ns1 link delete eth0.10 type vlan + + # restore address in ns1 and nsr1 +-ip -net ns1 link set eth0 up +-ip -net ns1 addr add 10.0.1.99/24 dev eth0 +-ip -net ns1 route add default via 10.0.1.1 +-ip -net ns1 addr add dead:1::99/64 dev eth0 +-ip -net ns1 route add default via dead:1::1 +-ip -net nsr1 addr add 10.0.1.1/24 dev veth0 +-ip -net nsr1 addr add dead:1::1/64 dev veth0 +-ip -net nsr1 link set up dev veth0 ++ip -net $ns1 link set eth0 up ++ip -net $ns1 addr add 10.0.1.99/24 dev eth0 ++ip -net $ns1 route add default via 10.0.1.1 ++ip -net $ns1 addr add dead:1::99/64 dev eth0 ++ip -net $ns1 route add default via dead:1::1 ++ip -net $nsr1 addr add 10.0.1.1/24 dev veth0 ++ip -net $nsr1 addr add dead:1::1/64 dev veth0 ++ip -net $nsr1 link set up dev veth0 + + KEY_SHA="0x"$(ps -xaf | sha1sum | cut -d " " -f 1) + KEY_AES="0x"$(ps -xaf | md5sum | cut -d " " -f 1) +@@ -480,23 +490,23 @@ do_esp() { + + } + +-do_esp nsr1 192.168.10.1 192.168.10.2 10.0.1.0/24 10.0.2.0/24 $SPI1 $SPI2 ++do_esp $nsr1 192.168.10.1 192.168.10.2 10.0.1.0/24 10.0.2.0/24 $SPI1 $SPI2 + +-do_esp nsr2 192.168.10.2 192.168.10.1 10.0.2.0/24 10.0.1.0/24 $SPI2 $SPI1 ++do_esp $nsr2 192.168.10.2 192.168.10.1 10.0.2.0/24 10.0.1.0/24 $SPI2 $SPI1 + +-ip netns exec nsr1 nft delete table ip nat ++ip netns exec $nsr1 nft delete table ip nat + + # restore default routes +-ip -net ns2 route del 192.168.10.1 via 10.0.2.1 +-ip -net ns2 route add default via 10.0.2.1 +-ip -net ns2 route add default via dead:2::1 ++ip -net $ns2 route del 192.168.10.1 via 10.0.2.1 ++ip -net $ns2 route add default via 10.0.2.1 ++ip -net $ns2 route add default via dead:2::1 + +-if test_tcp_forwarding ns1 ns2; then ++if test_tcp_forwarding $ns1 $ns2; then + echo "PASS: ipsec tunnel mode for ns1/ns2" + else + echo "FAIL: ipsec tunnel mode for ns1/ns2" +- ip netns exec nsr1 nft list ruleset 1>&2 +- ip netns exec nsr1 cat /proc/net/xfrm_stat 1>&2 ++ ip netns exec $nsr1 nft list ruleset 1>&2 ++ ip netns exec $nsr1 cat /proc/net/xfrm_stat 1>&2 + fi + + exit $ret +-- +2.35.1 + -- 2.47.3