diff options
Diffstat (limited to 'tsrc/thugetlb.c')
-rw-r--r-- | tsrc/thugetlb.c | 359 |
1 files changed, 359 insertions, 0 deletions
diff --git a/tsrc/thugetlb.c b/tsrc/thugetlb.c new file mode 100644 index 0000000..35e0b7e --- /dev/null +++ b/tsrc/thugetlb.c @@ -0,0 +1,359 @@ +/* + * Test program for memory error handling for hugepages + * Author: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com> + */ +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <fcntl.h> +#include <signal.h> +#include <unistd.h> +#include <getopt.h> +#include <sys/mman.h> +#include <sys/ipc.h> +#include <sys/shm.h> +#include <sys/sem.h> +#include <sys/types.h> +#include <sys/prctl.h> + +#define FILE_BASE "test" + +#define HPAGE_SIZE (2UL*1024*1024) +#define BUF_SIZE 256 +#define PROTECTION (PROT_READ | PROT_WRITE) + +#ifndef SHM_HUGETLB +#define SHM_HUGETLB 04000 +#endif + +/* Control early_kill/late_kill */ +#define PR_MCE_KILL 33 +#define PR_MCE_KILL_CLEAR 0 +#define PR_MCE_KILL_SET 1 +#define PR_MCE_KILL_LATE 0 +#define PR_MCE_KILL_EARLY 1 +#define PR_MCE_KILL_DEFAULT 2 +#define PR_MCE_KILL_GET 34 + +int PS; /* Page size */ +int file_size; /* Memory allocation size (hugepage unit) */ +/* Error injection position (page offset from the first hugepage head) */ +int corrupt_page; +char filename[BUF_SIZE] = "/test"; +char filepath[BUF_SIZE]; + +#define DEB printf("DEBUG [%d:%s:%d]\n", getpid(), __FILE__, __LINE__); + +static void usage(void) +{ + printf( +"./thugetlb [-m memory] [-o offset] [-f file] [-xeSAaFpch] hugetlbfs_directory\n" +" -m|--memory size(hugepage unit) Size of hugetlbfs file\n" +" -o|--offset offset(page unit) Position of error injection\n" +" -x|--inject Error injection switch\n" +" -e|--early-kill Set PR_MCE_KILL_EARLY\n" +" -S|--shm Use shmem with SHM_HUGETLB\n" +" -A|--anonymous Use MAP_ANONYMOUS\n" +" -a|--avoid-touch Avoid touching error page\n" +" -F|--fork\n" +" -p|--private\n" +" -c|--cow\n" +" -f|--filename string\n" +" -h|--help\n" +"\n" + ); +} + +/* + * semaphore get/put wrapper + */ +int get_semaphore(int sem_id, struct sembuf *sembuffer) +{ + sembuffer->sem_num = 0; + sembuffer->sem_op = -1; + sembuffer->sem_flg = SEM_UNDO; + return semop(sem_id, sembuffer, 1); +} + +int put_semaphore(int sem_id, struct sembuf *sembuffer) +{ + sembuffer->sem_num = 0; + sembuffer->sem_op = 1; + sembuffer->sem_flg = SEM_UNDO; + return semop(sem_id, sembuffer, 1); +} + +static int avoid_hpage(void *addr, int flag, char *avoid) +{ + return flag == 1 && addr == avoid; +} + +static void write_bytes(char *addr, int flag, char *avoid) +{ + int i, j; + for (i = 0; i < file_size; i++) { + if (avoid_hpage(addr + i * HPAGE_SIZE, flag, avoid)) + continue; + for (j = 0; j < HPAGE_SIZE; j++) { + *(addr + i * HPAGE_SIZE + j) = (char)('a' + + ((i + j) % 26)); + } + } +} + +static void read_bytes(char *addr, int flag, char *avoid) +{ + int i, j; + + for (i = 0; i < file_size; i++) { + if (avoid_hpage(addr + i * HPAGE_SIZE, flag, avoid)) + continue; + for (j = 0; j < HPAGE_SIZE; j++) { + if (*(addr + i * HPAGE_SIZE + j) != (char)('a' + + ((i + j) % 26))) { + printf("Mismatch at %lu\n", i + j); + break; + } + } + } +} + +static struct option opts[] = { + { "memory" , 1, NULL, 'm' }, + { "offset" , 1, NULL, 'o' }, + { "inject" , 0, NULL, 'x' }, + { "early_kill" , 0, NULL, 'e' }, + { "shm" , 0, NULL, 'S' }, + { "anonymous" , 0, NULL, 'A' }, + { "avoid-touch" , 0, NULL, 'a' }, + { "fork" , 0, NULL, 'F' }, + { "private" , 0, NULL, 'p' }, + { "cow" , 0, NULL, 'c' }, + { "filename" , 1, NULL, 'f' }, + { "help" , 0, NULL, 'h' }, + { NULL , 0, NULL, 0 } +}; + +int main(int argc, char *argv[]) +{ + void *addr; + int i; + int ret; + int fd = 0; + int shmid; + int semid; + int semaphore; + int inject = 0; + int early_kill = 0; + int avoid_touch = 0; + int anonflag = 0; + int shmflag = 0; + int shmkey = 0; + int forkflag = 0; + int privateflag = 0; + int cowflag = 0; + char c; + pid_t pid = 0; + void *expected_addr = NULL; + struct sembuf sembuffer; + + PS = getpagesize(); + file_size = 1; + corrupt_page = -1; + + if (argc == 1) { + usage(); + exit(EXIT_FAILURE); + } + + while ((c = getopt_long(argc, argv, + "m:o:xeSAaFpcf:h", opts, NULL)) != -1) { + switch (c) { + case 'm': + file_size = strtol(optarg, NULL, 10); + break; + case 'o': + corrupt_page = strtol(optarg, NULL, 10); + break; + case 'x': + inject = 1; + break; + case 'e': + early_kill = 1; + break; + case 'S': + shmflag = 1; + break; + case 'A': + anonflag = 1; + break; + case 'a': + avoid_touch = 1; + break; + case 'F': + forkflag = 1; + break; + case 'p': + privateflag = 1; + break; + case 'c': + cowflag = 1; + break; + case 'f': + strcat(filename, optarg); + shmkey = strtol(optarg, NULL, 10); + break; + case 'h': + usage(); + exit(EXIT_SUCCESS); + default: + usage(); + exit(EXIT_FAILURE); + } + } + + if (inject && corrupt_page * PS > file_size * HPAGE_SIZE) + err("Target page is out of range.\n"); + + if (avoid_touch && corrupt_page == -1) + err("Avoid which page?\n"); + + /* Construct file name */ + if (access(argv[argc - 1], F_OK) == -1) { + usage(); + exit(EXIT_FAILURE); + } else { + strcpy(filepath, argv[argc - 1]); + strcat(filepath, filename); + } + + if (shmflag) { + if ((shmid = shmget(shmkey, file_size * HPAGE_SIZE, + SHM_HUGETLB | IPC_CREAT | SHM_R | SHM_W)) < 0) + err("shmget"); + addr = shmat(shmid, (void *)0x0UL, 0); + if (addr == (char *)-1) { + perror("Shared memory attach failure"); + shmctl(shmid, IPC_RMID, NULL); + exit(2); + } + } else if (anonflag) { + int mapflag = MAP_ANONYMOUS | 0x40000; /* MAP_HUGETLB */ + if (privateflag) + mapflag |= MAP_PRIVATE; + else + mapflag |= MAP_SHARED; + if ((addr = mmap(0, file_size * HPAGE_SIZE, + PROTECTION, mapflag, -1, 0)) == MAP_FAILED) + err("mmap"); + } else { + int mapflag = MAP_SHARED; + if (privateflag) + mapflag = MAP_PRIVATE; + if ((fd = open(filepath, O_CREAT | O_RDWR, 0777)) < 0) + err("Open failed"); + if ((addr = mmap(0, file_size * HPAGE_SIZE, + PROTECTION, mapflag, fd, 0)) == MAP_FAILED) { + unlink(filepath); + err("mmap"); + } + } + + if (corrupt_page != -1) + expected_addr = (void *)(addr + corrupt_page / 512 * HPAGE_SIZE); + + if (forkflag) { + semid = semget(IPC_PRIVATE, 1, 0666|IPC_CREAT); + if (semid == -1) { + perror("semget"); + goto cleanout; + } + semaphore = semctl(semid, 0, SETVAL, 1); + if (semaphore == -1) { + perror("semctl"); + goto cleanout; + } + if (get_semaphore(semid, &sembuffer)) { + perror("get_semaphore"); + goto cleanout; + } + } + + write_bytes(addr, 0, 0); + read_bytes(addr, 0, 0); + + if (early_kill) + prctl(PR_MCE_KILL, PR_MCE_KILL_SET, PR_MCE_KILL_EARLY, + NULL, NULL); + + /* + * Intended order: + * 1. Child COWs + * 2. Parent madvise()s + * 3. Child exit()s + */ + if (forkflag) { + pid = fork(); + if (!pid) { + /* Semaphore is already held */ + if (cowflag) { + write_bytes(addr, 0, expected_addr); + read_bytes(addr, 0, expected_addr); + } + if (put_semaphore(semid, &sembuffer)) + err("put_semaphore"); + usleep(1000); + /* Wait for madvise() to be done */ + if (get_semaphore(semid, &sembuffer)) + err("put_semaphore"); + if (put_semaphore(semid, &sembuffer)) + err("put_semaphore"); + return 0; + } + } + + /* Wait for COW */ + if (forkflag && get_semaphore(semid, &sembuffer)) { + perror("get_semaphore"); + goto cleanout; + } + + if (inject && corrupt_page != -1) { + ret = madvise(addr + corrupt_page * PS, PS, 100); + if (ret) { + printf("madivise return %d :", ret); + perror("madvise"); + goto cleanout; + } + } + + if (forkflag && put_semaphore(semid, &sembuffer)) { + perror("put_semaphore"); + goto cleanout; + } + + write_bytes(addr, avoid_touch, expected_addr); + read_bytes(addr, avoid_touch, expected_addr); + + if (forkflag) + if (wait(&i) == -1) + err("wait"); +cleanout: + if (shmflag) { + if (shmdt((const void *)addr) != 0) { + err("Detach failure"); + shmctl(shmid, IPC_RMID, NULL); + exit(EXIT_FAILURE); + } + shmctl(shmid, IPC_RMID, NULL); + } else { + if (munmap(addr, file_size * HPAGE_SIZE)) + err("munmap"); + if (close(fd)) + err("close"); + if (!anonflag && unlink(filepath)) + err("unlink"); + } + + return 0; +} |