minix3/tests/test41.c

/* Tests for getitimer(2)/setitimer(2) - by D.C. van Moolenbroek */
/* Warning: this test deals with (real and virtual) time, and, lacking a proper
 * point of reference, its correctness depends on circumstances like CPU speed
 * and system load. A succeeding test run says a lot - failure not so much. */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <minix/config.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <sys/syslimits.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>

#define ITERATIONS 3
int max_error = 4;
#include "common.h"



/* we have to keep in mind the millisecond values are rounded up */
#define UPPERUSEC(us) ((us)+(1000000/system_hz))
#define EQUSEC(l,r) \
  ((l) <= ((r) + (1000000/system_hz)) && (l) >= ((r) - (1000000/system_hz)))

#define FILLITIMER(it, vs, vu, is, iu) \
  (it).it_value.tv_sec = (vs); \
  (it).it_value.tv_usec = (vu); \
  (it).it_interval.tv_sec = (is); \
  (it).it_interval.tv_usec = (iu);

/* these two macros are not fully working for all possible values;
 * the tests only use values that the macros can deal with, though. */
#define EQITIMER(it, vs, vu, is, iu) \
  ((it).it_value.tv_sec == (vs) && EQUSEC((it).it_value.tv_usec,vu) && \
  (it).it_interval.tv_sec == (is) && (it).it_interval.tv_usec == (iu))

#define LEITIMER(it, vs, vu, is, iu) \
  ((it).it_value.tv_sec > 0 && ((it).it_value.tv_sec < (vs) || \
  ((it).it_value.tv_sec == (vs) && (it).it_value.tv_usec <= \
   UPPERUSEC(vu))) && \
  (it).it_interval.tv_sec == (is) && EQUSEC((it).it_interval.tv_usec,iu))

int main(int argc, char **argv);
void test(int m, int t);
void test_which(void);
void test_getset(void);
void test_neglarge(void);
void test_zero(void);
void test_timer(void);
void test_alarm(void);
void test_fork(void);
void test_exec(void);
int do_check(void);
void got_alarm(int sig);
void busy_wait(int secs);
#define my_e(n) do { printf("Timer %s, ", names[timer]); e(n); } while(0)

static char *executable;
static int signals;
static int timer;
static long system_hz;

static int sigs[] = { SIGALRM, SIGVTALRM, SIGPROF };
static const char *names[] = { "REAL", "VIRTUAL", "PROF" };

int main(argc, argv)
int argc;
char **argv;
{
  int i, m = 0xFFFF, n = 0xF;
  char cp_cmd[NAME_MAX+10];

  system_hz = sysconf(_SC_CLK_TCK);

  if (strcmp(argv[0], "DO CHECK") == 0) {
  	timer = atoi(argv[1]);

	exit(do_check());
  }

  executable = argv[0];

  start(41);

  snprintf(cp_cmd, sizeof(cp_cmd), "cp ../%s .", executable);
  system(cp_cmd);

  if (argc >= 2) m = atoi(argv[1]);
  if (argc >= 3) n = atoi(argv[2]);

  for (i = 0; i < ITERATIONS; i++) {
  	if (n & 1) test(m, ITIMER_REAL);
  	if (n & 2) test(m, ITIMER_VIRTUAL);
  	if (n & 4) test(m, ITIMER_PROF);
  }

  quit();
  return(-1);			/* impossible */
}

void test(m, t)
int m;
int t;
{
  timer = t;

  if (m & 0001) test_which();
  if (m & 0002) test_getset();
  if (m & 0004) test_neglarge();
  if (m & 0010) test_zero();
  if (m & 0020) test_timer();
  if (m & 0040) test_alarm();
  if (m & 0100) test_fork();
  if (m & 0200) test_exec();
}

/* test invalid and unsupported 'which' values */
void test_which()
{
  struct itimerval it;

  subtest = 0;

  errno = 0; if (!getitimer(-1, &it) || errno != EINVAL) my_e(1);
  errno = 0; if ( getitimer(timer, &it)                ) my_e(2);
  errno = 0; if (!getitimer( 3, &it) || errno != EINVAL) my_e(3);
}

