Re: [PATCH v14 8/8] lib/tests: memcpy_kunit: add memcpy_mc() and memcpy_mc_large() test

[Shuai Xue]

On 5/18/26 4:49 PM, Ruidong Tian wrote:

memcpy_mc() is the Machine-Check safe memcpy variant that returns the
number of bytes NOT copied on a hardware memory error, or 0 on success.

Add two test cases modeled after the existing memcpy_test() and
memcpy_large_test() implementations:

Same build issue as with copy_mc_page_test: memcpy_mc() is an arm64-
only symbol.

1. Cross-architecture build break (BLOCKER, same as patch 6)

   These tests are gated on CONFIG_ARCH_HAS_COPY_MC, which is also
   selected by x86_64 and ppc64. Neither architecture provides a
   memcpy_mc() symbol -- they use copy_mc_to_kernel() directly.

   On x86_64:

       lib/tests/memcpy_kunit.c: error: implicit declaration of
       function 'memcpy_mc' [-Werror=implicit-function-declaration]

   Fix: guard with __HAVE_ARCH_MEMCPY_MC instead:

       #ifdef __HAVE_ARCH_MEMCPY_MC
       static void memcpy_mc_test(...) { ... }
       static void memcpy_mc_large_test(...) { ... }
       #endif

Signed-off-by: Ruidong Tian <tianruid...@linux.alibaba.com>
---
  lib/tests/memcpy_kunit.c | 113 ++++++++++++++++++++++++++++++++++++++-
  1 file changed, 112 insertions(+), 1 deletion(-)

diff --git a/lib/tests/memcpy_kunit.c b/lib/tests/memcpy_kunit.c
index 85df53ccfb0c..b4b2dafb50f1 100644
--- a/lib/tests/memcpy_kunit.c
+++ b/lib/tests/memcpy_kunit.c
@@ -552,6 +552,115 @@ static void copy_mc_page_test(struct kunit *test)
                memcmp(page_dst + PAGE_SIZE, page_zero, PAGE_SIZE), 0,
                "copy_mc_page overflow into adjacent page");
  }
+/*
+ * memcpy_mc() is a Machine-Check safe memcpy variant.
+ * Signature: int memcpy_mc(void *dst, const void *src, size_t len)
+ * Returns:   0 on success, or number of bytes NOT copied on MC error.
+ *
+ * In the normal (no-poison) path it must behave identically to memcpy()
+ * and always return 0.
+ */
+static void memcpy_mc_test(struct kunit *test)
+{
+#define TEST_OP "memcpy_mc"
+       struct some_bytes control = {
+               .data = { 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+                         0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+                         0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+                         0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+               },
+       };
+       struct some_bytes zero = { };
+       struct some_bytes middle = {
+               .data = { 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+                         0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00,
+                         0x00, 0x00, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20,
+                         0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+               },
+       };
+       struct some_bytes three = {
+               .data = { 0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+                         0x20, 0x00, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20,
+                         0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+                         0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+                       },
+       };
+       struct some_bytes dest = { };
+       int ret, count;
+       u8 *ptr;
+
+       /* Verify static initializers. */
+       check(control, 0x20);
+       check(zero, 0);
+       compare("static initializers", dest, zero);
+
+       /* Verify assignment. */
+       dest = control;
+       compare("direct assignment", dest, control);
+
+       /* Verify complete overwrite. */
+       ret = memcpy_mc(dest.data, control.data, sizeof(dest.data));
+       KUNIT_ASSERT_EQ(test, ret, 0);
+       compare("complete overwrite", dest, control);
+
+       /* Verify middle overwrite: 7 bytes at offset 12. */
+       dest = control;
+       ret = memcpy_mc(dest.data + 12, zero.data, 7);
+       KUNIT_ASSERT_EQ(test, ret, 0);
+       compare("middle overwrite", dest, middle);
+
+       /* Verify zero-length copy is a no-op. */
+       dest = control;
+       ret = memcpy_mc(dest.data, zero.data, 0);
+       KUNIT_ASSERT_EQ(test, ret, 0);
+       compare("zero length", dest, control);
+
+       /* Verify argument side-effects aren't repeated. */
+       dest = control;
+       ptr = dest.data;
+       count = 1;
+       memcpy(ptr++, zero.data, count++);
+       ptr += 8;
+       memcpy(ptr++, zero.data, count++);

   This is a verbatim paste from memcpy_test(). The intent is to
   verify that the memcpy_mc macro doesn't double-evaluate arguments,
   but the test doesn't actually call memcpy_mc(). Please change the
   two memcpy() calls to memcpy_mc() and assert their return values.

Thanks
Shuai