valgrind_stressor.c

/*stress --cpu 4 --vm 4 */

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(cmd);
}

static int process_pgrep_event(kr_event *event) {
  int done;
  int ret;
  kr_mt *mt;
  int fd;
  char output[KR_POPEN_BUF_SIZE];
  ssize_t did_read;
  memset(output, 0, sizeof(output));
  done = 0;
  if (event->events & EPOLLIN) {
    for (;;) {
      ret = read(event->fd, output, KR_POPEN_BUF_SIZE);
      if (ret == 0) {
      }
      if (ret == -1) {
        if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {
        }
      }
      if (ret > 0) {
      }
      printk("%s", output);
    }
  }
  if (event->events & EPOLLERR) {
    done = 1;
    printke("valgrind pgrep event: EPOLLERR event on pgrep fd");
  }
  if (event->events & EPOLLHUP) {
    done = 1;
    printk("Got EPOLLHUP");
  }
  if (done == 1) {
    mt = (kr_mt *) event->user;
    fd = fileno((FILE *) mt->data);
    kr_loop_del(mt->loop, fd);
  }
}

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_pgrep_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;
}