kmemtraced.c

   1 /*
   2  * Copyright (C) 2008 Pekka Enberg, Eduard - Gabriel Munteanu
   3  *
   4  * This file is released under GPL version 2.
   5  */
   6
   7 #define _GNU_SOURCE
   8
   9 #include <errno.h>
  10 #include <fcntl.h>
  11 #include <limits.h>
  12 #include <pthread.h>
  13 #include <poll.h>
  14 #include <sched.h>
  15 #include <signal.h>
  16 #include <stdarg.h>
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <sys/stat.h>
  21 #include <sys/mman.h>
  22 #include <sys/types.h>
  23 #include <sys/syscall.h>
  24 #include <sys/sendfile.h>
  25 #include <unistd.h>
  26
  27 #include "common.h"
  28 #include "kmemtrace.h"
  29
  30 static volatile int terminate;
  31
  32 static void write_str(const char *filename, const char *value)
  33 {
  34         int fd;
  35
  36         fd = open(filename, O_RDWR);
  37         if (fd < 0)
  38                 panic("Could not open() file %s: %s\n", filename, strerror(errno));
  39
  40         if (write(fd, value, strlen(value)) < 0)
  41                 panic("Could not write() to file %s: %s\n", filename, strerror(errno));
  42
  43         close(fd);
  44 }
  45
  46 static int open_channel(int cpu)
  47 {
  48         char filename[PATH_MAX];
  49         int fd;
  50
  51         sprintf(filename, "/sys/kernel/debug/kmemtrace/cpu%d", cpu);
  52         fd = open(filename, O_RDONLY | O_NONBLOCK);
  53         if (fd < 0)
  54                 panic("Could not open() file %s: %s\n", filename, strerror(errno));
  55         return fd;
  56 }
  57
  58 static int open_log(int cpu)
  59 {
  60         char filename[PATH_MAX];
  61         int fd;
  62
  63         sprintf(filename, "cpu%d.out", cpu);
  64         fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC,
  65                   S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
  66         if (fd < 0)
  67                 panic("Could not open() file %s: %s\n",
  68                       filename, strerror(errno));
  69
  70         return fd;
  71 }
  72
  73 static void reader_set_affinity(unsigned long cpu)
  74 {
  75         int err;
  76         cpu_set_t cpumask;
  77
  78         CPU_ZERO(&cpumask);
  79         CPU_SET(cpu, &cpumask);
  80         err = sched_setaffinity(syscall(SYS_gettid),
  81                                 sizeof(cpu_set_t), &cpumask);
  82
  83         if (err == -1)
  84                 panic("reader_set_affinity: %s\n", strerror(errno));
  85 }
  86
  87 static void *reader_thread(void *data)
  88 {
  89         unsigned long cpu = (unsigned long) data;
  90         int relay_fd, log_fd;
  91         int pipe_fd[2];
  92         long retval;
  93
  94         reader_set_affinity(cpu);
  95
  96         relay_fd = open_channel(cpu);
  97         log_fd = open_log(cpu);
  98
  99         if (pipe(pipe_fd))
 100                 panic("pipe() failed: %s\n", strerror(errno));
 101
 102         do {
 103                 /*
 104                  * We don't strip extra features (due to ABI changes) from
 105                  * events; do that when actually parsing the data.
 106                  */
 107                 retval = splice(relay_fd, NULL, pipe_fd[1], NULL,
 108                                 128, SPLICE_F_MOVE);
 109                 if (retval < 0)
 110                         panic("splice() (from) failed: %s\n",
 111                               strerror(errno));
 112                 if (!retval)
 113                         continue;
 114                 retval = splice(pipe_fd[0], NULL, log_fd, NULL,
 115                                 128, SPLICE_F_MOVE);
 116                 if (retval < 0)
 117                         panic("splice() (to) failed: %s\n", strerror(errno));
 118         } while (!terminate);
 119
 120         return NULL;
 121 }
 122
 123 static void copy_kallsyms(void)
 124 {
 125         int in_fd, out_fd;
 126         char buf[256];
 127         ssize_t count;
 128
 129         in_fd = open("/proc/kallsyms", O_RDONLY);
 130         if (in_fd == -1)
 131                 goto err;
 132
 133         out_fd = open("kallsyms", O_CREAT | O_WRONLY | O_TRUNC,
 134                       S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 135         if (out_fd == -1) {
 136                 close(in_fd);
 137                 goto err;
 138         }
 139
 140         while ((count = read(in_fd, buf, 256)) > 0)
 141                 write(out_fd, buf, count);
 142         if (count < 0)
 143                 goto err;
 144
 145         return;
 146
 147 err:
 148         panic("copy_kallsyms: %s\n", strerror(errno));
 149 }
 150
 151 int main(int argc, char *argv[])
 152 {
 153         unsigned long nr_cpus;
 154         pthread_t *readers;
 155         sigset_t signals;
 156         unsigned long i;
 157         int signal;
 158
 159         sigemptyset(&signals);
 160         sigaddset(&signals, SIGINT);
 161         sigaddset(&signals, SIGTERM);
 162         pthread_sigmask(SIG_BLOCK, &signals, NULL);
 163
 164         nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
 165
 166         readers = calloc(nr_cpus, sizeof(pthread_t));
 167         if (!readers)
 168                 panic("Out of memory!\n");
 169
 170         printf("Copying /proc/kallsyms...\n");
 171         copy_kallsyms();
 172
 173         for (i = 0; i < nr_cpus; i++) {
 174                 int err;
 175
 176                 err = pthread_create(&readers[i], NULL, reader_thread,
 177                                      (void *) i);
 178                 if (err)
 179                         panic("Could not pthread_create(): %s!\n",
 180                               strerror(errno));
 181         }
 182
 183         write_str("/sys/kernel/debug/kmemtrace/enabled", "1");
 184
 185         printf("Logging... Press Control-C to stop.\n");
 186
 187         while (sigwait(&signals, &signal) == 0) {
 188                 if (signal == SIGINT || signal == SIGTERM)
 189                         /*
 190                          * No synchronization needed, we wait for
 191                          * threads to end.
 192                          */
 193                         terminate = 1;
 194                         break;
 195         }
 196
 197         write_str("/sys/kernel/debug/kmemtrace/enabled", "0");
 198
 199         for (i = 0; i < nr_cpus; i++)
 200                 pthread_join(readers[i], NULL);
 201
 202         return EXIT_SUCCESS;
 203 }