/* test if we get back what we set */
void test_getset()
{
  struct itimerval it, oit;

  subtest = 1;

  /* no alarm should be set initially */
  if (getitimer(timer, &it)) my_e(1);
  if (!EQITIMER(it, 0, 0, 0, 0)) my_e(2);

  if (setitimer(timer, &it, &oit)) my_e(3);
  if (setitimer(timer, &oit, NULL)) my_e(4);
  if (!EQITIMER(oit, 0, 0, 0, 0)) my_e(5);

  FILLITIMER(it, 123, 0, 456, 0);
  if (setitimer(timer, &it, NULL)) my_e(6);

  FILLITIMER(it, 987, 0, 654, 0);
  if (setitimer(timer, &it, &oit)) my_e(7);
  if (!LEITIMER(oit, 123, 0, 456, 0)) my_e(8);

  if (getitimer(timer, &oit)) my_e(9);
  if (!LEITIMER(oit, 987, 0, 654, 0)) my_e(10);

  FILLITIMER(it, 0, 0, 0, 0);
  if (setitimer(timer, &it, &oit)) my_e(11);
  if (!LEITIMER(oit, 987, 0, 654, 0)) my_e(12);

  if (getitimer(timer, &oit)) my_e(13);
  if (!EQITIMER(oit, 0, 0, 0, 0)) my_e(14);
}

/* test negative/large values */
void test_neglarge()
{
  struct itimerval it;

  subtest = 2;

  FILLITIMER(it, 4, 0, 5, 0);
  if (setitimer(timer, &it, NULL)) my_e(1);

  FILLITIMER(it, 1000000000, 0, 0, 0);
  if (!setitimer(timer, &it, NULL) || errno != EINVAL) my_e(2);

  FILLITIMER(it, 0, 1000000, 0, 0);
  if (!setitimer(timer, &it, NULL) || errno != EINVAL) my_e(3);

  FILLITIMER(it, 0, 0, 0, 1000000);
  if (!setitimer(timer, &it, NULL) || errno != EINVAL) my_e(4);

  FILLITIMER(it, -1, 0, 0, 0);
  if (!setitimer(timer, &it, NULL) || errno != EINVAL) my_e(5);

  FILLITIMER(it, 0, -1, 0, 0);
  if (!setitimer(timer, &it, NULL) || errno != EINVAL) my_e(6);

  FILLITIMER(it, 0, 0, -1, 0);
  if (!setitimer(timer, &it, NULL) || errno != EINVAL) my_e(7);

  FILLITIMER(it, 0, 0, 0, -1);
  if (!setitimer(timer, &it, NULL) || errno != EINVAL) my_e(8);

  if (getitimer(timer, &it)) my_e(9);
  if (!LEITIMER(it, 4, 0, 5, 0)) my_e(10);
}

/* setitimer with a zero timer has to set the interval to zero as well */
void test_zero()
{
  struct itimerval it;

  subtest = 3;

  it.it_value.tv_sec = 0;
  it.it_value.tv_usec = 0;
  it.it_interval.tv_sec = 1;
  it.it_interval.tv_usec = 1;

  if (setitimer(timer, &it, NULL)) my_e(1);
  if (getitimer(timer, &it)) my_e(2);
  if (!EQITIMER(it, 0, 0, 0, 0)) my_e(3);
}

