From nobody Wed Apr 8 03:07:14 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7E1A1FA373D for ; Fri, 21 Oct 2022 16:41:37 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231506AbiJUQld (ORCPT ); Fri, 21 Oct 2022 12:41:33 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53968 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231277AbiJUQj6 (ORCPT ); Fri, 21 Oct 2022 12:39:58 -0400 Received: from mail-vs1-xe49.google.com (mail-vs1-xe49.google.com [IPv6:2607:f8b0:4864:20::e49]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 536DD238247 for ; Fri, 21 Oct 2022 09:38:04 -0700 (PDT) Received: by mail-vs1-xe49.google.com with SMTP id m186-20020a6726c3000000b0039b2e2e040dso1041533vsm.9 for ; Fri, 21 Oct 2022 09:38:04 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=qP1ClP7q+g5S/3EyNUqzGRFXdONCD3+1un/KPsFlt6w=; b=QMIS+S3FZjAOFL/rBkRiry87Th5Kd5EwT0c05LySCp4nkCaELh/zdUD5+Aa9N/+7D7 SttWCG9Hi3HpsVOYK516SluMw+1U5skL5XiUCiezO60dxluHkHXNJD2BPxzYy9ElIoIo CqVjIAYat6VGsTooAFXgZhyY31kEJ2Pb7dKKQXnSZh6pHHmXteCqEnslryEPoKlJ/1HL ZJ2O0i+mmtp0eV1DkFySFLMzu3xcpuYZRBOXaXNztWI6gXkUaHxqX1Lu3FuqcpPbUo/J YTGrOVJlkmeX1/WedJcVMPwDEck6qTmRFmeRuAAp5UxDdvPetKdD3Fa+pCCwGznSQq8b F+kg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=qP1ClP7q+g5S/3EyNUqzGRFXdONCD3+1un/KPsFlt6w=; b=ZURbbmxFqfyo1vrwHNokNDYctS0PheIjzcA+iU1rxyWOmZ6fPlA9qGhk5V4bqKQrpE Yws7FbDQSiBYcHYAJGQGwfOU5i75FLzFb3o413QEMtr0wp9kqQOcLZ+hdlgDczneu7oF A9y955SMJGnvDwYW5gNTaY7RA7ZVqRUlE/h+9bLnP+Kh5FcZHQzNWOvz0PEEogoMvbNj 8DPm42Lu4CTFSWdTc5XIdKSlz0QBRZJwdPcNtJKCCqFxaFE1op+uVkd6xl19uTmrMGfN JzywLTmMsNPDg7+YI4MKcHiqb9wuqlyLwv7+FkoFTCX4O1Ft26EIugVWO2dMV62Eu49S oAQQ== X-Gm-Message-State: ACrzQf3z9dpK+pxvpNcH52MloQtMpuvpvwz56jSbrgdEIu7lbaMVgsDP QL0pFr0l+09fcQj4goo0ByhoZ0N/E/U+bLv9 X-Google-Smtp-Source: AMsMyM4IUmuvbEMg95LOcPWISiFLwBaVK46TD/2jo2TirSfe33B71xuI4Gxr0O7eiTjo3WhjYikEb+f+W3ttCA5W X-Received: from jthoughton.c.googlers.com ([fda3:e722:ac3:cc00:14:4d90:c0a8:2a4f]) (user=jthoughton job=sendgmr) by 2002:a05:6102:3d99:b0:3a9:5976:cd84 with SMTP id h25-20020a0561023d9900b003a95976cd84mr12345154vsv.4.1666370280478; Fri, 21 Oct 2022 09:38:00 -0700 (PDT) Date: Fri, 21 Oct 2022 16:37:03 +0000 In-Reply-To: <20221021163703.3218176-1-jthoughton@google.com> Mime-Version: 1.0 References: <20221021163703.3218176-1-jthoughton@google.com> X-Mailer: git-send-email 2.38.0.135.g90850a2211-goog Message-ID: <20221021163703.3218176-48-jthoughton@google.com> Subject: [RFC PATCH v2 47/47] selftests/vm: add HGM UFFDIO_CONTINUE and hwpoison tests From: James Houghton To: Mike Kravetz , Muchun Song , Peter Xu Cc: David Hildenbrand , David Rientjes , Axel Rasmussen , Mina Almasry , "Zach O'Keefe" , Manish Mishra , Naoya Horiguchi , "Dr . David Alan Gilbert" , "Matthew Wilcox (Oracle)" , Vlastimil Babka , Baolin Wang , Miaohe Lin , Yang Shi , Andrew Morton , linux-mm@kvack.org, linux-kernel@vger.kernel.org, James Houghton Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" This tests that high-granularity CONTINUEs at all sizes work (exercising contiguous PTE sizes for arm64, when support is added). This also tests that collapse works and hwpoison works correctly (although we aren't yet testing high-granularity poison). Signed-off-by: James Houghton --- tools/testing/selftests/vm/Makefile | 1 + tools/testing/selftests/vm/hugetlb-hgm.c | 326 +++++++++++++++++++++++ 2 files changed, 327 insertions(+) create mode 100644 tools/testing/selftests/vm/hugetlb-hgm.c diff --git a/tools/testing/selftests/vm/Makefile b/tools/testing/selftests/= vm/Makefile index 00920cb8b499..da1e01a5ac9b 100644 --- a/tools/testing/selftests/vm/Makefile +++ b/tools/testing/selftests/vm/Makefile @@ -32,6 +32,7 @@ TEST_GEN_FILES +=3D compaction_test TEST_GEN_FILES +=3D gup_test TEST_GEN_FILES +=3D hmm-tests TEST_GEN_FILES +=3D hugetlb-madvise +TEST_GEN_FILES +=3D hugetlb-hgm TEST_GEN_FILES +=3D hugepage-mmap TEST_GEN_FILES +=3D hugepage-mremap TEST_GEN_FILES +=3D hugepage-shm diff --git a/tools/testing/selftests/vm/hugetlb-hgm.c b/tools/testing/selft= ests/vm/hugetlb-hgm.c new file mode 100644 index 000000000000..e36a1c988bb4 --- /dev/null +++ b/tools/testing/selftests/vm/hugetlb-hgm.c @@ -0,0 +1,326 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Test uncommon cases in HugeTLB high-granularity mapping: + * 1. Test all supported high-granularity page sizes (with MADV_COLLAPSE). + * 2. Test MADV_HWPOISON behavior. + */ + +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#define PAGE_MASK ~(4096 - 1) + +#ifndef MADV_COLLAPSE +#define MADV_COLLAPSE 25 +#endif + +#define PREFIX " ... " + +int userfaultfd(int flags) +{ + return syscall(__NR_userfaultfd, flags); +} + +int map_range(int uffd, char *addr, uint64_t length) +{ + struct uffdio_continue cont =3D { + .range =3D (struct uffdio_range) { + .start =3D (uint64_t)addr, + .len =3D length, + }, + .mode =3D 0, + .mapped =3D 0, + }; + + if (ioctl(uffd, UFFDIO_CONTINUE, &cont) < 0) { + perror("UFFDIO_CONTINUE failed"); + return -1; + } + return 0; +} + +int check_equal(char *mapping, size_t length, char value) +{ + size_t i; + + for (i =3D 0; i < length; ++i) + if (mapping[i] !=3D value) { + printf("mismatch at %p (%d !=3D %d)\n", &mapping[i], + mapping[i], value); + return -1; + } + + return 0; +} + +int test_continues(int uffd, char *primary_map, char *secondary_map, size_= t len, + bool verify) +{ + size_t offset =3D 0; + unsigned char iter =3D 0; + unsigned long pagesize =3D getpagesize(); + uint64_t size; + + for (size =3D len/2; size >=3D pagesize; + offset +=3D size, size /=3D 2) { + iter++; + memset(secondary_map + offset, iter, size); + printf(PREFIX "UFFDIO_CONTINUE: %p -> %p =3D %d%s\n", + primary_map + offset, + primary_map + offset + size, + iter, + verify ? " (and verify)" : ""); + if (map_range(uffd, primary_map + offset, size)) + return -1; + if (verify && check_equal(primary_map + offset, size, iter)) + return -1; + } + return 0; +} + +int test_collapse(char *primary_map, size_t len, bool hwpoison) +{ + size_t offset; + int i; + uint64_t size; + + printf(PREFIX "collapsing %p -> %p\n", primary_map, primary_map + len); + if (madvise(primary_map, len, MADV_COLLAPSE) < 0) { + if (errno =3D=3D EHWPOISON && hwpoison) { + /* this is expected for the hwpoison test. */ + printf(PREFIX "could not collapse due to poison\n"); + return 0; + } + perror("collapse failed"); + return -1; + } + + printf(PREFIX "verifying %p -> %p\n", primary_map, primary_map + len); + + offset =3D 0; + i =3D 0; + for (size =3D len/2; size > 4096; offset +=3D size, size /=3D 2) { + if (check_equal(primary_map + offset, size, ++i)) + return -1; + } + /* expect the last 4K to be zero. */ + if (check_equal(primary_map + len - 4096, 4096, 0)) + return -1; + + return 0; +} + +static void *poisoned_addr; + +void sigbus_handler(int signo, siginfo_t *info, void *context) +{ + if (info->si_code !=3D BUS_MCEERR_AR) + goto kill; + poisoned_addr =3D info->si_addr; +kill: + pthread_exit(NULL); +} + +void *access_mem(void *addr) +{ + volatile char *ptr =3D addr; + + *ptr; + return NULL; +} + +int test_poison_sigbus(char *addr) +{ + int ret =3D 0; + pthread_t pthread; + + poisoned_addr =3D (void *)0xBADBADBAD; + ret =3D pthread_create(&pthread, NULL, &access_mem, addr); + if (pthread_create(&pthread, NULL, &access_mem, addr)) { + printf("failed to create thread: %s\n", strerror(ret)); + return ret; + } + + pthread_join(pthread, NULL); + if (poisoned_addr !=3D addr) { + printf("got incorrect poisoned address: %p vs %p\n", + poisoned_addr, addr); + return -1; + } + return 0; +} + +int test_hwpoison(char *primary_map, size_t len) +{ + const unsigned long pagesize =3D getpagesize(); + const int num_poison_checks =3D 512; + unsigned long bytes_per_check =3D len/num_poison_checks; + struct sigaction new, old; + int i; + + printf(PREFIX "poisoning %p -> %p\n", primary_map, primary_map + len); + if (madvise(primary_map, len, MADV_HWPOISON) < 0) { + perror("MADV_HWPOISON failed"); + return -1; + } + + printf(PREFIX "checking that it was poisoned " + "(%d addresses within %p -> %p)\n", + num_poison_checks, primary_map, primary_map + len); + + new.sa_sigaction =3D &sigbus_handler; + new.sa_flags =3D SA_SIGINFO; + if (sigaction(SIGBUS, &new, &old) < 0) { + perror("could not setup SIGBUS handler"); + return -1; + } + + if (pagesize > bytes_per_check) + bytes_per_check =3D pagesize; + + for (i =3D 0; i < len; i +=3D bytes_per_check) + if (test_poison_sigbus(primary_map + i) < 0) + return -1; + /* check very last byte, because we left it unmapped */ + if (test_poison_sigbus(primary_map + len - 1)) + return -1; + + return 0; +} + +int test_hgm(int fd, size_t hugepagesize, size_t len, bool hwpoison) +{ + int ret =3D 0; + int uffd; + char *primary_map, *secondary_map; + struct uffdio_api api; + struct uffdio_register reg; + + if (ftruncate(fd, len) < 0) { + perror("ftruncate failed"); + return -1; + } + + uffd =3D userfaultfd(O_CLOEXEC | O_NONBLOCK); + if (uffd < 0) { + perror("uffd not created"); + return -1; + } + + primary_map =3D mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0= ); + if (primary_map =3D=3D MAP_FAILED) { + perror("mmap for primary mapping failed"); + ret =3D -1; + goto close_uffd; + } + secondary_map =3D mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd,= 0); + if (secondary_map =3D=3D MAP_FAILED) { + perror("mmap for secondary mapping failed"); + ret =3D -1; + goto unmap_primary; + } + + printf(PREFIX "primary mapping: %p\n", primary_map); + printf(PREFIX "secondary mapping: %p\n", secondary_map); + + api.api =3D UFFD_API; + api.features =3D UFFD_FEATURE_MINOR_HUGETLBFS | + UFFD_FEATURE_MISSING_HUGETLBFS | + UFFD_FEATURE_MINOR_HUGETLBFS_HGM | UFFD_FEATURE_SIGBUS | + UFFD_FEATURE_EXACT_ADDRESS; + if (ioctl(uffd, UFFDIO_API, &api) =3D=3D -1) { + perror("UFFDIO_API failed"); + ret =3D -1; + goto out; + } + if (!(api.features & UFFD_FEATURE_MINOR_HUGETLBFS_HGM)) { + puts("UFFD_FEATURE_MINOR_HUGETLBFS_HGM not present"); + ret =3D -1; + goto out; + } + + reg.range.start =3D (unsigned long)primary_map; + reg.range.len =3D len; + reg.mode =3D UFFDIO_REGISTER_MODE_MINOR | UFFDIO_REGISTER_MODE_MISSING; + reg.ioctls =3D 0; + if (ioctl(uffd, UFFDIO_REGISTER, ®) =3D=3D -1) { + perror("register failed"); + ret =3D -1; + goto out; + } + + if (test_continues(uffd, primary_map, secondary_map, len, !hwpoison) + || (hwpoison && test_hwpoison(primary_map, len)) + || test_collapse(primary_map, len, hwpoison)) { + ret =3D -1; + } + + if (ftruncate(fd, 0) < 0) { + perror("ftruncate back to 0 failed"); + ret =3D -1; + } + +out: + munmap(secondary_map, len); +unmap_primary: + munmap(primary_map, len); +close_uffd: + close(uffd); + return ret; +} + +int main(void) +{ + int fd; + struct statfs file_stat; + size_t hugepagesize; + size_t len; + + fd =3D memfd_create("hugetlb_tmp", MFD_HUGETLB); + if (fd < 0) { + perror("could not open hugetlbfs file"); + return -1; + } + + memset(&file_stat, 0, sizeof(file_stat)); + if (fstatfs(fd, &file_stat)) { + perror("fstatfs failed"); + goto close; + } + if (file_stat.f_type !=3D HUGETLBFS_MAGIC) { + printf("not hugetlbfs file\n"); + goto close; + } + + hugepagesize =3D file_stat.f_bsize; + len =3D 2 * hugepagesize; + printf("HGM regular test...\n"); + printf("HGM regular test: %s\n", + test_hgm(fd, hugepagesize, len, false) + ? "FAILED" : "PASSED"); + printf("HGM hwpoison test...\n"); + printf("HGM hwpoison test: %s\n", + test_hgm(fd, hugepagesize, len, true) + ? "FAILED" : "PASSED"); +close: + close(fd); + + return 0; +} --=20 2.38.0.135.g90850a2211-goog