tools/testing/selftests/timers/alarmtimer-suspend.c

   1 /* alarmtimer suspend test
   2  *              John Stultz (john.stultz@linaro.org)
   3  *              (C) Copyright Linaro 2013
   4  *              Licensed under the GPLv2
   5  *
   6  *   This test makes sure the alarmtimer & RTC wakeup code is
   7  *   functioning.
   8  *
   9  *  To build:
  10  *      $ gcc alarmtimer-suspend.c -o alarmtimer-suspend -lrt
  11  *
  12  *   This program is free software: you can redistribute it and/or modify
  13  *   it under the terms of the GNU General Public License as published by
  14  *   the Free Software Foundation, either version 2 of the License, or
  15  *   (at your option) any later version.
  16  *
  17  *   This program is distributed in the hope that it will be useful,
  18  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *   GNU General Public License for more details.
  21  */
  22
  23
  24 #include <stdio.h>
  25 #include <unistd.h>
  26 #include <time.h>
  27 #include <string.h>
  28 #include <signal.h>
  29 #include <stdlib.h>
  30 #include <pthread.h>
  31 #ifdef KTEST
  32 #include "../kselftest.h"
  33 #else
  34 static inline int ksft_exit_pass(void)
  35 {
  36         exit(0);
  37 }
  38 static inline int ksft_exit_fail(void)
  39 {
  40         exit(1);
  41 }
  42 #endif
  43
  44 #define CLOCK_REALTIME                  0
  45 #define CLOCK_MONOTONIC                 1
  46 #define CLOCK_PROCESS_CPUTIME_ID        2
  47 #define CLOCK_THREAD_CPUTIME_ID         3
  48 #define CLOCK_MONOTONIC_RAW             4
  49 #define CLOCK_REALTIME_COARSE           5
  50 #define CLOCK_MONOTONIC_COARSE          6
  51 #define CLOCK_BOOTTIME                  7
  52 #define CLOCK_REALTIME_ALARM            8
  53 #define CLOCK_BOOTTIME_ALARM            9
  54 #define CLOCK_HWSPECIFIC                10
  55 #define CLOCK_TAI                       11
  56 #define NR_CLOCKIDS                     12
  57
  58
  59 #define NSEC_PER_SEC 1000000000ULL
  60 #define UNREASONABLE_LAT (NSEC_PER_SEC * 5) /* hopefully we resume in 5 secs */
  61
  62 #define SUSPEND_SECS 15
  63 int alarmcount;
  64 int alarm_clock_id;
  65 struct timespec start_time;
  66
  67
  68 char *clockstring(int clockid)
  69 {
  70         switch (clockid) {
  71         case CLOCK_REALTIME:
  72                 return "CLOCK_REALTIME";
  73         case CLOCK_MONOTONIC:
  74                 return "CLOCK_MONOTONIC";
  75         case CLOCK_PROCESS_CPUTIME_ID:
  76                 return "CLOCK_PROCESS_CPUTIME_ID";
  77         case CLOCK_THREAD_CPUTIME_ID:
  78                 return "CLOCK_THREAD_CPUTIME_ID";
  79         case CLOCK_MONOTONIC_RAW:
  80                 return "CLOCK_MONOTONIC_RAW";
  81         case CLOCK_REALTIME_COARSE:
  82                 return "CLOCK_REALTIME_COARSE";
  83         case CLOCK_MONOTONIC_COARSE:
  84                 return "CLOCK_MONOTONIC_COARSE";
  85         case CLOCK_BOOTTIME:
  86                 return "CLOCK_BOOTTIME";
  87         case CLOCK_REALTIME_ALARM:
  88                 return "CLOCK_REALTIME_ALARM";
  89         case CLOCK_BOOTTIME_ALARM:
  90                 return "CLOCK_BOOTTIME_ALARM";
  91         case CLOCK_TAI:
  92                 return "CLOCK_TAI";
  93         };
  94         return "UNKNOWN_CLOCKID";
  95 }
  96
  97
  98 long long timespec_sub(struct timespec a, struct timespec b)
  99 {
 100         long long ret = NSEC_PER_SEC * b.tv_sec + b.tv_nsec;
 101
 102         ret -= NSEC_PER_SEC * a.tv_sec + a.tv_nsec;
 103         return ret;
 104 }
 105
 106 int final_ret = 0;
 107
 108 void sigalarm(int signo)
 109 {
 110         long long delta_ns;
 111         struct timespec ts;
 112
 113         clock_gettime(alarm_clock_id, &ts);
 114         alarmcount++;
 115
 116         delta_ns = timespec_sub(start_time, ts);
 117         delta_ns -= NSEC_PER_SEC * SUSPEND_SECS * alarmcount;
 118
 119         printf("ALARM(%i): %ld:%ld latency: %lld ns ", alarmcount, ts.tv_sec,
 120                                                         ts.tv_nsec, delta_ns);
 121
 122         if (delta_ns > UNREASONABLE_LAT) {
 123                 printf("[FAIL]\n");
 124                 final_ret = -1;
 125         } else
 126                 printf("[OK]\n");
 127
 128 }
 129
 130 int main(void)
 131 {
 132         timer_t tm1;
 133         struct itimerspec its1, its2;
 134         struct sigevent se;
 135         struct sigaction act;
 136         int signum = SIGRTMAX;
 137
 138         /* Set up signal handler: */
 139         sigfillset(&act.sa_mask);
 140         act.sa_flags = 0;
 141         act.sa_handler = sigalarm;
 142         sigaction(signum, &act, NULL);
 143
 144         /* Set up timer: */
 145         memset(&se, 0, sizeof(se));
 146         se.sigev_notify = SIGEV_SIGNAL;
 147         se.sigev_signo = signum;
 148         se.sigev_value.sival_int = 0;
 149
 150         for (alarm_clock_id = CLOCK_REALTIME_ALARM;
 151                         alarm_clock_id <= CLOCK_BOOTTIME_ALARM;
 152                         alarm_clock_id++) {
 153
 154                 alarmcount = 0;
 155                 if (timer_create(alarm_clock_id, &se, &tm1) == -1) {
 156                         printf("timer_create failled, %s unspported?\n",
 157                                         clockstring(alarm_clock_id));
 158                         break;
 159                 }
 160
 161                 clock_gettime(alarm_clock_id, &start_time);
 162                 printf("Start time (%s): %ld:%ld\n", clockstring(alarm_clock_id),
 163                                 start_time.tv_sec, start_time.tv_nsec);
 164                 printf("Setting alarm for every %i seconds\n", SUSPEND_SECS);
 165                 its1.it_value = start_time;
 166                 its1.it_value.tv_sec += SUSPEND_SECS;
 167                 its1.it_interval.tv_sec = SUSPEND_SECS;
 168                 its1.it_interval.tv_nsec = 0;
 169
 170                 timer_settime(tm1, TIMER_ABSTIME, &its1, &its2);
 171
 172                 while (alarmcount < 5)
 173                         sleep(1); /* First 5 alarms, do nothing */
 174
 175                 printf("Starting suspend loops\n");
 176                 while (alarmcount < 10) {
 177                         int ret;
 178
 179                         sleep(3);
 180                         ret = system("echo mem > /sys/power/state");
 181                         if (ret)
 182                                 break;
 183                 }
 184                 timer_delete(tm1);
 185         }
 186         if (final_ret)
 187                 return ksft_exit_fail();
 188         return ksft_exit_pass();
 189 }