/* test actual timer functioning */
void test_timer()
{
  struct itimerval it;

  subtest = 4;

  if (signal(sigs[timer], got_alarm) == SIG_ERR) my_e(1);

  FILLITIMER(it, 0, 100000, 0, 100000);

  if (setitimer(timer, &it, NULL)) my_e(2);

  signals = 0;
  busy_wait(1);

  FILLITIMER(it, 0, 0, 0, 0);
  if (setitimer(timer, &it, NULL)) my_e(3);

  /* we don't know how many signals we'll actually get in practice,
   * so these checks more or less cover the extremes of the acceptable */
  if (signals < 2) my_e(4);
  if (signals > system_hz * 2) my_e(5);

  /* only for REAL timer can we check against the clock */
  if (timer == ITIMER_REAL) {
	FILLITIMER(it, 1, 0, 0, 0);
	if (setitimer(timer, &it, NULL)) my_e(6);

	signals = 0;
	busy_wait(1);

  	FILLITIMER(it, 0, 0, 0, 0);
  	if (setitimer(timer, &it, NULL)) my_e(7);

	if (signals != 1) my_e(8);
  }

  signals = 0;
  busy_wait(1);

  if (signals != 0) my_e(9);
}

/* test itimer/alarm interaction */
void test_alarm(void) {
  struct itimerval it;

  /* only applicable for ITIMER_REAL */
  if (timer != ITIMER_REAL) return;

  subtest = 5;

  if (signal(SIGALRM, got_alarm) == SIG_ERR) my_e(1);

  FILLITIMER(it, 3, 0, 1, 0);
  if (setitimer(timer, &it, NULL)) my_e(2);

  if (alarm(2) != 3) my_e(3);

  if (getitimer(timer, &it)) my_e(4);
  if (!LEITIMER(it, 2, 0, 0, 0)) my_e(5);

  signals = 0;
  busy_wait(5);

  if (signals != 1) my_e(6);

  if (getitimer(timer, &it)) my_e(7);
  if (!EQITIMER(it, 0, 0, 0, 0)) my_e(8);
}

/* test that the timer is reset on forking */
void test_fork(void) {
  struct itimerval it, oit;
  pid_t pid;
  int status;

  subtest = 6;

  FILLITIMER(it, 12, 34, 56, 78);

  if (setitimer(timer, &it, NULL)) my_e(1);

  pid = fork();
  if (pid < 0) my_e(2);

  if (pid == 0) {
    if (getitimer(timer, &it)) exit(5);
    if (!EQITIMER(it, 0, 0, 0, 0)) exit(6);

    exit(0);
  }

  if (wait(&status) != pid) my_e(3);
  if (!WIFEXITED(status)) my_e(4);
  if (WEXITSTATUS(status) != 0) my_e(WEXITSTATUS(status));

  FILLITIMER(it, 0, 0, 0, 0);
  if (setitimer(timer, &it, &oit)) my_e(7);
  if (!LEITIMER(oit, 12, 34, 56, 78)) my_e(8);
}

/* test if timer is carried over to exec()'ed process */
void test_exec(void) {
  struct itimerval it;
  pid_t pid;
  int status;
  char buf[2];

  subtest = 7;

  pid = fork();
  if (pid < 0) my_e(1);

  if (pid == 0) {
    FILLITIMER(it, 3, 0, 1, 0);
    if (setitimer(timer, &it, NULL)) exit(2);

    sprintf(buf, "%d", timer);
    execl(executable, "DO CHECK", buf, NULL);

    exit(3);
  }

  if (wait(&status) != pid) my_e(4);
  if (WIFSIGNALED(status)) {
    /* process should have died from corresponding signal */
    if (WTERMSIG(status) != sigs[timer]) my_e(5);
  }
  else {
    if (WIFEXITED(status)) my_e(WEXITSTATUS(status));
    else my_e(6);
  }
}

/* procedure of the exec()'ed process */
int do_check()
{
  struct itimerval it;

  if (getitimer(timer, &it)) return(81);
  if (!LEITIMER(it, 3, 0, 1, 0)) return(82);

  busy_wait(60);

  return(83);
}

void busy_wait(secs)
int secs;
{
  time_t now, exp;
  int i;

  exp = time(&now) + secs + 1;

  while (now < exp) {
  	for (i = 0; i < 100000; i++);

	time(&now);
  }
}

void got_alarm(sig)
int sig;
{
  if (sig != sigs[timer]) my_e(1001);

  signals++;
}