From: Greg Kroah-Hartman Date: Wed, 22 Dec 2021 12:05:53 +0000 (+0100) Subject: 5.10-stable patches X-Git-Tag: v4.4.297~61 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=ee781215d82a552afadbe964c7349de57583fbe5;p=thirdparty%2Fkernel%2Fstable-queue.git 5.10-stable patches added patches: arm64-vdso32-drop-no-integrated-as-flag.patch arm64-vdso32-require-cross_compile_compat-for-gcc-bfd.patch ext4-check-for-inconsistent-extents-between-index-and-leaf-block.patch ext4-check-for-out-of-order-index-extents-in-ext4_valid_extent_entries.patch ext4-prevent-partial-update-of-the-extent-blocks.patch net-usb-lan78xx-add-allied-telesis-at29m2-af.patch --- diff --git a/queue-5.10/arm64-vdso32-drop-no-integrated-as-flag.patch b/queue-5.10/arm64-vdso32-drop-no-integrated-as-flag.patch new file mode 100644 index 00000000000..6ee1fdf9837 --- /dev/null +++ b/queue-5.10/arm64-vdso32-drop-no-integrated-as-flag.patch @@ -0,0 +1,50 @@ +From ef94340583eec5cb1544dc41a87baa4f684b3fe1 Mon Sep 17 00:00:00 2001 +From: Nick Desaulniers +Date: Tue, 20 Apr 2021 10:44:25 -0700 +Subject: arm64: vdso32: drop -no-integrated-as flag + +From: Nick Desaulniers + +commit ef94340583eec5cb1544dc41a87baa4f684b3fe1 upstream. + +Clang can assemble these files just fine; this is a relic from the top +level Makefile conditionally adding this. We no longer need --prefix, +--gcc-toolchain, or -Qunused-arguments flags either with this change, so +remove those too. + +To test building: +$ ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- \ + CROSS_COMPILE_COMPAT=arm-linux-gnueabi- make LLVM=1 LLVM_IAS=1 \ + defconfig arch/arm64/kernel/vdso32/ + +Suggested-by: Nathan Chancellor +Signed-off-by: Nick Desaulniers +Reviewed-by: Nathan Chancellor +Reviewed-by: Vincenzo Frascino +Tested-by: Stephen Boyd +Acked-by: Will Deacon +Link: https://lore.kernel.org/r/20210420174427.230228-1-ndesaulniers@google.com +Signed-off-by: Catalin Marinas +Signed-off-by: Greg Kroah-Hartman +--- + arch/arm64/kernel/vdso32/Makefile | 8 -------- + 1 file changed, 8 deletions(-) + +--- a/arch/arm64/kernel/vdso32/Makefile ++++ b/arch/arm64/kernel/vdso32/Makefile +@@ -10,15 +10,7 @@ include $(srctree)/lib/vdso/Makefile + + # Same as cc-*option, but using CC_COMPAT instead of CC + ifeq ($(CONFIG_CC_IS_CLANG), y) +-COMPAT_GCC_TOOLCHAIN_DIR := $(dir $(shell which $(CROSS_COMPILE_COMPAT)elfedit)) +-COMPAT_GCC_TOOLCHAIN := $(realpath $(COMPAT_GCC_TOOLCHAIN_DIR)/..) +- + CC_COMPAT_CLANG_FLAGS := --target=$(notdir $(CROSS_COMPILE_COMPAT:%-=%)) +-CC_COMPAT_CLANG_FLAGS += --prefix=$(COMPAT_GCC_TOOLCHAIN_DIR)$(notdir $(CROSS_COMPILE_COMPAT)) +-CC_COMPAT_CLANG_FLAGS += -no-integrated-as -Qunused-arguments +-ifneq ($(COMPAT_GCC_TOOLCHAIN),) +-CC_COMPAT_CLANG_FLAGS += --gcc-toolchain=$(COMPAT_GCC_TOOLCHAIN) +-endif + + CC_COMPAT ?= $(CC) + CC_COMPAT += $(CC_COMPAT_CLANG_FLAGS) diff --git a/queue-5.10/arm64-vdso32-require-cross_compile_compat-for-gcc-bfd.patch b/queue-5.10/arm64-vdso32-require-cross_compile_compat-for-gcc-bfd.patch new file mode 100644 index 00000000000..ff25113ee00 --- /dev/null +++ b/queue-5.10/arm64-vdso32-require-cross_compile_compat-for-gcc-bfd.patch @@ -0,0 +1,97 @@ +From 3e6f8d1fa18457d54b20917bd9174d27daf09ab9 Mon Sep 17 00:00:00 2001 +From: Nick Desaulniers +Date: Tue, 19 Oct 2021 15:36:46 -0700 +Subject: arm64: vdso32: require CROSS_COMPILE_COMPAT for gcc+bfd + +From: Nick Desaulniers + +commit 3e6f8d1fa18457d54b20917bd9174d27daf09ab9 upstream. + +Similar to +commit 231ad7f409f1 ("Makefile: infer --target from ARCH for CC=clang") +There really is no point in setting --target based on +$CROSS_COMPILE_COMPAT for clang when the integrated assembler is being +used, since +commit ef94340583ee ("arm64: vdso32: drop -no-integrated-as flag"). + +Allows COMPAT_VDSO to be selected without setting $CROSS_COMPILE_COMPAT +when using clang and lld together. + +Before: +$ ARCH=arm64 CROSS_COMPILE_COMPAT=arm-linux-gnueabi- make -j72 LLVM=1 defconfig +$ grep CONFIG_COMPAT_VDSO .config +CONFIG_COMPAT_VDSO=y +$ ARCH=arm64 make -j72 LLVM=1 defconfig +$ grep CONFIG_COMPAT_VDSO .config +$ + +After: +$ ARCH=arm64 CROSS_COMPILE_COMPAT=arm-linux-gnueabi- make -j72 LLVM=1 defconfig +$ grep CONFIG_COMPAT_VDSO .config +CONFIG_COMPAT_VDSO=y +$ ARCH=arm64 make -j72 LLVM=1 defconfig +$ grep CONFIG_COMPAT_VDSO .config +CONFIG_COMPAT_VDSO=y + +Reviewed-by: Nathan Chancellor +Suggested-by: Nathan Chancellor +Tested-by: Nathan Chancellor +Signed-off-by: Nick Desaulniers +Reviewed-by: Vincenzo Frascino +Link: https://lore.kernel.org/r/20211019223646.1146945-5-ndesaulniers@google.com +Signed-off-by: Will Deacon +Signed-off-by: Greg Kroah-Hartman +--- + arch/arm64/Kconfig | 3 ++- + arch/arm64/kernel/vdso32/Makefile | 17 +++++------------ + 2 files changed, 7 insertions(+), 13 deletions(-) + +--- a/arch/arm64/Kconfig ++++ b/arch/arm64/Kconfig +@@ -1265,7 +1265,8 @@ config KUSER_HELPERS + + config COMPAT_VDSO + bool "Enable vDSO for 32-bit applications" +- depends on !CPU_BIG_ENDIAN && "$(CROSS_COMPILE_COMPAT)" != "" ++ depends on !CPU_BIG_ENDIAN ++ depends on (CC_IS_CLANG && LD_IS_LLD) || "$(CROSS_COMPILE_COMPAT)" != "" + select GENERIC_COMPAT_VDSO + default y + help +--- a/arch/arm64/kernel/vdso32/Makefile ++++ b/arch/arm64/kernel/vdso32/Makefile +@@ -10,18 +10,15 @@ include $(srctree)/lib/vdso/Makefile + + # Same as cc-*option, but using CC_COMPAT instead of CC + ifeq ($(CONFIG_CC_IS_CLANG), y) +-CC_COMPAT_CLANG_FLAGS := --target=$(notdir $(CROSS_COMPILE_COMPAT:%-=%)) +- + CC_COMPAT ?= $(CC) +-CC_COMPAT += $(CC_COMPAT_CLANG_FLAGS) +- +-ifneq ($(LLVM),) +-LD_COMPAT ?= $(LD) ++CC_COMPAT += --target=arm-linux-gnueabi + else +-LD_COMPAT ?= $(CROSS_COMPILE_COMPAT)ld ++CC_COMPAT ?= $(CROSS_COMPILE_COMPAT)gcc + endif ++ ++ifeq ($(CONFIG_LD_IS_LLD), y) ++LD_COMPAT ?= $(LD) + else +-CC_COMPAT ?= $(CROSS_COMPILE_COMPAT)gcc + LD_COMPAT ?= $(CROSS_COMPILE_COMPAT)ld + endif + +@@ -47,10 +44,6 @@ VDSO_CPPFLAGS += $(LINUXINCLUDE) + # Common C and assembly flags + # From top-level Makefile + VDSO_CAFLAGS := $(VDSO_CPPFLAGS) +-ifneq ($(shell $(CC_COMPAT) --version 2>&1 | head -n 1 | grep clang),) +-VDSO_CAFLAGS += --target=$(notdir $(CROSS_COMPILE_COMPAT:%-=%)) +-endif +- + VDSO_CAFLAGS += $(call cc32-option,-fno-PIE) + ifdef CONFIG_DEBUG_INFO + VDSO_CAFLAGS += -g diff --git a/queue-5.10/ext4-check-for-inconsistent-extents-between-index-and-leaf-block.patch b/queue-5.10/ext4-check-for-inconsistent-extents-between-index-and-leaf-block.patch new file mode 100644 index 00000000000..46fd610c208 --- /dev/null +++ b/queue-5.10/ext4-check-for-inconsistent-extents-between-index-and-leaf-block.patch @@ -0,0 +1,199 @@ +From 9c6e071913792d80894cd0be98cc3c4b770e26d3 Mon Sep 17 00:00:00 2001 +From: Zhang Yi +Date: Wed, 8 Sep 2021 20:08:49 +0800 +Subject: ext4: check for inconsistent extents between index and leaf block + +From: Zhang Yi + +commit 9c6e071913792d80894cd0be98cc3c4b770e26d3 upstream. + +Now that we can check out overlapping extents in leaf block and +out-of-order index extents in index block. But the .ee_block in the +first extent of one leaf block should equal to the .ei_block in it's +parent index extent entry. This patch add a check to verify such +inconsistent between the index and leaf block. + +Signed-off-by: Zhang Yi +Link: https://lore.kernel.org/r/20210908120850.4012324-3-yi.zhang@huawei.com +Signed-off-by: Theodore Ts'o +Signed-off-by: Greg Kroah-Hartman +--- + fs/ext4/extents.c | 59 ++++++++++++++++++++++++++++++++---------------------- + 1 file changed, 36 insertions(+), 23 deletions(-) + +--- a/fs/ext4/extents.c ++++ b/fs/ext4/extents.c +@@ -366,7 +366,8 @@ static int ext4_valid_extent_idx(struct + + static int ext4_valid_extent_entries(struct inode *inode, + struct ext4_extent_header *eh, +- ext4_fsblk_t *pblk, int depth) ++ ext4_lblk_t lblk, ext4_fsblk_t *pblk, ++ int depth) + { + unsigned short entries; + ext4_lblk_t lblock = 0; +@@ -380,6 +381,14 @@ static int ext4_valid_extent_entries(str + if (depth == 0) { + /* leaf entries */ + struct ext4_extent *ext = EXT_FIRST_EXTENT(eh); ++ ++ /* ++ * The logical block in the first entry should equal to ++ * the number in the index block. ++ */ ++ if (depth != ext_depth(inode) && ++ lblk != le32_to_cpu(ext->ee_block)) ++ return 0; + while (entries) { + if (!ext4_valid_extent(inode, ext)) + return 0; +@@ -396,6 +405,14 @@ static int ext4_valid_extent_entries(str + } + } else { + struct ext4_extent_idx *ext_idx = EXT_FIRST_INDEX(eh); ++ ++ /* ++ * The logical block in the first entry should equal to ++ * the number in the parent index block. ++ */ ++ if (depth != ext_depth(inode) && ++ lblk != le32_to_cpu(ext_idx->ei_block)) ++ return 0; + while (entries) { + if (!ext4_valid_extent_idx(inode, ext_idx)) + return 0; +@@ -416,7 +433,7 @@ static int ext4_valid_extent_entries(str + + static int __ext4_ext_check(const char *function, unsigned int line, + struct inode *inode, struct ext4_extent_header *eh, +- int depth, ext4_fsblk_t pblk) ++ int depth, ext4_fsblk_t pblk, ext4_lblk_t lblk) + { + const char *error_msg; + int max = 0, err = -EFSCORRUPTED; +@@ -442,7 +459,7 @@ static int __ext4_ext_check(const char * + error_msg = "invalid eh_entries"; + goto corrupted; + } +- if (!ext4_valid_extent_entries(inode, eh, &pblk, depth)) { ++ if (!ext4_valid_extent_entries(inode, eh, lblk, &pblk, depth)) { + error_msg = "invalid extent entries"; + goto corrupted; + } +@@ -472,7 +489,7 @@ corrupted: + } + + #define ext4_ext_check(inode, eh, depth, pblk) \ +- __ext4_ext_check(__func__, __LINE__, (inode), (eh), (depth), (pblk)) ++ __ext4_ext_check(__func__, __LINE__, (inode), (eh), (depth), (pblk), 0) + + int ext4_ext_check_inode(struct inode *inode) + { +@@ -505,16 +522,18 @@ static void ext4_cache_extents(struct in + + static struct buffer_head * + __read_extent_tree_block(const char *function, unsigned int line, +- struct inode *inode, ext4_fsblk_t pblk, int depth, +- int flags) ++ struct inode *inode, struct ext4_extent_idx *idx, ++ int depth, int flags) + { + struct buffer_head *bh; + int err; + gfp_t gfp_flags = __GFP_MOVABLE | GFP_NOFS; ++ ext4_fsblk_t pblk; + + if (flags & EXT4_EX_NOFAIL) + gfp_flags |= __GFP_NOFAIL; + ++ pblk = ext4_idx_pblock(idx); + bh = sb_getblk_gfp(inode->i_sb, pblk, gfp_flags); + if (unlikely(!bh)) + return ERR_PTR(-ENOMEM); +@@ -527,8 +546,8 @@ __read_extent_tree_block(const char *fun + } + if (buffer_verified(bh) && !(flags & EXT4_EX_FORCE_CACHE)) + return bh; +- err = __ext4_ext_check(function, line, inode, +- ext_block_hdr(bh), depth, pblk); ++ err = __ext4_ext_check(function, line, inode, ext_block_hdr(bh), ++ depth, pblk, le32_to_cpu(idx->ei_block)); + if (err) + goto errout; + set_buffer_verified(bh); +@@ -546,8 +565,8 @@ errout: + + } + +-#define read_extent_tree_block(inode, pblk, depth, flags) \ +- __read_extent_tree_block(__func__, __LINE__, (inode), (pblk), \ ++#define read_extent_tree_block(inode, idx, depth, flags) \ ++ __read_extent_tree_block(__func__, __LINE__, (inode), (idx), \ + (depth), (flags)) + + /* +@@ -597,8 +616,7 @@ int ext4_ext_precache(struct inode *inod + i--; + continue; + } +- bh = read_extent_tree_block(inode, +- ext4_idx_pblock(path[i].p_idx++), ++ bh = read_extent_tree_block(inode, path[i].p_idx++, + depth - i - 1, + EXT4_EX_FORCE_CACHE); + if (IS_ERR(bh)) { +@@ -903,8 +921,7 @@ ext4_find_extent(struct inode *inode, ex + path[ppos].p_depth = i; + path[ppos].p_ext = NULL; + +- bh = read_extent_tree_block(inode, path[ppos].p_block, --i, +- flags); ++ bh = read_extent_tree_block(inode, path[ppos].p_idx, --i, flags); + if (IS_ERR(bh)) { + ret = PTR_ERR(bh); + goto err; +@@ -1509,7 +1526,6 @@ static int ext4_ext_search_right(struct + struct ext4_extent_header *eh; + struct ext4_extent_idx *ix; + struct ext4_extent *ex; +- ext4_fsblk_t block; + int depth; /* Note, NOT eh_depth; depth from top of tree */ + int ee_len; + +@@ -1576,20 +1592,17 @@ got_index: + * follow it and find the closest allocated + * block to the right */ + ix++; +- block = ext4_idx_pblock(ix); + while (++depth < path->p_depth) { + /* subtract from p_depth to get proper eh_depth */ +- bh = read_extent_tree_block(inode, block, +- path->p_depth - depth, 0); ++ bh = read_extent_tree_block(inode, ix, path->p_depth - depth, 0); + if (IS_ERR(bh)) + return PTR_ERR(bh); + eh = ext_block_hdr(bh); + ix = EXT_FIRST_INDEX(eh); +- block = ext4_idx_pblock(ix); + put_bh(bh); + } + +- bh = read_extent_tree_block(inode, block, path->p_depth - depth, 0); ++ bh = read_extent_tree_block(inode, ix, path->p_depth - depth, 0); + if (IS_ERR(bh)) + return PTR_ERR(bh); + eh = ext_block_hdr(bh); +@@ -2968,9 +2981,9 @@ again: + ext_debug(inode, "move to level %d (block %llu)\n", + i + 1, ext4_idx_pblock(path[i].p_idx)); + memset(path + i + 1, 0, sizeof(*path)); +- bh = read_extent_tree_block(inode, +- ext4_idx_pblock(path[i].p_idx), depth - i - 1, +- EXT4_EX_NOCACHE); ++ bh = read_extent_tree_block(inode, path[i].p_idx, ++ depth - i - 1, ++ EXT4_EX_NOCACHE); + if (IS_ERR(bh)) { + /* should we reset i_size? */ + err = PTR_ERR(bh); diff --git a/queue-5.10/ext4-check-for-out-of-order-index-extents-in-ext4_valid_extent_entries.patch b/queue-5.10/ext4-check-for-out-of-order-index-extents-in-ext4_valid_extent_entries.patch new file mode 100644 index 00000000000..b4ac02fed09 --- /dev/null +++ b/queue-5.10/ext4-check-for-out-of-order-index-extents-in-ext4_valid_extent_entries.patch @@ -0,0 +1,78 @@ +From 8dd27fecede55e8a4e67eef2878040ecad0f0d33 Mon Sep 17 00:00:00 2001 +From: Zhang Yi +Date: Wed, 8 Sep 2021 20:08:48 +0800 +Subject: ext4: check for out-of-order index extents in ext4_valid_extent_entries() + +From: Zhang Yi + +commit 8dd27fecede55e8a4e67eef2878040ecad0f0d33 upstream. + +After commit 5946d089379a ("ext4: check for overlapping extents in +ext4_valid_extent_entries()"), we can check out the overlapping extent +entry in leaf extent blocks. But the out-of-order extent entry in index +extent blocks could also trigger bad things if the filesystem is +inconsistent. So this patch add a check to figure out the out-of-order +index extents and return error. + +Signed-off-by: Zhang Yi +Reviewed-by: Theodore Ts'o +Link: https://lore.kernel.org/r/20210908120850.4012324-2-yi.zhang@huawei.com +Signed-off-by: Theodore Ts'o +Signed-off-by: Greg Kroah-Hartman +--- + fs/ext4/extents.c | 17 ++++++++++++----- + 1 file changed, 12 insertions(+), 5 deletions(-) + +--- a/fs/ext4/extents.c ++++ b/fs/ext4/extents.c +@@ -369,6 +369,9 @@ static int ext4_valid_extent_entries(str + ext4_fsblk_t *pblk, int depth) + { + unsigned short entries; ++ ext4_lblk_t lblock = 0; ++ ext4_lblk_t prev = 0; ++ + if (eh->eh_entries == 0) + return 1; + +@@ -377,31 +380,35 @@ static int ext4_valid_extent_entries(str + if (depth == 0) { + /* leaf entries */ + struct ext4_extent *ext = EXT_FIRST_EXTENT(eh); +- ext4_lblk_t lblock = 0; +- ext4_lblk_t prev = 0; +- int len = 0; + while (entries) { + if (!ext4_valid_extent(inode, ext)) + return 0; + + /* Check for overlapping extents */ + lblock = le32_to_cpu(ext->ee_block); +- len = ext4_ext_get_actual_len(ext); + if ((lblock <= prev) && prev) { + *pblk = ext4_ext_pblock(ext); + return 0; + } ++ prev = lblock + ext4_ext_get_actual_len(ext) - 1; + ext++; + entries--; +- prev = lblock + len - 1; + } + } else { + struct ext4_extent_idx *ext_idx = EXT_FIRST_INDEX(eh); + while (entries) { + if (!ext4_valid_extent_idx(inode, ext_idx)) + return 0; ++ ++ /* Check for overlapping index extents */ ++ lblock = le32_to_cpu(ext_idx->ei_block); ++ if ((lblock <= prev) && prev) { ++ *pblk = ext4_idx_pblock(ext_idx); ++ return 0; ++ } + ext_idx++; + entries--; ++ prev = lblock; + } + } + return 1; diff --git a/queue-5.10/ext4-prevent-partial-update-of-the-extent-blocks.patch b/queue-5.10/ext4-prevent-partial-update-of-the-extent-blocks.patch new file mode 100644 index 00000000000..1bcf52d410d --- /dev/null +++ b/queue-5.10/ext4-prevent-partial-update-of-the-extent-blocks.patch @@ -0,0 +1,69 @@ +From 0f2f87d51aebcf71a709b52f661d681594c7dffa Mon Sep 17 00:00:00 2001 +From: Zhang Yi +Date: Wed, 8 Sep 2021 20:08:50 +0800 +Subject: ext4: prevent partial update of the extent blocks + +From: Zhang Yi + +commit 0f2f87d51aebcf71a709b52f661d681594c7dffa upstream. + +In the most error path of current extents updating operations are not +roll back partial updates properly when some bad things happens(.e.g in +ext4_ext_insert_extent()). So we may get an inconsistent extents tree +if journal has been aborted due to IO error, which may probability lead +to BUGON later when we accessing these extent entries in errors=continue +mode. This patch drop extent buffer's verify flag before updatng the +contents in ext4_ext_get_access(), and reset it after updating in +__ext4_ext_dirty(). After this patch we could force to check the extent +buffer if extents tree updating was break off, make sure the extents are +consistent. + +Signed-off-by: Zhang Yi +Reviewed-by: Theodore Ts'o +Link: https://lore.kernel.org/r/20210908120850.4012324-4-yi.zhang@huawei.com +Signed-off-by: Theodore Ts'o +Signed-off-by: Greg Kroah-Hartman + +--- + fs/ext4/extents.c | 17 +++++++++++++++-- + 1 file changed, 15 insertions(+), 2 deletions(-) + +--- a/fs/ext4/extents.c ++++ b/fs/ext4/extents.c +@@ -136,14 +136,24 @@ int ext4_datasem_ensure_credits(handle_t + static int ext4_ext_get_access(handle_t *handle, struct inode *inode, + struct ext4_ext_path *path) + { ++ int err = 0; ++ + if (path->p_bh) { + /* path points to block */ + BUFFER_TRACE(path->p_bh, "get_write_access"); +- return ext4_journal_get_write_access(handle, path->p_bh); ++ err = ext4_journal_get_write_access(handle, path->p_bh); ++ /* ++ * The extent buffer's verified bit will be set again in ++ * __ext4_ext_dirty(). We could leave an inconsistent ++ * buffer if the extents updating procudure break off du ++ * to some error happens, force to check it again. ++ */ ++ if (!err) ++ clear_buffer_verified(path->p_bh); + } + /* path points to leaf/index in inode body */ + /* we use in-core data, no need to protect them */ +- return 0; ++ return err; + } + + /* +@@ -164,6 +174,9 @@ static int __ext4_ext_dirty(const char * + /* path points to block */ + err = __ext4_handle_dirty_metadata(where, line, handle, + inode, path->p_bh); ++ /* Extents updating done, re-set verified flag */ ++ if (!err) ++ set_buffer_verified(path->p_bh); + } else { + /* path points to leaf/index in inode body */ + err = ext4_mark_inode_dirty(handle, inode); diff --git a/queue-5.10/net-usb-lan78xx-add-allied-telesis-at29m2-af.patch b/queue-5.10/net-usb-lan78xx-add-allied-telesis-at29m2-af.patch new file mode 100644 index 00000000000..be1753b02b8 --- /dev/null +++ b/queue-5.10/net-usb-lan78xx-add-allied-telesis-at29m2-af.patch @@ -0,0 +1,42 @@ +From ef8a0f6eab1ca5d1a75c242c5c7b9d386735fa0a Mon Sep 17 00:00:00 2001 +From: Greg Jesionowski +Date: Tue, 14 Dec 2021 15:10:27 -0700 +Subject: net: usb: lan78xx: add Allied Telesis AT29M2-AF + +From: Greg Jesionowski + +commit ef8a0f6eab1ca5d1a75c242c5c7b9d386735fa0a upstream. + +This adds the vendor and product IDs for the AT29M2-AF which is a +lan7801-based device. + +Signed-off-by: Greg Jesionowski +Link: https://lore.kernel.org/r/20211214221027.305784-1-jesionowskigreg@gmail.com +Signed-off-by: Jakub Kicinski +Signed-off-by: Greg Kroah-Hartman +--- + drivers/net/usb/lan78xx.c | 6 ++++++ + 1 file changed, 6 insertions(+) + +--- a/drivers/net/usb/lan78xx.c ++++ b/drivers/net/usb/lan78xx.c +@@ -64,6 +64,8 @@ + #define LAN7801_USB_PRODUCT_ID (0x7801) + #define LAN78XX_EEPROM_MAGIC (0x78A5) + #define LAN78XX_OTP_MAGIC (0x78F3) ++#define AT29M2AF_USB_VENDOR_ID (0x07C9) ++#define AT29M2AF_USB_PRODUCT_ID (0x0012) + + #define MII_READ 1 + #define MII_WRITE 0 +@@ -4142,6 +4144,10 @@ static const struct usb_device_id produc + /* LAN7801 USB Gigabit Ethernet Device */ + USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7801_USB_PRODUCT_ID), + }, ++ { ++ /* ATM2-AF USB Gigabit Ethernet Device */ ++ USB_DEVICE(AT29M2AF_USB_VENDOR_ID, AT29M2AF_USB_PRODUCT_ID), ++ }, + {}, + }; + MODULE_DEVICE_TABLE(usb, products); diff --git a/queue-5.10/series b/queue-5.10/series new file mode 100644 index 00000000000..3c8639fb41c --- /dev/null +++ b/queue-5.10/series @@ -0,0 +1,6 @@ +arm64-vdso32-drop-no-integrated-as-flag.patch +arm64-vdso32-require-cross_compile_compat-for-gcc-bfd.patch +net-usb-lan78xx-add-allied-telesis-at29m2-af.patch +ext4-prevent-partial-update-of-the-extent-blocks.patch +ext4-check-for-out-of-order-index-extents-in-ext4_valid_extent_entries.patch +ext4-check-for-inconsistent-extents-between-index-and-leaf-block.patch