tools/testing/selftests/proc/read.c

   1 /*
   2  * Copyright © 2018 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 // Test
  17 // 1) read of every file in /proc
  18 // 2) readlink of every symlink in /proc
  19 // 3) recursively (1) + (2) for every directory in /proc
  20 // 4) write to /proc/*/clear_refs and /proc/*/task/*/clear_refs
  21 // 5) write to /proc/sysrq-trigger
  22 #undef NDEBUG
  23 #include <assert.h>
  24 #include <errno.h>
  25 #include <sys/types.h>
  26 #include <dirent.h>
  27 #include <stdbool.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <sys/stat.h>
  31 #include <fcntl.h>
  32 #include <unistd.h>
  33
  34 #include "proc.h"
  35
  36 static void f_reg(DIR *d, const char *filename)
  37 {
  38         char buf[4096];
  39         int fd;
  40         ssize_t rv;
  41
  42         /* read from /proc/kmsg can block */
  43         fd = openat(dirfd(d), filename, O_RDONLY|O_NONBLOCK);
  44         if (fd == -1)
  45                 return;
  46         rv = read(fd, buf, sizeof(buf));
  47         assert((0 <= rv && rv <= sizeof(buf)) || rv == -1);
  48         close(fd);
  49 }
  50
  51 static void f_reg_write(DIR *d, const char *filename, const char *buf, size_t len)
  52 {
  53         int fd;
  54         ssize_t rv;
  55
  56         fd = openat(dirfd(d), filename, O_WRONLY);
  57         if (fd == -1)
  58                 return;
  59         rv = write(fd, buf, len);
  60         assert((0 <= rv && rv <= len) || rv == -1);
  61         close(fd);
  62 }
  63
  64 static void f_lnk(DIR *d, const char *filename)
  65 {
  66         char buf[4096];
  67         ssize_t rv;
  68
  69         rv = readlinkat(dirfd(d), filename, buf, sizeof(buf));
  70         assert((0 <= rv && rv <= sizeof(buf)) || rv == -1);
  71 }
  72
  73 static void f(DIR *d, unsigned int level)
  74 {
  75         struct dirent *de;
  76
  77         de = xreaddir(d);
  78         assert(de->d_type == DT_DIR);
  79         assert(streq(de->d_name, "."));
  80
  81         de = xreaddir(d);
  82         assert(de->d_type == DT_DIR);
  83         assert(streq(de->d_name, ".."));
  84
  85         while ((de = xreaddir(d))) {
  86                 assert(!streq(de->d_name, "."));
  87                 assert(!streq(de->d_name, ".."));
  88
  89                 switch (de->d_type) {
  90                         DIR *dd;
  91                         int fd;
  92
  93                 case DT_REG:
  94                         if (level == 0 && streq(de->d_name, "sysrq-trigger")) {
  95                                 f_reg_write(d, de->d_name, "h", 1);
  96                         } else if (level == 1 && streq(de->d_name, "clear_refs")) {
  97                                 f_reg_write(d, de->d_name, "1", 1);
  98                         } else if (level == 3 && streq(de->d_name, "clear_refs")) {
  99                                 f_reg_write(d, de->d_name, "1", 1);
 100                         } else {
 101                                 f_reg(d, de->d_name);
 102                         }
 103                         break;
 104                 case DT_DIR:
 105                         fd = openat(dirfd(d), de->d_name, O_DIRECTORY|O_RDONLY);
 106                         if (fd == -1)
 107                                 continue;
 108                         dd = fdopendir(fd);
 109                         if (!dd)
 110                                 continue;
 111                         f(dd, level + 1);
 112                         closedir(dd);
 113                         break;
 114                 case DT_LNK:
 115                         f_lnk(d, de->d_name);
 116                         break;
 117                 default:
 118                         assert(0);
 119                 }
 120         }
 121 }
 122
 123 int main(void)
 124 {
 125         DIR *d;
 126
 127         d = opendir("/proc");
 128         if (!d)
 129                 return 2;
 130         f(d, 0);
 131         return 0;
 132 }