/* $NetBSD: t_time_arith.c,v 1.1 2024/12/22 23:25:15 riastradh Exp $ */ /*- * Copyright (c) 2024 The NetBSD Foundation, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include __RCSID("$NetBSD: t_time_arith.c,v 1.1 2024/12/22 23:25:15 riastradh Exp $"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "h_macros.h" enum { HZ = 100 }; int hz = HZ; int tick = 1000000/HZ; static sig_atomic_t jmp_en; static int jmp_sig; static jmp_buf jmp; static void handle_signal(int signo) { const int errno_save = errno; char buf[32]; snprintf_ss(buf, sizeof(buf), "signal %d\n", signo); (void)write(STDERR_FILENO, buf, strlen(buf)); errno = errno_save; if (jmp_en) { jmp_sig = signo; jmp_en = 0; longjmp(jmp, 1); } else { raise_default_signal(signo); } } const struct itimer_transition { struct itimerspec it_time; struct timespec it_now; struct timespec it_next; int it_overruns; const char *it_xfail; } itimer_transitions[] = { /* * Fired more than one interval early -- treat clock as wound * backwards, not counting overruns. Advance by somewhere * between one and two intervals from now. */ [0] = {{.it_value = {3,0}, .it_interval = {1,0}}, {0,1}, {2,0}, 0, /* 1.709551617 */ "PR kern/58925: itimer(9) responds erratically to clock wound back"}, [1] = {{.it_value = {3,0}, .it_interval = {1,0}}, {0,500000000}, {2,0}, 0, /* 1.709551615 */ "PR kern/58925: itimer(9) responds erratically to clock wound back"}, [2] = {{.it_value = {3,0}, .it_interval = {1,0}}, {0,999999999}, {2,0}, 0, /* 2.709551613 */ "PR kern/58925: itimer(9) responds erratically to clock wound back"}, [3] = {{.it_value = {3,0}, .it_interval = {1,0}}, {1,0}, {2,0}, 0, /* 2.709551615 */ "PR kern/58925: itimer(9) responds erratically to clock wound back"}, [4] = {{.it_value = {3,0}, .it_interval = {1,0}}, {1,1}, {3,0}, 0, /* 2.709551617 */ "PR kern/58925: itimer(9) responds erratically to clock wound back"}, [5] = {{.it_value = {3,0}, .it_interval = {1,0}}, {1,500000000}, {3,0}, 0, /* 2.709551615 */ "PR kern/58925: itimer(9) responds erratically to clock wound back"}, [6] = {{.it_value = {3,0}, .it_interval = {1,0}}, {1,999999999}, {3,0}, 0, /* 3.709551613 */ "PR kern/58925: itimer(9) responds erratically to clock wound back"}, /* * Fired exactly one interval early. Treat this too as clock * wound backwards. */ [7] = {{.it_value = {3,0}, .it_interval = {1,0}}, {2,0}, {3,0}, 0, /* 3.709551615 */ "PR kern/58925: itimer(9) responds erratically to clock wound back"}, /* * Fired less than one interval early -- callouts and real-time * clock might not be perfectly synced, counted as zero * overruns. Advance by one interval from the scheduled time. */ [8] = {{.it_value = {3,0}, .it_interval = {1,0}}, {2,1}, {4,0}, 0, /* 3.000000001 */ "PR kern/58925: itimer(9) responds erratically to clock wound back"}, [9] = {{.it_value = {3,0}, .it_interval = {1,0}}, {2,500000000}, {4,0}, 0, /* 3.999999999 */ "PR kern/58925: itimer(9) responds erratically to clock wound back"}, [10] = {{.it_value = {3,0}, .it_interval = {1,0}}, {2,999999999}, {4,0}, 0, /* 4.999999997 */ "PR kern/58925: itimer(9) responds erratically to clock wound back"}, /* * Fired exactly on time. Advance by one interval. */ [11] = {{.it_value = {3,0}, .it_interval = {1,0}}, {3,0}, {4,0}, 0, NULL}, /* * Fired late by less than one interval -- callouts and * real-time clock might not be prefectly synced, counted as * zero overruns. Advance by one interval from the scheduled * time (even if it's very close to a full interval). */ [12] = {{.it_value = {3,0}, .it_interval = {1,0}}, {3,1}, {4,0}, 0, NULL}, [14] = {{.it_value = {3,0}, .it_interval = {1,0}}, {3,500000000}, {4,0}, 0, NULL}, [15] = {{.it_value = {3,0}, .it_interval = {1,0}}, {3,999999999}, {4,0}, 0, NULL}, /* * Fired late by exactly one interval -- treat it as overrun. * * XXX ...or treat it as not overrun? wat */ [16] = {{.it_value = {3,0}, .it_interval = {1,0}}, {4,0}, {4,0}, 0, NULL}, /* * Fired late by more than one interval but less than two -- * overrun. */ [17] = {{.it_value = {3,0}, .it_interval = {1,0}}, {4,1}, {5,0}, 1, /* 4.000000000, overruns=0 */ "PR kern/58927: itimer(9): overrun accounting is broken"}, [18] = {{.it_value = {3,0}, .it_interval = {1,0}}, {4,500000000}, {5,0}, 1, /* 4.000000000, overruns=0 */ "PR kern/58927: itimer(9): overrun accounting is broken"}, [19] = {{.it_value = {3,0}, .it_interval = {1,0}}, {4,999999999}, {5,0}, 1, /* 4.000000000, overruns=0 */ "PR kern/58927: itimer(9): overrun accounting is broken"}, /* * Fired late by exactly two intervals -- two overruns. */ [20] = {{.it_value = {3,0}, .it_interval = {1,0}}, {5,0}, {6,0}, 2, /* 4.000000000, overruns=0 */ "PR kern/58927: itimer(9): overrun accounting is broken"}, /* * Fired late by more intervals plus slop, up to 32. * * XXX Define DELAYTIMER_MAX so we can write it in terms of * that. */ [21] = {{.it_value = {3,0}, .it_interval = {1,0}}, {13,123456789}, {14,0}, 10, /* 4.000000000, overruns=0 */ "PR kern/58927: itimer(9): overrun accounting is broken"}, [22] = {{.it_value = {3,0}, .it_interval = {1,0}}, {34,999999999}, {32,0}, 32, /* 4.000000000, overruns=0 */ "PR kern/58927: itimer(9): overrun accounting is broken"}, /* * Fired late by roughly INT_MAX intervals. */ [23] = {{.it_value = {3,0}, .it_interval = {1,0}}, {(time_t)3 + INT_MAX - 1, 0}, {(time_t)3 + INT_MAX, 0}, INT_MAX, /* 4.000000000, overruns=0 */ "PR kern/58927: itimer(9): overrun accounting is broken"}, [24] = {{.it_value = {3,0}, .it_interval = {1,0}}, {(time_t)3 + INT_MAX, 0}, {(time_t)3 + INT_MAX + 1, 0}, INT_MAX, /* 4.000000000, overruns=0 */ "PR kern/58926: itimer(9) integer overflow in overrun counting"}, [25] = {{.it_value = {3,0}, .it_interval = {1,0}}, {(time_t)3 + INT_MAX + 1, 0}, {(time_t)3 + INT_MAX + 2, 0}, INT_MAX, /* 4.000000000, overruns=0 */ "PR kern/58926: itimer(9) integer overflow in overrun counting"}, /* (2^63 - 1) ns */ [26] = {{.it_value = {3,0}, .it_interval = {9223372036,854775807}}, {3,1}, {9223372039,854775807}, 0, NULL}, /* 2^63 ns */ [27] = {{.it_value = {3,0}, .it_interval = {9223372036,854775808}}, {3,1}, {9223372039,854775808}, 0, NULL}, /* (2^63 + 1) ns */ [28] = {{.it_value = {3,0}, .it_interval = {9223372036,854775809}}, {3,1}, {9223372039,854775809}, 0, NULL}, /* * Overflows -- we should (XXX but currently don't) reject * intervals of at least 2^64 nanoseconds up front, since this * is more time than it is reasonable to wait (more than 584 * years). */ /* (2^64 - 1) ns */ [29] = {{.it_value = {3,0}, .it_interval = {18446744073,709551615}}, {2,999999999}, {0,0}, 0, "PR kern/58922: itimer(9): arithmetic overflow"}, /* 2^64 ns */ [30] = {{.it_value = {3,0}, .it_interval = {18446744073,709551616}}, {2,999999999}, {0,0}, 0, "PR kern/58922: itimer(9): arithmetic overflow"}, /* (2^64 + 1) ns */ [31] = {{.it_value = {3,0}, .it_interval = {18446744073,709551617}}, {2,999999999}, {0,0}, 0, "PR kern/58922: itimer(9): arithmetic overflow"}, /* (2^63 - 1) us */ [32] = {{.it_value = {3,0}, .it_interval = {9223372036854,775807}}, {2,999999999}, {0,0}, 0, "PR kern/58922: itimer(9): arithmetic overflow"}, /* 2^63 us */ [33] = {{.it_value = {3,0}, .it_interval = {9223372036854,775808}}, {2,999999999}, {0,0}, 0, "PR kern/58922: itimer(9): arithmetic overflow"}, /* (2^63 + 1) us */ [34] = {{.it_value = {3,0}, .it_interval = {9223372036854,775809}}, {2,999999999}, {0,0}, 0, "PR kern/58922: itimer(9): arithmetic overflow"}, /* (2^64 - 1) us */ [35] = {{.it_value = {3,0}, .it_interval = {18446744073709,551615}}, {2,999999999}, {0,0}, 0, "PR kern/58922: itimer(9): arithmetic overflow"}, /* 2^64 us */ [36] = {{.it_value = {3,0}, .it_interval = {18446744073709,551616}}, {2,999999999}, {0,0}, 0, "PR kern/58922: itimer(9): arithmetic overflow"}, /* (2^64 + 1) us */ [37] = {{.it_value = {3,0}, .it_interval = {18446744073709,551617}}, {2,999999999}, {0,0}, 0, "PR kern/58922: itimer(9): arithmetic overflow"}, /* (2^63 - 1) ms */ [38] = {{.it_value = {3,0}, .it_interval = {9223372036854775,807}}, {2,999999999}, {0,0}, 0, "PR kern/58922: itimer(9): arithmetic overflow"}, /* 2^63 ms */ [39] = {{.it_value = {3,0}, .it_interval = {9223372036854775,808}}, {2,999999999}, {0,0}, 0, "PR kern/58922: itimer(9): arithmetic overflow"}, /* (2^63 + 1) ms */ [40] = {{.it_value = {3,0}, .it_interval = {9223372036854775,809}}, {2,999999999}, {0,0}, 0, "PR kern/58922: itimer(9): arithmetic overflow"}, /* (2^64 - 1) ms */ [41] = {{.it_value = {3,0}, .it_interval = {18446744073709551,615}}, {2,999999999}, {0,0}, 0, "PR kern/58922: itimer(9): arithmetic overflow"}, /* 2^64 ms */ [42] = {{.it_value = {3,0}, .it_interval = {18446744073709551,616}}, {2,999999999}, {0,0}, 0, "PR kern/58922: itimer(9): arithmetic overflow"}, /* (2^64 + 1) ms */ [43] = {{.it_value = {3,0}, .it_interval = {18446744073709551,617}}, {2,999999999}, {0,0}, 0, "PR kern/58922: itimer(9): arithmetic overflow"}, /* invalid intervals */ [44] = {{.it_value = {3,0}, .it_interval = {-1,0}}, {3,1}, {0,0}, 0, NULL}, [45] = {{.it_value = {3,0}, .it_interval = {0,-1}}, {3,1}, {0,0}, 0, NULL}, [46] = {{.it_value = {3,0}, .it_interval = {0,1000000000}}, {3,1}, {0,0}, 0, NULL}, }; ATF_TC(itimer_transitions); ATF_TC_HEAD(itimer_transitions, tc) { atf_tc_set_md_var(tc, "descr", "Tests interval timer transitions"); } ATF_TC_BODY(itimer_transitions, tc) { volatile unsigned i; REQUIRE_LIBC(signal(SIGFPE, handle_signal), SIG_ERR); REQUIRE_LIBC(signal(SIGABRT, handle_signal), SIG_ERR); for (i = 0; i < __arraycount(itimer_transitions); i++) { struct itimer_transition it = itimer_transitions[i]; struct timespec next; int overruns; volatile bool aborted = true; volatile bool expect_abort = false; fprintf(stderr, "case %u\n", i); if (it.it_xfail) atf_tc_expect_fail("%s", it.it_xfail); if (itimespecfix(&it.it_time.it_value) != 0 || itimespecfix(&it.it_time.it_interval) != 0) { fprintf(stderr, "rejected by itimerspecfix\n"); expect_abort = true; } if (setjmp(jmp) == 0) { jmp_en = 1; itimer_transition(&it.it_time, &it.it_now, &next, &overruns); jmp_en = 0; aborted = false; } ATF_CHECK(!jmp_en); jmp_en = 0; /* paranoia */ if (expect_abort) { fprintf(stderr, "expected abort\n"); ATF_CHECK_MSG(aborted, "[%u] missing invariant assertion", i); ATF_CHECK_MSG(jmp_sig == SIGABRT, "[%u] missing invariant assertion", i); } else { ATF_CHECK_MSG(!aborted, "[%u] raised signal %d: %s", i, jmp_sig, strsignal(jmp_sig)); } ATF_CHECK_MSG((next.tv_sec == it.it_next.tv_sec && next.tv_nsec == it.it_next.tv_nsec), "[%u] periodic intervals of %lld.%09d from %lld.%09d" " last expired at %lld.%09d:" " next expiry at %lld.%09d, expected %lld.%09d", i, (long long)it.it_time.it_interval.tv_sec, (int)it.it_time.it_interval.tv_nsec, (long long)it.it_time.it_value.tv_sec, (int)it.it_time.it_value.tv_nsec, (long long)it.it_now.tv_sec, (int)it.it_now.tv_nsec, (long long)next.tv_sec, (int)next.tv_nsec, (long long)it.it_next.tv_sec, (int)it.it_next.tv_nsec); ATF_CHECK_EQ_MSG(overruns, it.it_overruns, "[%u] periodic intervals of %lld.%09d from %lld.%09d" " last expired at %lld.%09d:" " overruns %d, expected %d", i, (long long)it.it_time.it_interval.tv_sec, (int)it.it_time.it_interval.tv_nsec, (long long)it.it_time.it_value.tv_sec, (int)it.it_time.it_value.tv_nsec, (long long)it.it_now.tv_sec, (int)it.it_now.tv_nsec, overruns, it.it_overruns); if (it.it_xfail) atf_tc_expect_pass(); } } ATF_TP_ADD_TCS(tp) { ATF_TP_ADD_TC(tp, itimer_transitions); return atf_no_error(); }