valgrind_stressor.c

#include <sys/uio.h>

static FILE *launch_pgrep() {
  char cmd[512];
  snprintf(cmd, 512, "pgrep kr");
  cmd[511] = '\0';
  return launch_command(cmd);
}

static FILE *launch_stressor() {
  char cmd[512];
  snprintf(cmd, 512, "stress --cpu 4 --vm 4");
  cmd[511] = '\0';
  return launch_command(cmd);
}

static ssize_t process_popen_event(kr_event *event) {
  /* temp kludge */
  char output[KR_POPEN_BUF_SIZE];
  memset(output, 0, sizeof(output));
  /* end temp kludge */
  struct iovec iov[1];
  kr_mt *mt;
  ssize_t bytes_read;
  ssize_t ret;
  int done;
  int fd;
  int err;
  done = 0;
  bytes_read = 0;
  iov[0].iov_base = output;
  iov[0].iov_len = KR_POPEN_BUF_SIZE;
  if (event->events & EPOLLIN) {
    ret = readv(event->fd, iov, 1);
    if (ret == -1) {
      if ((errno != EAGAIN) && (errno != EWOULDBLOCK)) {
        err = errno;
        printke("process popen event readv got %s", streror(err));
        done = 1;
      }
    } else if (ret == 0) {
      printke("process popen event readv got 0 bytes");
      done = 1;
    } else {
      bytes_read += ret;
    }
  }
  /* temp kludge */
  if (bytes_read > 0) {
    printk("%s", output);
  }
  /* end temp kludge */
  if (event->events & EPOLLERR) {
    done = 1;
    printke("process popen event: EPOLLERR event on popened fd");
  }
  if (event->events & EPOLLHUP) {
    done = 1;
    printk("process popen event: EPOLLHUP event on popened fd");
  }
  if (done == 1) {
    mt = (kr_mt *) event->user;
    fd = fileno((FILE *) mt->data);
    kr_loop_del(mt->loop, fd);
  }
  return bytes_read;
}

static int process_valgrind_activity_timer_event(kr_event *event) {
  kr_mt *mt;
  kr_event new_event;
  int fd;
  FILE *fp;
  mt = (kr_mt *) event->user;
  process_timer_event(event);
  printk("valgrind_activity_timer_event");
  fp = launch_pgrep();
  if (fp == NULL) {
    printke("valgrind_activity_timer_event : failed to launch");
    return -1;
  }
  fd = fileno(fp);
  mt->data = fp;
  memset(&new_event, 0, sizeof(new_event));
  new_event.fd = fd;
  new_event.handler = process_popen_event;
  new_event.user = mt;
  new_event.events = EPOLLIN;
  kr_loop_add(mt->loop, &new_event);
  kr_media_ops_raise_event(mt, KR_MT_PROGRESS);
  return 0;
}

static int init_valgrind_activity_timeout(kr_mt *mt) {
  int ret;
  kr_event event;
  struct itimerspec new_value;
  int fd;
  fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC);
  if (fd < 0) {
    printke("Valgrind Stressor: timerfd_create fail");
    return -1;
  }
  memset(&event, 0, sizeof(event));
  event.fd = fd;
  event.handler = process_valgrind_activity_timer_event;
  event.user = mt;
  event.events = EPOLLIN;
  ret = kr_loop_add(mt->loop, &event);
  memset(&new_value, 0, sizeof(new_value));
  new_value.it_value.tv_sec = 1;
  new_value.it_value.tv_nsec = 0;
  new_value.it_interval.tv_sec = 1;
  new_value.it_interval.tv_nsec = 0;
  ret = timerfd_settime(fd, 0, &new_value, NULL);
  if (ret != 0) {
    printke("valgrind_stressor: timerfd settime fail");
    return -5;
  }
  return 0;
}

int kr_valgrind_stressor_create(kr_mt *mt) {
  return 0;
}

int kr_valgrind_stressor_ctl(kr_mt *mt, kr_patchset *patchset) {
  return 0;
}

int kr_valgrind_stressor_start(kr_mt *mt) {
  init_valgrind_activity_timeout(mt);
  return 0;
}

int kr_valgrind_stressor_stop(kr_mt *mt) {
  return 0;
}

int kr_valgrind_stressor_destroy(kr_mt *mt) {
  return 0;
}