tools/testing/selftests/proc/proc-pid-vm.c

   1 /*
   2  * Copyright (c) 2019 Alexey Dobriyan <adobriyan@gmail.com>
   3  *
   4  * Permission to use, copy, modify, and distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16 /*
  17  * Fork and exec tiny 1 page executable which precisely controls its VM.
  18  * Test /proc/$PID/maps
  19  * Test /proc/$PID/smaps
  20  * Test /proc/$PID/smaps_rollup
  21  * Test /proc/$PID/statm
  22  *
  23  * FIXME require CONFIG_TMPFS which can be disabled
  24  * FIXME test other values from "smaps"
  25  * FIXME support other archs
  26  */
  27 #undef NDEBUG
  28 #include <assert.h>
  29 #include <errno.h>
  30 #include <sched.h>
  31 #include <signal.h>
  32 #include <stdint.h>
  33 #include <stdio.h>
  34 #include <string.h>
  35 #include <stdlib.h>
  36 #include <sys/mount.h>
  37 #include <sys/types.h>
  38 #include <sys/stat.h>
  39 #include <fcntl.h>
  40 #include <unistd.h>
  41 #include <sys/syscall.h>
  42 #include <sys/uio.h>
  43 #include <linux/kdev_t.h>
  44
  45 static inline long sys_execveat(int dirfd, const char *pathname, char **argv, char **envp, int flags)
  46 {
  47         return syscall(SYS_execveat, dirfd, pathname, argv, envp, flags);
  48 }
  49
  50 static void make_private_tmp(void)
  51 {
  52         if (unshare(CLONE_NEWNS) == -1) {
  53                 if (errno == ENOSYS || errno == EPERM) {
  54                         exit(4);
  55                 }
  56                 exit(1);
  57         }
  58         if (mount(NULL, "/", NULL, MS_PRIVATE|MS_REC, NULL) == -1) {
  59                 exit(1);
  60         }
  61         if (mount(NULL, "/tmp", "tmpfs", 0, NULL) == -1) {
  62                 exit(1);
  63         }
  64 }
  65
  66 static pid_t pid = -1;
  67 static void ate(void)
  68 {
  69         if (pid > 0) {
  70                 kill(pid, SIGTERM);
  71         }
  72 }
  73
  74 struct elf64_hdr {
  75         uint8_t e_ident[16];
  76         uint16_t e_type;
  77         uint16_t e_machine;
  78         uint32_t e_version;
  79         uint64_t e_entry;
  80         uint64_t e_phoff;
  81         uint64_t e_shoff;
  82         uint32_t e_flags;
  83         uint16_t e_ehsize;
  84         uint16_t e_phentsize;
  85         uint16_t e_phnum;
  86         uint16_t e_shentsize;
  87         uint16_t e_shnum;
  88         uint16_t e_shstrndx;
  89 };
  90
  91 struct elf64_phdr {
  92         uint32_t p_type;
  93         uint32_t p_flags;
  94         uint64_t p_offset;
  95         uint64_t p_vaddr;
  96         uint64_t p_paddr;
  97         uint64_t p_filesz;
  98         uint64_t p_memsz;
  99         uint64_t p_align;
 100 };
 101
 102 #ifdef __x86_64__
 103 #define PAGE_SIZE 4096
 104 #define VADDR (1UL << 32)
 105 #define MAPS_OFFSET 73
 106
 107 #define syscall 0x0f, 0x05
 108 #define mov_rdi(x)      \
 109         0x48, 0xbf,     \
 110         (x)&0xff, ((x)>>8)&0xff, ((x)>>16)&0xff, ((x)>>24)&0xff,        \
 111         ((x)>>32)&0xff, ((x)>>40)&0xff, ((x)>>48)&0xff, ((x)>>56)&0xff
 112
 113 #define mov_rsi(x)      \
 114         0x48, 0xbe,     \
 115         (x)&0xff, ((x)>>8)&0xff, ((x)>>16)&0xff, ((x)>>24)&0xff,        \
 116         ((x)>>32)&0xff, ((x)>>40)&0xff, ((x)>>48)&0xff, ((x)>>56)&0xff
 117
 118 #define mov_eax(x)      \
 119         0xb8, (x)&0xff, ((x)>>8)&0xff, ((x)>>16)&0xff, ((x)>>24)&0xff
 120
 121 static const uint8_t payload[] = {
 122         /* Casually unmap stack, vDSO and everything else. */
 123         /* munmap */
 124         mov_rdi(VADDR + 4096),
 125         mov_rsi((1ULL << 47) - 4096 - VADDR - 4096),
 126         mov_eax(11),
 127         syscall,
 128
 129         /* Ping parent. */
 130         /* write(0, &c, 1); */
 131         0x31, 0xff,                                     /* xor edi, edi */
 132         0x48, 0x8d, 0x35, 0x00, 0x00, 0x00, 0x00,       /* lea rsi, [rip] */
 133         0xba, 0x01, 0x00, 0x00, 0x00,                   /* mov edx, 1 */
 134         mov_eax(1),
 135         syscall,
 136
 137         /* 1: pause(); */
 138         mov_eax(34),
 139         syscall,
 140
 141         0xeb, 0xf7,     /* jmp 1b */
 142 };
 143
 144 static int make_exe(const uint8_t *payload, size_t len)
 145 {
 146         struct elf64_hdr h;
 147         struct elf64_phdr ph;
 148
 149         struct iovec iov[3] = {
 150                 {&h, sizeof(struct elf64_hdr)},
 151                 {&ph, sizeof(struct elf64_phdr)},
 152                 {(void *)payload, len},
 153         };
 154         int fd, fd1;
 155         char buf[64];
 156
 157         memset(&h, 0, sizeof(h));
 158         h.e_ident[0] = 0x7f;
 159         h.e_ident[1] = 'E';
 160         h.e_ident[2] = 'L';
 161         h.e_ident[3] = 'F';
 162         h.e_ident[4] = 2;
 163         h.e_ident[5] = 1;
 164         h.e_ident[6] = 1;
 165         h.e_ident[7] = 0;
 166         h.e_type = 2;
 167         h.e_machine = 0x3e;
 168         h.e_version = 1;
 169         h.e_entry = VADDR + sizeof(struct elf64_hdr) + sizeof(struct elf64_phdr);
 170         h.e_phoff = sizeof(struct elf64_hdr);
 171         h.e_shoff = 0;
 172         h.e_flags = 0;
 173         h.e_ehsize = sizeof(struct elf64_hdr);
 174         h.e_phentsize = sizeof(struct elf64_phdr);
 175         h.e_phnum = 1;
 176         h.e_shentsize = 0;
 177         h.e_shnum = 0;
 178         h.e_shstrndx = 0;
 179
 180         memset(&ph, 0, sizeof(ph));
 181         ph.p_type = 1;
 182         ph.p_flags = (1<<2)|1;
 183         ph.p_offset = 0;
 184         ph.p_vaddr = VADDR;
 185         ph.p_paddr = 0;
 186         ph.p_filesz = sizeof(struct elf64_hdr) + sizeof(struct elf64_phdr) + sizeof(payload);
 187         ph.p_memsz = sizeof(struct elf64_hdr) + sizeof(struct elf64_phdr) + sizeof(payload);
 188         ph.p_align = 4096;
 189
 190         fd = openat(AT_FDCWD, "/tmp", O_WRONLY|O_EXCL|O_TMPFILE, 0700);
 191         if (fd == -1) {
 192                 exit(1);
 193         }
 194
 195         if (writev(fd, iov, 3) != sizeof(struct elf64_hdr) + sizeof(struct elf64_phdr) + len) {
 196                 exit(1);
 197         }
 198
 199         /* Avoid ETXTBSY on exec. */
 200         snprintf(buf, sizeof(buf), "/proc/self/fd/%u", fd);
 201         fd1 = open(buf, O_RDONLY|O_CLOEXEC);
 202         close(fd);
 203
 204         return fd1;
 205 }
 206 #endif
 207
 208 #ifdef __x86_64__
 209 int main(void)
 210 {
 211         int pipefd[2];
 212         int exec_fd;
 213
 214         atexit(ate);
 215
 216         make_private_tmp();
 217
 218         /* Reserve fd 0 for 1-byte pipe ping from child. */
 219         close(0);
 220         if (open("/", O_RDONLY|O_DIRECTORY|O_PATH) != 0) {
 221                 return 1;
 222         }
 223
 224         exec_fd = make_exe(payload, sizeof(payload));
 225
 226         if (pipe(pipefd) == -1) {
 227                 return 1;
 228         }
 229         if (dup2(pipefd[1], 0) != 0) {
 230                 return 1;
 231         }
 232
 233         pid = fork();
 234         if (pid == -1) {
 235                 return 1;
 236         }
 237         if (pid == 0) {
 238                 sys_execveat(exec_fd, "", NULL, NULL, AT_EMPTY_PATH);
 239                 return 1;
 240         }
 241
 242         char _;
 243         if (read(pipefd[0], &_, 1) != 1) {
 244                 return 1;
 245         }
 246
 247         struct stat st;
 248         if (fstat(exec_fd, &st) == -1) {
 249                 return 1;
 250         }
 251
 252         /* Generate "head -n1 /proc/$PID/maps" */
 253         char buf0[256];
 254         memset(buf0, ' ', sizeof(buf0));
 255         int len = snprintf(buf0, sizeof(buf0),
 256                         "%08lx-%08lx r-xp 00000000 %02lx:%02lx %llu",
 257                         VADDR, VADDR + PAGE_SIZE,
 258                         MAJOR(st.st_dev), MINOR(st.st_dev),
 259                         (unsigned long long)st.st_ino);
 260         buf0[len] = ' ';
 261         snprintf(buf0 + MAPS_OFFSET, sizeof(buf0) - MAPS_OFFSET,
 262                  "/tmp/#%llu (deleted)\n", (unsigned long long)st.st_ino);
 263
 264
 265         /* Test /proc/$PID/maps */
 266         {
 267                 char buf[256];
 268                 ssize_t rv;
 269                 int fd;
 270
 271                 snprintf(buf, sizeof(buf), "/proc/%u/maps", pid);
 272                 fd = open(buf, O_RDONLY);
 273                 if (fd == -1) {
 274                         return 1;
 275                 }
 276                 rv = read(fd, buf, sizeof(buf));
 277                 assert(rv == strlen(buf0));
 278                 assert(memcmp(buf, buf0, strlen(buf0)) == 0);
 279         }
 280
 281         /* Test /proc/$PID/smaps */
 282         {
 283                 char buf[1024];
 284                 ssize_t rv;
 285                 int fd;
 286
 287                 snprintf(buf, sizeof(buf), "/proc/%u/smaps", pid);
 288                 fd = open(buf, O_RDONLY);
 289                 if (fd == -1) {
 290                         return 1;
 291                 }
 292                 rv = read(fd, buf, sizeof(buf));
 293                 assert(0 <= rv && rv <= sizeof(buf));
 294
 295                 assert(rv >= strlen(buf0));
 296                 assert(memcmp(buf, buf0, strlen(buf0)) == 0);
 297
 298 #define RSS1 "Rss:                   4 kB\n"
 299 #define RSS2 "Rss:                   0 kB\n"
 300 #define PSS1 "Pss:                   4 kB\n"
 301 #define PSS2 "Pss:                   0 kB\n"
 302                 assert(memmem(buf, rv, RSS1, strlen(RSS1)) ||
 303                        memmem(buf, rv, RSS2, strlen(RSS2)));
 304                 assert(memmem(buf, rv, PSS1, strlen(PSS1)) ||
 305                        memmem(buf, rv, PSS2, strlen(PSS2)));
 306
 307                 static const char *S[] = {
 308                         "Size:                  4 kB\n",
 309                         "KernelPageSize:        4 kB\n",
 310                         "MMUPageSize:           4 kB\n",
 311                         "Anonymous:             0 kB\n",
 312                         "AnonHugePages:         0 kB\n",
 313                         "Shared_Hugetlb:        0 kB\n",
 314                         "Private_Hugetlb:       0 kB\n",
 315                         "Locked:                0 kB\n",
 316                 };
 317                 int i;
 318
 319                 for (i = 0; i < sizeof(S)/sizeof(S[0]); i++) {
 320                         assert(memmem(buf, rv, S[i], strlen(S[i])));
 321                 }
 322         }
 323
 324         /* Test /proc/$PID/smaps_rollup */
 325         {
 326                 char bufr[256];
 327                 memset(bufr, ' ', sizeof(bufr));
 328                 len = snprintf(bufr, sizeof(bufr),
 329                                 "%08lx-%08lx ---p 00000000 00:00 0",
 330                                 VADDR, VADDR + PAGE_SIZE);
 331                 bufr[len] = ' ';
 332                 snprintf(bufr + MAPS_OFFSET, sizeof(bufr) - MAPS_OFFSET,
 333                          "[rollup]\n");
 334
 335                 char buf[1024];
 336                 ssize_t rv;
 337                 int fd;
 338
 339                 snprintf(buf, sizeof(buf), "/proc/%u/smaps_rollup", pid);
 340                 fd = open(buf, O_RDONLY);
 341                 if (fd == -1) {
 342                         return 1;
 343                 }
 344                 rv = read(fd, buf, sizeof(buf));
 345                 assert(0 <= rv && rv <= sizeof(buf));
 346
 347                 assert(rv >= strlen(bufr));
 348                 assert(memcmp(buf, bufr, strlen(bufr)) == 0);
 349
 350                 assert(memmem(buf, rv, RSS1, strlen(RSS1)) ||
 351                        memmem(buf, rv, RSS2, strlen(RSS2)));
 352                 assert(memmem(buf, rv, PSS1, strlen(PSS1)) ||
 353                        memmem(buf, rv, PSS2, strlen(PSS2)));
 354
 355                 static const char *S[] = {
 356                         "Anonymous:             0 kB\n",
 357                         "AnonHugePages:         0 kB\n",
 358                         "Shared_Hugetlb:        0 kB\n",
 359                         "Private_Hugetlb:       0 kB\n",
 360                         "Locked:                0 kB\n",
 361                 };
 362                 int i;
 363
 364                 for (i = 0; i < sizeof(S)/sizeof(S[0]); i++) {
 365                         assert(memmem(buf, rv, S[i], strlen(S[i])));
 366                 }
 367         }
 368
 369         /* Test /proc/$PID/statm */
 370         {
 371                 char buf[64];
 372                 ssize_t rv;
 373                 int fd;
 374
 375                 snprintf(buf, sizeof(buf), "/proc/%u/statm", pid);
 376                 fd = open(buf, O_RDONLY);
 377                 if (fd == -1) {
 378                         return 1;
 379                 }
 380                 rv = read(fd, buf, sizeof(buf));
 381                 assert(rv == 7 * 2);
 382
 383                 assert(buf[0] == '1');  /* ->total_vm */
 384                 assert(buf[1] == ' ');
 385                 assert(buf[2] == '0' || buf[2] == '1'); /* rss */
 386                 assert(buf[3] == ' ');
 387                 assert(buf[4] == '0' || buf[2] == '1'); /* file rss */
 388                 assert(buf[5] == ' ');
 389                 assert(buf[6] == '1');  /* ELF executable segments */
 390                 assert(buf[7] == ' ');
 391                 assert(buf[8] == '0');
 392                 assert(buf[9] == ' ');
 393                 assert(buf[10] == '0'); /* ->data_vm + ->stack_vm */
 394                 assert(buf[11] == ' ');
 395                 assert(buf[12] == '0');
 396                 assert(buf[13] == '\n');
 397         }
 398
 399         return 0;
 400 }
 401 #else
 402 int main(void)
 403 {
 404         return 4;
 405 }
 406 #endif