1  /* Tests for POSIX timer implementation using another process's CPU clock.  */
       2  
       3  #include <unistd.h>
       4  
       5  #if _POSIX_THREADS && defined _POSIX_CPUTIME
       6  
       7  #include <errno.h>
       8  #include <stdio.h>
       9  #include <stdlib.h>
      10  #include <string.h>
      11  #include <fcntl.h>
      12  #include <time.h>
      13  #include <signal.h>
      14  #include <sys/wait.h>
      15  
      16  #include <support/xunistd.h>
      17  
      18  static clockid_t child_clock;
      19  
      20  #define TEST_CLOCK child_clock
      21  #define TEST_CLOCK_MISSING(clock) \
      22    (setup_test () ? "other-process CPU clock timer support" : NULL)
      23  
      24  /* This function is intended to rack up both user and system time.  */
      25  static void
      26  chew_cpu (void)
      27  {
      28    while (1)
      29      {
      30        static volatile char buf[4096];
      31        for (int i = 0; i < 100; ++i)
      32  	for (size_t j = 0; j < sizeof buf; ++j)
      33  	  buf[j] = 0xaa;
      34        int nullfd = open ("/dev/null", O_WRONLY);
      35        for (int i = 0; i < 100; ++i)
      36  	for (size_t j = 0; j < sizeof buf; ++j)
      37  	  buf[j] = 0xbb;
      38        xwrite (nullfd, (char *) buf, sizeof buf);
      39        close (nullfd);
      40        if (getppid () == 1)
      41  	_exit (2);
      42      }
      43  }
      44  
      45  static pid_t child;
      46  static void
      47  cleanup_child (void)
      48  {
      49    if (child <= 0)
      50      return;
      51    if (kill (child, SIGKILL) < 0 && errno != ESRCH)
      52      printf ("cannot kill child %d: %m\n", child);
      53    else
      54      {
      55        int status;
      56        errno = 0;
      57        if (waitpid (child, &status, 0) != child)
      58  	printf ("waitpid %d: %m\n", child);
      59      }
      60  }
      61  #define CLEANUP_HANDLER cleanup_child ()
      62  
      63  static int
      64  setup_test (void)
      65  {
      66    /* Test timers on a process CPU clock by having a child process eating
      67       CPU.  First make sure we can make such timers at all.  */
      68  
      69    int pipefd[2];
      70    if (pipe (pipefd) < 0)
      71      {
      72        printf ("pipe: %m\n");
      73        exit (1);
      74      }
      75  
      76    child = fork ();
      77  
      78    if (child == 0)
      79      {
      80        char c;
      81        close (pipefd[1]);
      82        if (read (pipefd[0], &c, 1) == 1)
      83  	chew_cpu ();
      84        _exit (1);
      85      }
      86  
      87    if (child < 0)
      88      {
      89        printf ("fork: %m\n");
      90        exit (1);
      91      }
      92  
      93    atexit (&cleanup_child);
      94  
      95    close (pipefd[0]);
      96  
      97    int e = clock_getcpuclockid (child, &child_clock);
      98    if (e == EPERM)
      99      {
     100        puts ("clock_getcpuclockid does not support other processes");
     101        return 1;
     102      }
     103    if (e != 0)
     104      {
     105        printf ("clock_getcpuclockid: %s\n", strerror (e));
     106        exit (1);
     107      }
     108  
     109    timer_t t;
     110    if (timer_create (TEST_CLOCK, NULL, &t) != 0)
     111      {
     112        printf ("timer_create: %m\n");
     113        return 1;
     114      }
     115    timer_delete (t);
     116  
     117    /* Get the child started chewing.  */
     118    if (write (pipefd[1], "x", 1) != 1)
     119      {
     120        printf ("write to pipe: %m\n");
     121        return 1;
     122      }
     123    close (pipefd[1]);
     124  
     125    return 0;
     126  }
     127  
     128  #else
     129  # define TEST_CLOCK_MISSING(clock) "process clocks"
     130  #endif
     131  
     132  #include "tst-timer4.c"