]>
Commit | Line | Data |
---|---|---|
27561951 | 1 | /* Basic tests for getitimer and setitimer. |
dff8da6b | 2 | Copyright (C) 2021-2024 Free Software Foundation, Inc. |
27561951 AZ |
3 | This file is part of the GNU C Library. |
4 | ||
5 | The GNU C Library is free software; you can redistribute it and/or | |
6 | modify it under the terms of the GNU Lesser General Public | |
7 | License as published by the Free Software Foundation; either | |
8 | version 2.1 of the License, or (at your option) any later version. | |
9 | ||
10 | The GNU C Library is distributed in the hope that it will be useful, | |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
13 | Lesser General Public License for more details. | |
14 | ||
15 | You should have received a copy of the GNU Lesser General Public | |
16 | License along with the GNU C Library; if not, see | |
17 | <https://www.gnu.org/licenses/>. */ | |
18 | ||
19 | #include <array_length.h> | |
20 | #include <errno.h> | |
21 | #include <stdlib.h> | |
22 | #include <sys/time.h> | |
23 | #include <support/check.h> | |
5604830d | 24 | #include <support/support.h> |
27561951 AZ |
25 | #include <support/xsignal.h> |
26 | #include <unistd.h> | |
27 | #include <time.h> | |
28 | ||
29 | static sig_atomic_t cnt; | |
30 | ||
31 | static void | |
32 | alrm_handler (int sig) | |
33 | { | |
34 | if (++cnt > 3) | |
35 | cnt = 3; | |
36 | } | |
37 | ||
38 | static void | |
39 | intr_sleep (int sec) | |
40 | { | |
41 | struct timespec ts = { .tv_sec = sec, .tv_nsec = 0 }; | |
42 | while (nanosleep (&ts, &ts) == -1 && errno == EINTR) | |
43 | ; | |
44 | } | |
45 | ||
46 | static int | |
47 | do_test (void) | |
48 | { | |
49 | struct itimerval it, it_old; | |
50 | const int timers[] = { ITIMER_REAL, ITIMER_VIRTUAL, ITIMER_PROF }; | |
51 | for (int i = 0; i < array_length (timers); i++) | |
52 | { | |
53 | TEST_COMPARE (getitimer (timers[i], &it), 0); | |
54 | ||
55 | /* No timer set, all value should be 0. */ | |
56 | TEST_COMPARE (it.it_interval.tv_sec, 0); | |
57 | TEST_COMPARE (it.it_interval.tv_usec, 0); | |
58 | TEST_COMPARE (it.it_value.tv_sec, 0); | |
59 | TEST_COMPARE (it.it_value.tv_usec, 0); | |
60 | ||
61 | it.it_interval.tv_sec = 10; | |
62 | it.it_interval.tv_usec = 20; | |
63 | TEST_COMPARE (setitimer (timers[i], &it, NULL), 0); | |
64 | ||
65 | TEST_COMPARE (setitimer (timers[i], &(struct itimerval) { 0 }, &it_old), | |
66 | 0); | |
67 | /* ITIMER_REAL returns { 0, 0 } for single-shot timers, while | |
68 | other timers returns setitimer value. */ | |
69 | if (timers[i] == ITIMER_REAL) | |
70 | { | |
71 | TEST_COMPARE (it_old.it_interval.tv_sec, 0); | |
72 | TEST_COMPARE (it_old.it_interval.tv_usec, 0); | |
73 | } | |
74 | else | |
75 | { | |
76 | TEST_COMPARE (it_old.it_interval.tv_sec, 10); | |
958309cb AZ |
77 | /* Some systems might use a different precision for ITIMER_VIRTUAL |
78 | and ITIMER_IPROF and thus the value might be adjusted. To avoid | |
79 | trying to guess the resolution, we do not check it. */ | |
27561951 AZ |
80 | } |
81 | ||
82 | /* Create a periodic timer and check if the return value is the one | |
83 | previously set. */ | |
84 | it.it_interval.tv_sec = 10; | |
85 | it.it_interval.tv_usec = 20; | |
86 | it.it_value.tv_sec = 30; | |
87 | it.it_value.tv_usec = 40; | |
88 | TEST_COMPARE (setitimer (timers[i], &it, NULL), 0); | |
89 | ||
90 | TEST_COMPARE (setitimer (timers[i], &(struct itimerval) { 0 }, &it_old), | |
91 | 0); | |
92 | TEST_COMPARE (it.it_interval.tv_sec, it_old.it_interval.tv_sec); | |
958309cb AZ |
93 | if (timers[i] == ITIMER_REAL) |
94 | TEST_COMPARE (it.it_interval.tv_usec, it_old.it_interval.tv_usec); | |
27561951 AZ |
95 | |
96 | if (sizeof (time_t) == 4) | |
97 | continue; | |
98 | ||
99 | /* Same as before, but with a 64 bit time_t value. */ | |
100 | it.it_interval.tv_sec = (time_t) 0x1ffffffffull; | |
101 | it.it_interval.tv_usec = 20; | |
102 | it.it_value.tv_sec = 0; | |
103 | it.it_value.tv_usec = 0; | |
104 | ||
105 | /* Linux does not provide 64 bit time_t support for getitimer and | |
106 | setitimer on architectures with 32 bit time_t support. */ | |
5604830d | 107 | if (support_itimer_support_time64()) |
27561951 AZ |
108 | { |
109 | TEST_COMPARE (setitimer (timers[i], &it, NULL), 0); | |
110 | TEST_COMPARE (setitimer (timers[i], &(struct itimerval) { 0 }, | |
111 | &it_old), | |
112 | 0); | |
113 | /* ITIMER_REAL returns { 0, 0 } for single-sort timers, while other | |
114 | timers returns setitimer value. */ | |
115 | if (timers[i] == ITIMER_REAL) | |
116 | { | |
117 | TEST_COMPARE (it_old.it_interval.tv_sec, 0ull); | |
118 | TEST_COMPARE (it_old.it_interval.tv_usec, 0); | |
119 | } | |
27561951 AZ |
120 | } |
121 | else | |
122 | { | |
123 | TEST_COMPARE (setitimer (timers[i], &it, NULL), -1); | |
124 | TEST_COMPARE (errno, EOVERFLOW); | |
125 | } | |
126 | ||
127 | /* Create a periodic timer and check if the return value is the one | |
128 | previously set. */ | |
129 | it.it_interval.tv_sec = (time_t) 0x1ffffffffull; | |
130 | it.it_interval.tv_usec = 20; | |
131 | it.it_value.tv_sec = 30; | |
132 | it.it_value.tv_usec = 40; | |
5604830d | 133 | if (support_itimer_support_time64()) |
27561951 AZ |
134 | { |
135 | TEST_COMPARE (setitimer (timers[i], &it, NULL), 0); | |
136 | ||
137 | TEST_COMPARE (setitimer (timers[i], &(struct itimerval) { 0 }, | |
138 | &it_old), | |
139 | 0); | |
958309cb AZ |
140 | if (timers[i] == ITIMER_REAL) |
141 | { | |
142 | TEST_COMPARE (it.it_interval.tv_sec, it_old.it_interval.tv_sec); | |
143 | TEST_COMPARE (it.it_interval.tv_usec, it_old.it_interval.tv_usec); | |
144 | } | |
27561951 AZ |
145 | } |
146 | else | |
147 | { | |
148 | TEST_COMPARE (setitimer (timers[i], &it, NULL), -1); | |
149 | TEST_COMPARE (errno, EOVERFLOW); | |
150 | } | |
151 | } | |
152 | ||
153 | { | |
154 | struct sigaction sa = { .sa_handler = alrm_handler, .sa_flags = 0 }; | |
155 | sigemptyset (&sa.sa_mask); | |
156 | xsigaction (SIGALRM, &sa, NULL); | |
157 | } | |
158 | ||
159 | /* Setup a timer to 0.1s and sleep for 1s and check to 3 signal handler | |
160 | execution. */ | |
161 | it.it_interval.tv_sec = 0; | |
162 | it.it_interval.tv_usec = 100000; | |
163 | it.it_value.tv_sec = 0; | |
164 | it.it_value.tv_usec = 100000; | |
165 | ||
166 | /* Check ITIMER_VIRTUAL and ITIMER_PROF would require to generate load | |
167 | and be subject to system load. */ | |
168 | cnt = 0; | |
169 | TEST_COMPARE (setitimer (ITIMER_REAL, &it, NULL), 0); | |
170 | intr_sleep (1); | |
171 | TEST_COMPARE (cnt, 3); | |
172 | TEST_COMPARE (setitimer (ITIMER_REAL, &(struct itimerval) { 0 }, NULL), 0); | |
173 | ||
174 | return 0; | |
175 | } | |
176 | ||
177 | #include <support/test-driver.c> |