Messages in this thread | | | Subject | Re: [PATCH v2] mm: migrate: Fix THP's mapcount on isolation | From | Gavin Shan <> | Date | Thu, 24 Nov 2022 20:55:39 +0800 |
| |
On 11/24/22 6:43 PM, David Hildenbrand wrote: > On 24.11.22 11:21, Gavin Shan wrote: >> On 11/24/22 6:09 PM, David Hildenbrand wrote: >>> On 24.11.22 10:55, Gavin Shan wrote: >>>> The issue is reported when removing memory through virtio_mem device. >>>> The transparent huge page, experienced copy-on-write fault, is wrongly >>>> regarded as pinned. The transparent huge page is escaped from being >>>> isolated in isolate_migratepages_block(). The transparent huge page >>>> can't be migrated and the corresponding memory block can't be put >>>> into offline state. >>>> >>>> Fix it by replacing page_mapcount() with total_mapcount(). With this, >>>> the transparent huge page can be isolated and migrated, and the memory >>>> block can be put into offline state. Besides, The page's refcount is >>>> increased a bit earlier to avoid the page is released when the check >>>> is executed. >>> >>> Did you look into handling pages that are in the swapcache case as well? >>> >>> See is_refcount_suitable() in mm/khugepaged.c. >>> >>> Should be easy to reproduce, let me know if you need inspiration. >>> >> >> Nope, I didn't look into the case. Please elaborate the details so that >> I can reproduce it firstly. > > > A simple reproducer would be (on a system with ordinary swap (not zram)) > > 1) mmap a region (MAP_ANON|MAP_PRIVATE) that can hold a THP > > 2) Enable THP for that region (MADV_HUGEPAGE) > > 3) Populate a THP (e.g., write access) > > 4) PTE-map the THP, for example, using MADV_FREE on the last subpage > > 5) Trigger swapout of the THP, for example, using MADV_PAGEOUT > > 6) Read-access to some subpages to fault them in from the swapcache > > > Now you'd have a THP, which > > 1) Is partially PTE-mapped into the page table > 2) Is in the swapcache (each subpage should have one reference from the swapache) > > > Now we could test, if alloc_contig_range() will still succeed (e.g., using virtio-mem). >
Thanks for the details. Step (4) and (5) can be actually combined. To swap part of the THP (e.g. one sub-page) will force the THP to be split.
I followed your steps in the attached program, there is no issue to do memory hot-remove through virtio-mem with or without this patch.
# numactl -p 1 testsuite mm swap -k Any key to split THP Any key to swap sub-pages Any key to read the swapped sub-pages Page[000]: 0xffffffffffffffff Page[001]: 0xffffffffffffffff : Page[255]: 0xffffffffffffffff Any key to exit // hold here and the program doesn't exit
(qemu) qom-set vm1 requested-size 0 [ 356.005396] virtio_mem virtio1: plugged size: 0x40000000 [ 356.005996] virtio_mem virtio1: requested size: 0x0 [ 356.350299] Fallback order for Node 0: 0 1 [ 356.350810] Fallback order for Node 1: 1 0 [ 356.351260] Built 2 zonelists, mobility grouping on. Total pages: 491343 [ 356.351998] Policy zone: DMA
Thanks, Gavin #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/wait.h> #include <fcntl.h> #include <sys/mman.h> #include <errno.h>
#include "inc/testsuite.h"
struct swap_struct { int page_size;
int fd; int flags; void *buf; unsigned long len;
int key_break; };
#define SWAP_DEFAULT_SIZE 0x200000 /* 2MB */ #define SWAP_PAGE_TO_SPLIT 511 #define SWAP_PAGE_TO_SWAP 1 #define SWAP_PAGE_TO_SWAP_NUM 256
#ifndef MADV_PAGEOUT #define MADV_PAGEOUT 21 #endif
static void usage(void) { fprintf(stdout, "testsuite mm swap -l <size> -k\n"); fprintf(stdout, "\n"); fprintf(stdout, "-l: Length of memory to be mapped\n"); fprintf(stdout, "-w: Length of memory to be copied-on-write\n"); fprintf(stdout, "-k: Stop at various stages\n"); fprintf(stdout, "\n"); }
static int swap_init_data(struct swap_struct *m) { m->page_size = getpagesize();
m->fd = -1; m->flags = (MAP_PRIVATE | MAP_ANONYMOUS); m->len = SWAP_DEFAULT_SIZE; m->key_break = 0;
return 0; }
static int swap_handler(int argc, char **argv) { struct swap_struct m; unsigned long *pval; int i, opt, ret;
ret = swap_init_data(&m); if (ret) return ret;
while ((opt = getopt(argc, argv, "l:w:kh")) != -1) { switch (opt) { case 'l': m.len = util_memory_parse_size(optarg); if (m.len <= SWAP_DEFAULT_SIZE) { fprintf(stderr, "%s: length 0x%lx less than 0x%x\n", __func__, m.len, SWAP_DEFAULT_SIZE); return -1; }
break; case 'k': m.key_break = 1; break; case 'h': usage(); return 0; } }
/* * Setup the area. The area should be backed up with huge pages * if it suits. Write to the area to ensure the area is populted * completely. */ m.buf = mmap(NULL, m.len, PROT_READ | PROT_WRITE, m.flags, m.fd, 0); if (m.buf == (void *)-1) { fprintf(stderr, "Unable do mmap()\n"); goto out; }
memset(m.buf, 0xff, m.len);
/* Force to split the huge page */ util_misc_key_press(m.key_break, " ", "Any key to split THP"); ret = madvise(m.buf + SWAP_PAGE_TO_SPLIT * m.page_size, m.page_size, MADV_FREE); if (ret) { fprintf(stderr, "Error %d to split THP\n", ret); goto out; }
/* Swap one sub-page */ util_misc_key_press(m.key_break, " ", "Any key to swap sub-pages"); ret = madvise(m.buf + SWAP_PAGE_TO_SWAP * m.page_size, SWAP_PAGE_TO_SWAP_NUM * m.page_size, MADV_PAGEOUT); if (ret) { fprintf(stderr, "Error %d to swap one sub-page\n", ret); goto out; }
/* Read the swapped sub-page */ util_misc_key_press(m.key_break, " ", "Any key to read the swapped sub-pages"); for (i = 0; i < SWAP_PAGE_TO_SWAP_NUM; i++) { pval = (unsigned long *)(m.buf + (SWAP_PAGE_TO_SWAP + i) * m.page_size); fprintf(stdout, " Page[%03d]: 0x%016lx\n", i, *pval); }
/* Exit */ util_misc_key_press(m.key_break, " ", "Any key to exit");
out: if (m.buf != (void *)-1) munmap(m.buf, m.len); if (m.fd > 0) close(m.fd);
return 0; }
static struct command swap_command = { .name = "swap", .handler = swap_handler, .children = LIST_HEAD_INIT(swap_command.children), .link = LIST_HEAD_INIT(swap_command.link), };
int mm_swap_init(void) { return command_add(&mm_command, &swap_command); }
| |