Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Alexey Dobriyan | 1359 | 71.00% | 7 | 70.00% |
Swarup Laxman Kotiaklapudi | 553 | 28.89% | 2 | 20.00% |
Hugh Dickins | 2 | 0.10% | 1 | 10.00% |
Total | 1914 | 10 |
#if defined __amd64__ || defined __i386__ /* * Copyright (c) 2022 Alexey Dobriyan <adobriyan@gmail.com> * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ /* * Create a process without mappings by unmapping everything at once and * holding it with ptrace(2). See what happens to * * /proc/${pid}/maps * /proc/${pid}/numa_maps * /proc/${pid}/smaps * /proc/${pid}/smaps_rollup */ #undef _GNU_SOURCE #define _GNU_SOURCE #undef NDEBUG #include <assert.h> #include <errno.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <fcntl.h> #include <sys/mman.h> #include <sys/ptrace.h> #include <sys/resource.h> #include <sys/syscall.h> #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> #ifdef __amd64__ #define TEST_VSYSCALL #endif #if defined __amd64__ #ifndef SYS_pkey_alloc #define SYS_pkey_alloc 330 #endif #ifndef SYS_pkey_free #define SYS_pkey_free 331 #endif #elif defined __i386__ #ifndef SYS_pkey_alloc #define SYS_pkey_alloc 381 #endif #ifndef SYS_pkey_free #define SYS_pkey_free 382 #endif #else #error "SYS_pkey_alloc" #endif static int g_protection_key_support; static int protection_key_support(void) { long rv = syscall(SYS_pkey_alloc, 0, 0); if (rv > 0) { syscall(SYS_pkey_free, (int)rv); return 1; } else if (rv == -1 && errno == ENOSYS) { return 0; } else if (rv == -1 && errno == EINVAL) { // ospke=n return 0; } else { fprintf(stderr, "%s: error: rv %ld, errno %d\n", __func__, rv, errno); exit(EXIT_FAILURE); } } /* * 0: vsyscall VMA doesn't exist vsyscall=none * 1: vsyscall VMA is --xp vsyscall=xonly * 2: vsyscall VMA is r-xp vsyscall=emulate */ static volatile int g_vsyscall; static const char *g_proc_pid_maps_vsyscall; static const char *g_proc_pid_smaps_vsyscall; static const char proc_pid_maps_vsyscall_0[] = ""; static const char proc_pid_maps_vsyscall_1[] = "ffffffffff600000-ffffffffff601000 --xp 00000000 00:00 0 [vsyscall]\n"; static const char proc_pid_maps_vsyscall_2[] = "ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0 [vsyscall]\n"; static const char proc_pid_smaps_vsyscall_0[] = ""; static const char proc_pid_smaps_vsyscall_1[] = "ffffffffff600000-ffffffffff601000 --xp 00000000 00:00 0 [vsyscall]\n" "Size: 4 kB\n" "KernelPageSize: 4 kB\n" "MMUPageSize: 4 kB\n" "Rss: 0 kB\n" "Pss: 0 kB\n" "Pss_Dirty: 0 kB\n" "Shared_Clean: 0 kB\n" "Shared_Dirty: 0 kB\n" "Private_Clean: 0 kB\n" "Private_Dirty: 0 kB\n" "Referenced: 0 kB\n" "Anonymous: 0 kB\n" "KSM: 0 kB\n" "LazyFree: 0 kB\n" "AnonHugePages: 0 kB\n" "ShmemPmdMapped: 0 kB\n" "FilePmdMapped: 0 kB\n" "Shared_Hugetlb: 0 kB\n" "Private_Hugetlb: 0 kB\n" "Swap: 0 kB\n" "SwapPss: 0 kB\n" "Locked: 0 kB\n" "THPeligible: 0\n" ; static const char proc_pid_smaps_vsyscall_2[] = "ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0 [vsyscall]\n" "Size: 4 kB\n" "KernelPageSize: 4 kB\n" "MMUPageSize: 4 kB\n" "Rss: 0 kB\n" "Pss: 0 kB\n" "Pss_Dirty: 0 kB\n" "Shared_Clean: 0 kB\n" "Shared_Dirty: 0 kB\n" "Private_Clean: 0 kB\n" "Private_Dirty: 0 kB\n" "Referenced: 0 kB\n" "Anonymous: 0 kB\n" "KSM: 0 kB\n" "LazyFree: 0 kB\n" "AnonHugePages: 0 kB\n" "ShmemPmdMapped: 0 kB\n" "FilePmdMapped: 0 kB\n" "Shared_Hugetlb: 0 kB\n" "Private_Hugetlb: 0 kB\n" "Swap: 0 kB\n" "SwapPss: 0 kB\n" "Locked: 0 kB\n" "THPeligible: 0\n" ; static void sigaction_SIGSEGV(int _, siginfo_t *__, void *___) { _exit(EXIT_FAILURE); } #ifdef TEST_VSYSCALL static void sigaction_SIGSEGV_vsyscall(int _, siginfo_t *__, void *___) { _exit(g_vsyscall); } /* * vsyscall page can't be unmapped, probe it directly. */ static void vsyscall(void) { pid_t pid; int wstatus; pid = fork(); if (pid < 0) { fprintf(stderr, "fork, errno %d\n", errno); exit(1); } if (pid == 0) { setrlimit(RLIMIT_CORE, &(struct rlimit){}); /* Hide "segfault at ffffffffff600000" messages. */ struct sigaction act = {}; act.sa_flags = SA_SIGINFO; act.sa_sigaction = sigaction_SIGSEGV_vsyscall; sigaction(SIGSEGV, &act, NULL); g_vsyscall = 0; /* gettimeofday(NULL, NULL); */ uint64_t rax = 0xffffffffff600000; asm volatile ( "call *%[rax]" : [rax] "+a" (rax) : "D" (NULL), "S" (NULL) : "rcx", "r11" ); g_vsyscall = 1; *(volatile int *)0xffffffffff600000UL; g_vsyscall = 2; exit(g_vsyscall); } waitpid(pid, &wstatus, 0); if (WIFEXITED(wstatus)) { g_vsyscall = WEXITSTATUS(wstatus); } else { fprintf(stderr, "error: vsyscall wstatus %08x\n", wstatus); exit(1); } } #endif static int test_proc_pid_maps(pid_t pid) { char buf[4096]; snprintf(buf, sizeof(buf), "/proc/%u/maps", pid); int fd = open(buf, O_RDONLY); if (fd == -1) { perror("open /proc/${pid}/maps"); return EXIT_FAILURE; } else { ssize_t rv = read(fd, buf, sizeof(buf)); close(fd); if (g_vsyscall == 0) { assert(rv == 0); } else { size_t len = strlen(g_proc_pid_maps_vsyscall); assert(rv == len); assert(memcmp(buf, g_proc_pid_maps_vsyscall, len) == 0); } return EXIT_SUCCESS; } } static int test_proc_pid_numa_maps(pid_t pid) { char buf[4096]; snprintf(buf, sizeof(buf), "/proc/%u/numa_maps", pid); int fd = open(buf, O_RDONLY); if (fd == -1) { if (errno == ENOENT) { /* * /proc/${pid}/numa_maps is under CONFIG_NUMA, * it doesn't necessarily exist. */ return EXIT_SUCCESS; } perror("open /proc/${pid}/numa_maps"); return EXIT_FAILURE; } else { ssize_t rv = read(fd, buf, sizeof(buf)); close(fd); assert(rv == 0); return EXIT_SUCCESS; } } static int test_proc_pid_smaps(pid_t pid) { char buf[4096]; snprintf(buf, sizeof(buf), "/proc/%u/smaps", pid); int fd = open(buf, O_RDONLY); if (fd == -1) { if (errno == ENOENT) { /* * /proc/${pid}/smaps is under CONFIG_PROC_PAGE_MONITOR, * it doesn't necessarily exist. */ return EXIT_SUCCESS; } perror("open /proc/${pid}/smaps"); return EXIT_FAILURE; } ssize_t rv = read(fd, buf, sizeof(buf)); close(fd); assert(0 <= rv); assert(rv <= sizeof(buf)); if (g_vsyscall == 0) { assert(rv == 0); } else { size_t len = strlen(g_proc_pid_smaps_vsyscall); assert(rv > len); assert(memcmp(buf, g_proc_pid_smaps_vsyscall, len) == 0); if (g_protection_key_support) { #define PROTECTION_KEY "ProtectionKey: 0\n" assert(memmem(buf, rv, PROTECTION_KEY, strlen(PROTECTION_KEY))); } } return EXIT_SUCCESS; } static const char g_smaps_rollup[] = "00000000-00000000 ---p 00000000 00:00 0 [rollup]\n" "Rss: 0 kB\n" "Pss: 0 kB\n" "Pss_Dirty: 0 kB\n" "Pss_Anon: 0 kB\n" "Pss_File: 0 kB\n" "Pss_Shmem: 0 kB\n" "Shared_Clean: 0 kB\n" "Shared_Dirty: 0 kB\n" "Private_Clean: 0 kB\n" "Private_Dirty: 0 kB\n" "Referenced: 0 kB\n" "Anonymous: 0 kB\n" "KSM: 0 kB\n" "LazyFree: 0 kB\n" "AnonHugePages: 0 kB\n" "ShmemPmdMapped: 0 kB\n" "FilePmdMapped: 0 kB\n" "Shared_Hugetlb: 0 kB\n" "Private_Hugetlb: 0 kB\n" "Swap: 0 kB\n" "SwapPss: 0 kB\n" "Locked: 0 kB\n" ; static int test_proc_pid_smaps_rollup(pid_t pid) { char buf[4096]; snprintf(buf, sizeof(buf), "/proc/%u/smaps_rollup", pid); int fd = open(buf, O_RDONLY); if (fd == -1) { if (errno == ENOENT) { /* * /proc/${pid}/smaps_rollup is under CONFIG_PROC_PAGE_MONITOR, * it doesn't necessarily exist. */ return EXIT_SUCCESS; } perror("open /proc/${pid}/smaps_rollup"); return EXIT_FAILURE; } else { ssize_t rv = read(fd, buf, sizeof(buf)); close(fd); assert(rv == sizeof(g_smaps_rollup) - 1); assert(memcmp(buf, g_smaps_rollup, sizeof(g_smaps_rollup) - 1) == 0); return EXIT_SUCCESS; } } static const char *parse_u64(const char *p, const char *const end, uint64_t *rv) { *rv = 0; for (; p != end; p += 1) { if ('0' <= *p && *p <= '9') { assert(!__builtin_mul_overflow(*rv, 10, rv)); assert(!__builtin_add_overflow(*rv, *p - '0', rv)); } else { break; } } assert(p != end); return p; } /* * There seems to be 2 types of valid output: * "0 A A B 0 0 0\n" for dynamic exeuctables, * "0 0 0 B 0 0 0\n" for static executables. */ static int test_proc_pid_statm(pid_t pid) { char buf[4096]; snprintf(buf, sizeof(buf), "/proc/%u/statm", pid); int fd = open(buf, O_RDONLY); if (fd == -1) { perror("open /proc/${pid}/statm"); return EXIT_FAILURE; } ssize_t rv = read(fd, buf, sizeof(buf)); close(fd); assert(rv >= 0); assert(rv <= sizeof(buf)); const char *p = buf; const char *const end = p + rv; /* size */ assert(p != end && *p++ == '0'); assert(p != end && *p++ == ' '); uint64_t resident; p = parse_u64(p, end, &resident); assert(p != end && *p++ == ' '); uint64_t shared; p = parse_u64(p, end, &shared); assert(p != end && *p++ == ' '); uint64_t text; p = parse_u64(p, end, &text); assert(p != end && *p++ == ' '); assert(p != end && *p++ == '0'); assert(p != end && *p++ == ' '); /* data */ assert(p != end && *p++ == '0'); assert(p != end && *p++ == ' '); assert(p != end && *p++ == '0'); assert(p != end && *p++ == '\n'); assert(p == end); /* * "text" is "mm->end_code - mm->start_code" at execve(2) time. * munmap() doesn't change it. It can be anything (just link * statically). It can't be 0 because executing to this point * implies at least 1 page of code. */ assert(text > 0); /* * These two are always equal. Always 0 for statically linked * executables and sometimes 0 for dynamically linked executables. * There is no way to tell one from another without parsing ELF * which is too much for this test. */ assert(resident == shared); return EXIT_SUCCESS; } int main(void) { int rv = EXIT_SUCCESS; #ifdef TEST_VSYSCALL vsyscall(); #endif switch (g_vsyscall) { case 0: g_proc_pid_maps_vsyscall = proc_pid_maps_vsyscall_0; g_proc_pid_smaps_vsyscall = proc_pid_smaps_vsyscall_0; break; case 1: g_proc_pid_maps_vsyscall = proc_pid_maps_vsyscall_1; g_proc_pid_smaps_vsyscall = proc_pid_smaps_vsyscall_1; break; case 2: g_proc_pid_maps_vsyscall = proc_pid_maps_vsyscall_2; g_proc_pid_smaps_vsyscall = proc_pid_smaps_vsyscall_2; break; default: abort(); } g_protection_key_support = protection_key_support(); pid_t pid = fork(); if (pid == -1) { perror("fork"); return EXIT_FAILURE; } else if (pid == 0) { rv = ptrace(PTRACE_TRACEME, 0, NULL, NULL); if (rv != 0) { if (errno == EPERM) { fprintf(stderr, "Did you know? ptrace(PTRACE_TRACEME) doesn't work under strace.\n" ); kill(getppid(), SIGTERM); return EXIT_FAILURE; } perror("ptrace PTRACE_TRACEME"); return EXIT_FAILURE; } /* * Hide "segfault at ..." messages. Signal handler won't run. */ struct sigaction act = {}; act.sa_flags = SA_SIGINFO; act.sa_sigaction = sigaction_SIGSEGV; sigaction(SIGSEGV, &act, NULL); #ifdef __amd64__ munmap(NULL, ((size_t)1 << 47) - 4096); #elif defined __i386__ { size_t len; for (len = -4096;; len -= 4096) { munmap(NULL, len); } } #else #error "implement 'unmap everything'" #endif return EXIT_FAILURE; } else { /* * TODO find reliable way to signal parent that munmap(2) completed. * Child can't do it directly because it effectively doesn't exist * anymore. Looking at child's VM files isn't 100% reliable either: * due to a bug they may not become empty or empty-like. */ sleep(1); if (rv == EXIT_SUCCESS) { rv = test_proc_pid_maps(pid); } if (rv == EXIT_SUCCESS) { rv = test_proc_pid_numa_maps(pid); } if (rv == EXIT_SUCCESS) { rv = test_proc_pid_smaps(pid); } if (rv == EXIT_SUCCESS) { rv = test_proc_pid_smaps_rollup(pid); } if (rv == EXIT_SUCCESS) { rv = test_proc_pid_statm(pid); } /* Cut the rope. */ int wstatus; waitpid(pid, &wstatus, 0); assert(WIFSTOPPED(wstatus)); assert(WSTOPSIG(wstatus) == SIGSEGV); } return rv; } #else int main(void) { return 4; } #endif
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1