redonkable
/
alistair23-linux
1
0
Fork 0
Code Releases Activity

linux-kselftest-4.1-rc1 

This update adds install and packaging tools developed on top
 of back-end shared logic enhancemnets to run and install tests.
 In addition several timer tests are added.
 
 - New timer tests from John Stultz
 - rtc test from Prarit Bhargava
 - Enhancements to un and install tests from Michael Ellerman
 - Install and packaging tools from Shuah Khan
 - Cross-compilation enablement from Tyler Baker
 - A couple of bug fixes.
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1
 
 iQIcBAABAgAGBQJVIuw/AAoJEAsCRMQNDUMcO5gP/RlKsICYrG8R26cifiDJn7G0
 loSNuZ7f1oGiXtAw/MjCCUI9bxS9c6Y7z03FsgsztU6BN3xy2N0y1dsy29ix8Vc5
 uOak3Gl9fVg+cVMu6nTuDMMesBXpRCP9Wy+bmS2yBl8iTYETzagjLpMxCXcNbkll
 JSx78+09KE3H7HflCl2mK9HjmIfmZzu5TDCzYgwZHn6BC9atZBpJDNfD+mGDJSBo
 B+UMeR9rGV25axELky5Ul4N9f6Gssw4sEYMLx+UwyRE27kvL4q3jKMpIPgqtmYJh
 T1Ob09XaCEpiUF9eTdWoQWQT3AXVJTExPBmAfMqgv+znoEmx82xccqe8kWmbDiUP
 rcwfCBUYk5fS2UXc1L6fa5aBMtJUaFb9KBhbcTJNWAtMc5YYOOpTiQmEKaE2Rc6n
 5aRf2sEc9T1DG52BKde7Vg9GaAuzHgkomJDJeu4NtYJgoNuDyYnrQcGs13Xe+4DK
 u3hpiu3fz/0Pt+sX9hIMVaUbGwO6TticyEHNtkAdinRSjTcOVg6oYWh1WrWTcOPp
 Z0PH0ysdKF7nPk78uLqaSz9b20IwivyEaLVwczc1OkPoTjsrbm+3IP/oqepmhK+C
 S0+oVL4BWHHSyK6Lls7maXCy0D356GT6AaIKyzpJ2f36QhIjaTVX8RPZ2l6dC6h0
 ieZZQYW4ALd+6qmfzPxe
 =M1zT
 -----END PGP SIGNATURE-----

Merge tag 'linux-kselftest-4.1-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/shuah/linux-kselftest

Pull kselftest updates from Shuah Khan:
 "This is a milestone update in a sense.  Several new tests and install
  and packaging support is added in this update.

  This update adds install and packaging tools developed on top of
  back-end shared logic enhancemnets to run and install tests.  In
  addition several timer tests are added.

   - New timer tests from John Stultz

   - rtc test from Prarit Bhargava

   - Enhancements to un and install tests from Michael Ellerman

   - Install and packaging tools from Shuah Khan

   - Cross-compilation enablement from Tyler Baker

   - A couple of bug fixes"

* tag 'linux-kselftest-4.1-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/shuah/linux-kselftest: (42 commits)
  ftracetest: Do not use usleep directly
  selftest/mqueue: enable cross compilation
  selftest/ipc: enable cross compilation
  selftest/memfd: include default header install path
  selftest/mount: enable cross compilation
  selftest/memfd: enable cross compilation
  kselftests: timers: Make set-timer-lat fail more gracefully for !CAP_WAKE_ALARM
  selftests: Change memory on-off-test.sh name to be unique
  selftests: change cpu on-off-test.sh name to be unique
  selftests/mount: Make git ignore all binaries in mount test suite
  kselftests: timers: Reduce default runtime on inconsistency-check and set-timer-lat
  ftracetest: Convert exit -1 to exit $FAIL
  ftracetest: Cope properly with stack tracer not being enabled
  tools, update rtctest.c to verify passage of time
  Documentation, split up rtc.txt into documentation and test file
  selftests: Add tool to generate kselftest tar archive
  selftests: Add kselftest install tool
  selftests: Set CC using CROSS_COMPILE once in lib.mk
  selftests: Add install support for the powerpc tests
  selftests/timers: Use shared logic to run and install tests
  ...
hifive-unleashed-5.1
Linus Torvalds 2015-04-13 08:59:21 -07:00
parent 39a8804455 2bfd4d1f8c
commit 4541fec310
69 changed files with 3368 additions and 461 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

264
Documentation/rtc.txt
View File

@ -204,266 +204,4 @@ Some common examples:
* RTC_PIE_ON, RTC_PIE_OFF: These are also emulated by the generic code.
If all else fails, check out the rtc-test.c driver!
-------------------- 8< ---------------- 8< -----------------------------
/*
* Real Time Clock Driver Test/Example Program
*
* Compile with:
* gcc -s -Wall -Wstrict-prototypes rtctest.c -o rtctest
*
* Copyright (C) 1996, Paul Gortmaker.
*
* Released under the GNU General Public License, version 2,
* included herein by reference.
*
*/
#include <stdio.h>
#include <linux/rtc.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
/*
* This expects the new RTC class driver framework, working with
* clocks that will often not be clones of what the PC-AT had.
* Use the command line to specify another RTC if you need one.
*/
static const char default_rtc[] = "/dev/rtc0";
int main(int argc, char **argv)
{
int i, fd, retval, irqcount = 0;
unsigned long tmp, data;
struct rtc_time rtc_tm;
const char *rtc = default_rtc;
switch (argc) {
case 2:
rtc = argv[1];
/* FALLTHROUGH */
case 1:
break;
default:
fprintf(stderr, "usage: rtctest [rtcdev]\n");
return 1;
}
fd = open(rtc, O_RDONLY);
if (fd == -1) {
perror(rtc);
exit(errno);
}
fprintf(stderr, "\n\t\t\tRTC Driver Test Example.\n\n");
/* Turn on update interrupts (one per second) */
retval = ioctl(fd, RTC_UIE_ON, 0);
if (retval == -1) {
if (errno == ENOTTY) {
fprintf(stderr,
"\n...Update IRQs not supported.\n");
goto test_READ;
}
perror("RTC_UIE_ON ioctl");
exit(errno);
}
fprintf(stderr, "Counting 5 update (1/sec) interrupts from reading %s:",
rtc);
fflush(stderr);
for (i=1; i<6; i++) {
/* This read will block */
retval = read(fd, &data, sizeof(unsigned long));
if (retval == -1) {
perror("read");
exit(errno);
}
fprintf(stderr, " %d",i);
fflush(stderr);
irqcount++;
}
fprintf(stderr, "\nAgain, from using select(2) on /dev/rtc:");
fflush(stderr);
for (i=1; i<6; i++) {
struct timeval tv = {5, 0}; /* 5 second timeout on select */
fd_set readfds;
FD_ZERO(&readfds);
FD_SET(fd, &readfds);
/* The select will wait until an RTC interrupt happens. */
retval = select(fd+1, &readfds, NULL, NULL, &tv);
if (retval == -1) {
perror("select");
exit(errno);
}
/* This read won't block unlike the select-less case above. */
retval = read(fd, &data, sizeof(unsigned long));
if (retval == -1) {
perror("read");
exit(errno);
}
fprintf(stderr, " %d",i);
fflush(stderr);
irqcount++;
}
/* Turn off update interrupts */
retval = ioctl(fd, RTC_UIE_OFF, 0);
if (retval == -1) {
perror("RTC_UIE_OFF ioctl");
exit(errno);
}
test_READ:
/* Read the RTC time/date */
retval = ioctl(fd, RTC_RD_TIME, &rtc_tm);
if (retval == -1) {
perror("RTC_RD_TIME ioctl");
exit(errno);
}
fprintf(stderr, "\n\nCurrent RTC date/time is %d-%d-%d, %02d:%02d:%02d.\n",
rtc_tm.tm_mday, rtc_tm.tm_mon + 1, rtc_tm.tm_year + 1900,
rtc_tm.tm_hour, rtc_tm.tm_min, rtc_tm.tm_sec);
/* Set the alarm to 5 sec in the future, and check for rollover */
rtc_tm.tm_sec += 5;
if (rtc_tm.tm_sec >= 60) {
rtc_tm.tm_sec %= 60;
rtc_tm.tm_min++;
}
if (rtc_tm.tm_min == 60) {
rtc_tm.tm_min = 0;
rtc_tm.tm_hour++;
}
if (rtc_tm.tm_hour == 24)
rtc_tm.tm_hour = 0;
retval = ioctl(fd, RTC_ALM_SET, &rtc_tm);
if (retval == -1) {
if (errno == ENOTTY) {
fprintf(stderr,
"\n...Alarm IRQs not supported.\n");
goto test_PIE;
}
perror("RTC_ALM_SET ioctl");
exit(errno);
}
/* Read the current alarm settings */
retval = ioctl(fd, RTC_ALM_READ, &rtc_tm);
if (retval == -1) {
perror("RTC_ALM_READ ioctl");
exit(errno);
}
fprintf(stderr, "Alarm time now set to %02d:%02d:%02d.\n",
rtc_tm.tm_hour, rtc_tm.tm_min, rtc_tm.tm_sec);
/* Enable alarm interrupts */
retval = ioctl(fd, RTC_AIE_ON, 0);
if (retval == -1) {
perror("RTC_AIE_ON ioctl");
exit(errno);
}
fprintf(stderr, "Waiting 5 seconds for alarm...");
fflush(stderr);
/* This blocks until the alarm ring causes an interrupt */
retval = read(fd, &data, sizeof(unsigned long));
if (retval == -1) {
perror("read");
exit(errno);
}
irqcount++;
fprintf(stderr, " okay. Alarm rang.\n");
/* Disable alarm interrupts */
retval = ioctl(fd, RTC_AIE_OFF, 0);
if (retval == -1) {
perror("RTC_AIE_OFF ioctl");
exit(errno);
}
test_PIE:
/* Read periodic IRQ rate */
retval = ioctl(fd, RTC_IRQP_READ, &tmp);
if (retval == -1) {
/* not all RTCs support periodic IRQs */
if (errno == ENOTTY) {
fprintf(stderr, "\nNo periodic IRQ support\n");
goto done;
}
perror("RTC_IRQP_READ ioctl");
exit(errno);
}
fprintf(stderr, "\nPeriodic IRQ rate is %ldHz.\n", tmp);
fprintf(stderr, "Counting 20 interrupts at:");
fflush(stderr);
/* The frequencies 128Hz, 256Hz, ... 8192Hz are only allowed for root. */
for (tmp=2; tmp<=64; tmp*=2) {
retval = ioctl(fd, RTC_IRQP_SET, tmp);
if (retval == -1) {
/* not all RTCs can change their periodic IRQ rate */
if (errno == ENOTTY) {
fprintf(stderr,
"\n...Periodic IRQ rate is fixed\n");
goto done;
}
perror("RTC_IRQP_SET ioctl");
exit(errno);
}
fprintf(stderr, "\n%ldHz:\t", tmp);
fflush(stderr);
/* Enable periodic interrupts */
retval = ioctl(fd, RTC_PIE_ON, 0);
if (retval == -1) {
perror("RTC_PIE_ON ioctl");
exit(errno);
}
for (i=1; i<21; i++) {
/* This blocks */
retval = read(fd, &data, sizeof(unsigned long));
if (retval == -1) {
perror("read");
exit(errno);
}
fprintf(stderr, " %d",i);
fflush(stderr);
irqcount++;
}
/* Disable periodic interrupts */
retval = ioctl(fd, RTC_PIE_OFF, 0);
if (retval == -1) {
perror("RTC_PIE_OFF ioctl");
exit(errno);
}
}
done:
fprintf(stderr, "\n\n\t\t\t *** Test complete ***\n");
close(fd);
return 0;
}
If all else fails, check out the tools/testing/selftests/timers/rtctest.c test!

1
MAINTAINERS
View File

@ -8559,6 +8559,7 @@ F: include/uapi/linux/timex.h
F: kernel/time/clocksource.c
F: kernel/time/time*.c
F: kernel/time/ntp.c
F: tools/testing/selftests/timers/
SC1200 WDT DRIVER
M: Zwane Mwaikambo <zwanem@gmail.com>

33
tools/testing/selftests/Makefile
View File

@ -55,7 +55,40 @@ clean_hotplug:
make -C $$TARGET clean; \
done;
INSTALL_PATH ?= install
INSTALL_PATH := $(abspath $(INSTALL_PATH))
ALL_SCRIPT := $(INSTALL_PATH)/run_kselftest.sh
install:
ifdef INSTALL_PATH
@# Ask all targets to install their files
mkdir -p $(INSTALL_PATH)
for TARGET in $(TARGETS); do \
mkdir -p $(INSTALL_PATH)/$$TARGET ; \
make -C $$TARGET INSTALL_PATH=$(INSTALL_PATH)/$$TARGET install; \
done;
@# Ask all targets to emit their test scripts
echo "#!/bin/bash" > $(ALL_SCRIPT)
echo "cd \$$(dirname \$$0)" >> $(ALL_SCRIPT)
echo "ROOT=\$$PWD" >> $(ALL_SCRIPT)
for TARGET in $(TARGETS); do \
echo "echo ; echo Running tests in $$TARGET" >> $(ALL_SCRIPT); \
echo "echo ========================================" >> $(ALL_SCRIPT); \
echo "cd $$TARGET" >> $(ALL_SCRIPT); \
make -s --no-print-directory -C $$TARGET emit_tests >> $(ALL_SCRIPT); \
echo "cd \$$ROOT" >> $(ALL_SCRIPT); \
done;
chmod u+x $(ALL_SCRIPT)
else
$(error Error: set INSTALL_PATH to use install)
endif
clean:
for TARGET in $(TARGETS); do \
make -C $$TARGET clean; \
done;
.PHONY: install

5
tools/testing/selftests/breakpoints/Makefile
View File

@ -16,8 +16,9 @@ else
echo "Not an x86 target, can't build breakpoints selftests"
endif
run_tests:
@./breakpoint_test || echo "breakpoints selftests: [FAIL]"
TEST_PROGS := breakpoint_test
include ../lib.mk
clean:
rm -fr breakpoint_test

7
tools/testing/selftests/cpu-hotplug/Makefile
View File

@ -1,9 +1,10 @@
all:
run_tests:
@/bin/bash ./on-off-test.sh || echo "cpu-hotplug selftests: [FAIL]"
TEST_PROGS := cpu-on-off-test.sh
include ../lib.mk
run_full_test:
@/bin/bash ./on-off-test.sh -a || echo "cpu-hotplug selftests: [FAIL]"
@/bin/bash ./cpu-on-off-test.sh -a || echo "cpu-hotplug selftests: [FAIL]"
clean:

0
tools/testing/selftests/cpu-hotplug/on-off-test.sh → tools/testing/selftests/cpu-hotplug/cpu-on-off-test.sh 100644 → 100755
View File

7
tools/testing/selftests/efivarfs/Makefile
View File

@ -1,12 +1,13 @@
CC = $(CROSS_COMPILE)gcc
CFLAGS = -Wall
test_objs = open-unlink create-read
all: $(test_objs)
run_tests: all
@/bin/bash ./efivarfs.sh || echo "efivarfs selftests: [FAIL]"
TEST_PROGS := efivarfs.sh
TEST_FILES := $(test_objs)
include ../lib.mk
clean:
rm -f $(test_objs)

0
tools/testing/selftests/efivarfs/efivarfs.sh 100644 → 100755
View File

9
tools/testing/selftests/exec/Makefile
View File

@ -1,4 +1,3 @@
CC = $(CROSS_COMPILE)gcc
CFLAGS = -Wall
BINARIES = execveat
DEPS = execveat.symlink execveat.denatured script subdir
@ -18,8 +17,12 @@ execveat.denatured: execveat
%: %.c
$(CC) $(CFLAGS) -o $@ $^
run_tests: all
./execveat
TEST_PROGS := execveat
TEST_FILES := $(DEPS)
include ../lib.mk
override EMIT_TESTS := echo "mkdir -p subdir; (./execveat && echo \"selftests: execveat [PASS]\") || echo \"selftests: execveat [FAIL]\""
clean:
rm -rf $(BINARIES) $(DEPS) subdir.moved execveat.moved xxxxx*

20
tools/testing/selftests/firmware/Makefile
View File

@ -3,25 +3,9 @@
# No binaries, but make sure arg-less "make" doesn't trigger "run_tests"
all:
fw_filesystem:
@if /bin/sh ./fw_filesystem.sh ; then \
echo "fw_filesystem: ok"; \
else \
echo "fw_filesystem: [FAIL]"; \
exit 1; \
fi
TEST_PROGS := fw_filesystem.sh fw_userhelper.sh
fw_userhelper:
@if /bin/sh ./fw_userhelper.sh ; then \
echo "fw_userhelper: ok"; \
else \
echo "fw_userhelper: [FAIL]"; \
exit 1; \
fi
run_tests: all fw_filesystem fw_userhelper
include ../lib.mk
# Nothing to clean up.
clean:
.PHONY: all clean run_tests fw_filesystem fw_userhelper

0
tools/testing/selftests/firmware/fw_filesystem.sh 100644 → 100755
View File

0
tools/testing/selftests/firmware/fw_userhelper.sh 100644 → 100755
View File

5
tools/testing/selftests/ftrace/Makefile
View File

@ -1,7 +1,8 @@
all:
run_tests:
@/bin/sh ./ftracetest || echo "ftrace selftests: [FAIL]"
TEST_PROGS := ftracetest
include ../lib.mk
clean:
rm -rf logs/*

2
tools/testing/selftests/ftrace/test.d/00basic/basic4.tc
View File

@ -2,4 +2,4 @@
# description: Basic event tracing check
test -f available_events -a -f set_event -a -d events
# check scheduler events are available
grep -q sched available_events && exit 0 || exit -1
grep -q sched available_events && exit 0 || exit $FAIL

15
tools/testing/selftests/ftrace/test.d/event/event-enable.tc
View File

@ -9,7 +9,11 @@ do_reset() {
fail() { #msg
do_reset
echo $1
exit -1
exit $FAIL
}
yield() {
ping localhost -c 1 || sleep .001 || usleep 1 || sleep 1
}
if [ ! -f set_event -o ! -d events/sched ]; then
@ -21,7 +25,8 @@ reset_tracer
do_reset
echo 'sched:sched_switch' > set_event
usleep 1
yield
count=`cat trace | grep sched_switch | wc -l`
if [ $count -eq 0 ]; then
@ -31,7 +36,8 @@ fi
do_reset
echo 1 > events/sched/sched_switch/enable
usleep 1
yield
count=`cat trace | grep sched_switch | wc -l`
if [ $count -eq 0 ]; then
@ -41,7 +47,8 @@ fi
do_reset
echo 0 > events/sched/sched_switch/enable
usleep 1
yield
count=`cat trace | grep sched_switch | wc -l`
if [ $count -ne 0 ]; then

15
tools/testing/selftests/ftrace/test.d/event/subsystem-enable.tc
View File

@ -9,7 +9,11 @@ do_reset() {
fail() { #msg
do_reset
echo $1
exit -1
exit $FAIL
}
yield() {
ping localhost -c 1 || sleep .001 || usleep 1 || sleep 1
}
if [ ! -f set_event -o ! -d events/sched ]; then
@ -21,7 +25,8 @@ reset_tracer
do_reset
echo 'sched:*' > set_event
usleep 1
yield
count=`cat trace | grep -v ^# | awk '{ print $5 }' | sort -u | wc -l`
if [ $count -lt 3 ]; then
@ -31,7 +36,8 @@ fi
do_reset
echo 1 > events/sched/enable
usleep 1
yield
count=`cat trace | grep -v ^# | awk '{ print $5 }' | sort -u | wc -l`
if [ $count -lt 3 ]; then
@ -41,7 +47,8 @@ fi
do_reset
echo 0 > events/sched/enable
usleep 1
yield
count=`cat trace | grep -v ^# | awk '{ print $5 }' | sort -u | wc -l`
if [ $count -ne 0 ]; then

15
tools/testing/selftests/ftrace/test.d/event/toplevel-enable.tc
View File

@ -9,7 +9,11 @@ do_reset() {
fail() { #msg
do_reset
echo $1
exit -1
exit $FAIL
}
yield() {
ping localhost -c 1 || sleep .001 || usleep 1 || sleep 1
}
if [ ! -f available_events -o ! -f set_event -o ! -d events ]; then
@ -21,6 +25,9 @@ reset_tracer
do_reset
echo '*:*' > set_event
yield
count=`cat trace | grep -v ^# | wc -l`
if [ $count -eq 0 ]; then
fail "none of events are recorded"
@ -29,6 +36,9 @@ fi
do_reset
echo 1 > events/enable
yield
count=`cat trace | grep -v ^# | wc -l`
if [ $count -eq 0 ]; then
fail "none of events are recorded"
@ -37,6 +47,9 @@ fi
do_reset
echo 0 > events/enable
yield
count=`cat trace | grep -v ^# | wc -l`
if [ $count -ne 0 ]; then
fail "any of events should not be recorded"

6
tools/testing/selftests/ftrace/test.d/ftrace/fgraph-filter-stack.tc
View File

@ -16,7 +16,9 @@ fi
do_reset() {
reset_tracer
echo 0 > /proc/sys/kernel/stack_tracer_enabled
if [ -e /proc/sys/kernel/stack_tracer_enabled ]; then
echo 0 > /proc/sys/kernel/stack_tracer_enabled
fi
enable_tracing
clear_trace
echo > set_ftrace_filter
@ -25,7 +27,7 @@ do_reset() {
fail() { # msg
do_reset
echo $1
exit -1
exit $FAIL
}
disable_tracing

2
tools/testing/selftests/ftrace/test.d/ftrace/fgraph-filter.tc
View File

@ -17,7 +17,7 @@ do_reset() {
fail() { # msg
do_reset
echo $1
exit -1
exit $FAIL
}
disable_tracing

2
tools/testing/selftests/ftrace/test.d/ftrace/func_profiler.tc
View File

@ -31,7 +31,7 @@ fail() { # mesg
reset_tracer
echo > set_ftrace_filter
echo $1
exit -1
exit $FAIL
}
echo "Testing function tracer with profiler:"

55
tools/testing/selftests/gen_kselftest_tar.sh 100755
View File

@ -0,0 +1,55 @@
#!/bin/bash
#
# gen_kselftest_tar
# Generate kselftest tarball
# Author: Shuah Khan <shuahkh@osg.samsung.com>
# Copyright (C) 2015 Samsung Electronics Co., Ltd.
# This software may be freely redistributed under the terms of the GNU
# General Public License (GPLv2).
# main
main()
{
if [ "$#" -eq 0 ]; then
echo "$0: Generating default compression gzip"
copts="cvzf"
ext=".tar.gz"
else
case "$1" in
tar)
copts="cvf"
ext=".tar"
;;
targz)
copts="cvzf"
ext=".tar.gz"
;;
tarbz2)
copts="cvjf"
ext=".tar.bz2"
;;
tarxz)
copts="cvJf"
ext=".tar.xz"
;;
*)
echo "Unknown tarball format $1"
exit 1
;;
esac
fi
install_dir=./kselftest
# Run install using INSTALL_KSFT_PATH override to generate install
# directory
./kselftest_install.sh
tar $copts kselftest${ext} $install_dir
echo "Kselftest archive kselftest${ext} created!"
# clean up install directory
rm -rf kselftest
}
main "$@"

11
tools/testing/selftests/ipc/Makefile
View File

@ -12,14 +12,11 @@ endif
CFLAGS += -I../../../../usr/include/
all:
ifeq ($(ARCH),x86)
gcc $(CFLAGS) msgque.c -o msgque_test
else
echo "Not an x86 target, can't build msgque selftest"
endif
$(CC) $(CFLAGS) msgque.c -o msgque_test
run_tests: all
./msgque_test
TEST_PROGS := msgque_test
include ../lib.mk
clean:
rm -fr ./msgque_test

6
tools/testing/selftests/kcmp/Makefile
View File

@ -1,10 +1,10 @@
CC := $(CROSS_COMPILE)$(CC)
CFLAGS += -I../../../../usr/include/
all: kcmp_test
run_tests: all
@./kcmp_test || echo "kcmp_test: [FAIL]"
TEST_PROGS := kcmp_test
include ../lib.mk
clean:
$(RM) kcmp_test kcmp-test-file

37
tools/testing/selftests/kselftest_install.sh 100755
View File

@ -0,0 +1,37 @@
#!/bin/bash
#
# Kselftest Install
# Install kselftest tests
# Author: Shuah Khan <shuahkh@osg.samsung.com>
# Copyright (C) 2015 Samsung Electronics Co., Ltd.
# This software may be freely redistributed under the terms of the GNU
# General Public License (GPLv2).
install_loc=`pwd`
main()
{
if [ $(basename $install_loc) != "selftests" ]; then
echo "$0: Please run it in selftests directory ..."
exit 1;
fi
if [ "$#" -eq 0 ]; then
echo "$0: Installing in default location - $install_loc ..."
elif [ ! -d "$1" ]; then
echo "$0: $1 doesn't exist!!"
exit 1;
else
install_loc=$1
echo "$0: Installing in specified location - $install_loc ..."
fi
install_dir=$install_loc/kselftest
# Create install directory
mkdir -p $install_dir
# Build tests
INSTALL_PATH=$install_dir make install
}
main "$@"

35
tools/testing/selftests/lib.mk 100644
View File

@ -0,0 +1,35 @@
# This mimics the top-level Makefile. We do it explicitly here so that this
# Makefile can operate with or without the kbuild infrastructure.
CC := $(CROSS_COMPILE)gcc
define RUN_TESTS
@for TEST in $(TEST_PROGS); do \
(./$$TEST && echo "selftests: $$TEST [PASS]") || echo "selftests: $$TEST [FAIL]"; \
done;
endef
run_tests: all
$(RUN_TESTS)
define INSTALL_RULE
mkdir -p $(INSTALL_PATH)
install -t $(INSTALL_PATH) $(TEST_PROGS) $(TEST_PROGS_EXTENDED) $(TEST_FILES)
endef
install: all
ifdef INSTALL_PATH
$(INSTALL_RULE)
else
$(error Error: set INSTALL_PATH to use install)
endif
define EMIT_TESTS
@for TEST in $(TEST_PROGS); do \
echo "(./$$TEST && echo \"selftests: $$TEST [PASS]\") || echo \"selftests: $$TEST [FAIL]\""; \
done;
endef
emit_tests:
$(EMIT_TESTS)
.PHONY: run_tests all clean install emit_tests

14
tools/testing/selftests/memfd/Makefile
View File

@ -1,17 +1,19 @@
CC = $(CROSS_COMPILE)gcc
CFLAGS += -D_FILE_OFFSET_BITS=64
CFLAGS += -I../../../../include/uapi/
CFLAGS += -I../../../../include/
CFLAGS += -I../../../../usr/include/
all:
gcc $(CFLAGS) memfd_test.c -o memfd_test
$(CC) $(CFLAGS) memfd_test.c -o memfd_test
run_tests: all
gcc $(CFLAGS) memfd_test.c -o memfd_test
@./memfd_test || echo "memfd_test: [FAIL]"
TEST_PROGS := memfd_test
include ../lib.mk
build_fuse:
gcc $(CFLAGS) fuse_mnt.c `pkg-config fuse --cflags --libs` -o fuse_mnt
gcc $(CFLAGS) fuse_test.c -o fuse_test
$(CC) $(CFLAGS) fuse_mnt.c `pkg-config fuse --cflags --libs` -o fuse_mnt
$(CC) $(CFLAGS) fuse_test.c -o fuse_test
run_fuse: build_fuse
@./run_fuse_test.sh || echo "fuse_test: [FAIL]"

9
tools/testing/selftests/memory-hotplug/Makefile
View File

@ -1,9 +1,12 @@
all:
run_tests:
@/bin/bash ./on-off-test.sh -r 2 || echo "memory-hotplug selftests: [FAIL]"
include ../lib.mk
TEST_PROGS := mem-on-off-test.sh
override RUN_TESTS := ./mem-on-off-test.sh -r 2 || echo "selftests: memory-hotplug [FAIL]"
override EMIT_TESTS := echo "$(RUN_TESTS)"
run_full_test:
@/bin/bash ./on-off-test.sh || echo "memory-hotplug selftests: [FAIL]"
@/bin/bash ./mem-on-off-test.sh || echo "memory-hotplug selftests: [FAIL]"
clean:

0
tools/testing/selftests/memory-hotplug/on-off-test.sh → tools/testing/selftests/memory-hotplug/mem-on-off-test.sh 100644 → 100755
View File

1
tools/testing/selftests/mount/.gitignore vendored 100644
View File

@ -0,0 +1 @@
unprivileged-remount-test

15
tools/testing/selftests/mount/Makefile
View File

@ -1,17 +1,16 @@
# Makefile for mount selftests.
CFLAGS = -Wall \
-O2
all: unprivileged-remount-test
unprivileged-remount-test: unprivileged-remount-test.c
gcc -Wall -O2 unprivileged-remount-test.c -o unprivileged-remount-test
$(CC) $(CFLAGS) unprivileged-remount-test.c -o unprivileged-remount-test
# Allow specific tests to be selected.
test_unprivileged_remount: unprivileged-remount-test
@if [ -f /proc/self/uid_map ] ; then ./unprivileged-remount-test ; fi
include ../lib.mk
run_tests: all test_unprivileged_remount
TEST_PROGS := unprivileged-remount-test
override RUN_TESTS := if [ -f /proc/self/uid_map ] ; then ./unprivileged-remount-test ; fi
override EMIT_TESTS := echo "$(RUN_TESTS)"
clean:
rm -f unprivileged-remount-test
.PHONY: all test_unprivileged_remount

24
tools/testing/selftests/mqueue/Makefile
View File

@ -1,10 +1,22 @@
all:
gcc -O2 mq_open_tests.c -o mq_open_tests -lrt
gcc -O2 -o mq_perf_tests mq_perf_tests.c -lrt -lpthread -lpopt
CFLAGS = -O2
run_tests:
@./mq_open_tests /test1 || echo "mq_open_tests: [FAIL]"
@./mq_perf_tests || echo "mq_perf_tests: [FAIL]"
all:
$(CC) $(CFLAGS) mq_open_tests.c -o mq_open_tests -lrt
$(CC) $(CFLAGS) -o mq_perf_tests mq_perf_tests.c -lrt -lpthread -lpopt
include ../lib.mk
override define RUN_TESTS
@./mq_open_tests /test1 || echo "selftests: mq_open_tests [FAIL]"
@./mq_perf_tests || echo "selftests: mq_perf_tests [FAIL]"
endef
TEST_PROGS := mq_open_tests mq_perf_tests
override define EMIT_TESTS
echo "./mq_open_tests /test1 || echo \"selftests: mq_open_tests [FAIL]\""
echo "./mq_perf_tests || echo \"selftests: mq_perf_tests [FAIL]\""
endef
clean:
rm -f mq_open_tests mq_perf_tests

10
tools/testing/selftests/net/Makefile
View File

@ -1,6 +1,5 @@
# Makefile for net selftests
CC = $(CROSS_COMPILE)gcc
CFLAGS = -Wall -O2 -g
CFLAGS += -I../../../../usr/include/
@ -11,9 +10,10 @@ all: $(NET_PROGS)
%: %.c
$(CC) $(CFLAGS) -o $@ $^
run_tests: all
@/bin/sh ./run_netsocktests || echo "sockettests: [FAIL]"
@/bin/sh ./run_afpackettests || echo "afpackettests: [FAIL]"
./test_bpf.sh
TEST_PROGS := run_netsocktests run_afpackettests test_bpf.sh
TEST_FILES := $(NET_PROGS)
include ../lib.mk
clean:
$(RM) $(NET_PROGS)

0
tools/testing/selftests/net/run_afpackettests 100644 → 100755
View File

0
tools/testing/selftests/net/run_netsocktests 100644 → 100755
View File

22
tools/testing/selftests/powerpc/Makefile
View File

@ -8,10 +8,9 @@ ifeq ($(ARCH),powerpc)
GIT_VERSION = $(shell git describe --always --long --dirty || echo "unknown")
CC := $(CROSS_COMPILE)$(CC)
CFLAGS := -Wall -O2 -flto -Wall -Werror -DGIT_VERSION='"$(GIT_VERSION)"' -I$(CURDIR) $(CFLAGS)
export CC CFLAGS
export CFLAGS
TARGETS = pmu copyloops mm tm primitives stringloops
@ -22,10 +21,25 @@ all: $(TARGETS)
$(TARGETS):
$(MAKE) -k -C $@ all
run_tests: all
include ../lib.mk
override define RUN_TESTS
@for TARGET in $(TARGETS); do \
$(MAKE) -C $$TARGET run_tests; \
done;
endef
override define INSTALL_RULE
@for TARGET in $(TARGETS); do \
$(MAKE) -C $$TARGET install; \
done;
endef
override define EMIT_TESTS
@for TARGET in $(TARGETS); do \
$(MAKE) -s -C $$TARGET emit_tests; \
done;
endef
clean:
@for TARGET in $(TARGETS); do \
@ -36,4 +50,4 @@ clean:
tags:
find . -name '*.c' -o -name '*.h' | xargs ctags
.PHONY: all run_tests clean tags $(TARGETS)
.PHONY: tags $(TARGETS)

15
tools/testing/selftests/powerpc/copyloops/Makefile
View File

@ -6,24 +6,19 @@ CFLAGS += -D SELFTEST
# Use our CFLAGS for the implicit .S rule
ASFLAGS = $(CFLAGS)
PROGS := copyuser_64 copyuser_power7 memcpy_64 memcpy_power7
TEST_PROGS := copyuser_64 copyuser_power7 memcpy_64 memcpy_power7
EXTRA_SOURCES := validate.c ../harness.c
all: $(PROGS)
all: $(TEST_PROGS)
copyuser_64: CPPFLAGS += -D COPY_LOOP=test___copy_tofrom_user_base
copyuser_power7: CPPFLAGS += -D COPY_LOOP=test___copy_tofrom_user_power7
memcpy_64: CPPFLAGS += -D COPY_LOOP=test_memcpy
memcpy_power7: CPPFLAGS += -D COPY_LOOP=test_memcpy_power7
$(PROGS): $(EXTRA_SOURCES)
$(TEST_PROGS): $(EXTRA_SOURCES)
run_tests: all
@-for PROG in $(PROGS); do \
./$$PROG; \
done;
include ../../lib.mk
clean:
rm -f $(PROGS) *.o
.PHONY: all run_tests clean
rm -f $(TEST_PROGS) *.o

15
tools/testing/selftests/powerpc/mm/Makefile
View File

@ -1,21 +1,16 @@
noarg:
$(MAKE) -C ../
PROGS := hugetlb_vs_thp_test subpage_prot
TEST_PROGS := hugetlb_vs_thp_test subpage_prot
all: $(PROGS) tempfile
all: $(TEST_PROGS) tempfile
$(PROGS): ../harness.c
$(TEST_PROGS): ../harness.c
run_tests: all
@-for PROG in $(PROGS); do \
./$$PROG; \
done;
include ../../lib.mk
tempfile:
dd if=/dev/zero of=tempfile bs=64k count=1
clean:
rm -f $(PROGS) tempfile
.PHONY: all run_tests clean
rm -f $(TEST_PROGS) tempfile

50
tools/testing/selftests/powerpc/pmu/Makefile
View File

@ -1,38 +1,42 @@
noarg:
$(MAKE) -C ../
PROGS := count_instructions l3_bank_test per_event_excludes
TEST_PROGS := count_instructions l3_bank_test per_event_excludes
EXTRA_SOURCES := ../harness.c event.c lib.c
SUB_TARGETS = ebb
all: $(TEST_PROGS) ebb
all: $(PROGS) $(SUB_TARGETS)
$(PROGS): $(EXTRA_SOURCES)
$(TEST_PROGS): $(EXTRA_SOURCES)
# loop.S can only be built 64-bit
count_instructions: loop.S count_instructions.c $(EXTRA_SOURCES)
$(CC) $(CFLAGS) -m64 -o $@ $^
run_tests: all sub_run_tests
@-for PROG in $(PROGS); do \
./$$PROG; \
done;
include ../../lib.mk
clean: sub_clean
rm -f $(PROGS) loop.o
DEFAULT_RUN_TESTS := $(RUN_TESTS)
override define RUN_TESTS
$(DEFAULT_RUN_TESTS)
$(MAKE) -C ebb run_tests
endef
$(SUB_TARGETS):
DEFAULT_EMIT_TESTS := $(EMIT_TESTS)
override define EMIT_TESTS
$(DEFAULT_EMIT_TESTS)
$(MAKE) -s -C ebb emit_tests
endef
DEFAULT_INSTALL := $(INSTALL_RULE)
override define INSTALL_RULE
$(DEFAULT_INSTALL_RULE)
$(MAKE) -C ebb install
endef
clean:
rm -f $(TEST_PROGS) loop.o
$(MAKE) -C ebb clean
ebb:
$(MAKE) -k -C $@ all
sub_run_tests: all
@for TARGET in $(SUB_TARGETS); do \
$(MAKE) -C $$TARGET run_tests; \
done;
sub_clean:
@for TARGET in $(SUB_TARGETS); do \
$(MAKE) -C $$TARGET clean; \
done;
.PHONY: all run_tests clean sub_run_tests sub_clean $(SUB_TARGETS)
.PHONY: all run_tests clean ebb

13
tools/testing/selftests/powerpc/pmu/ebb/Makefile
View File

@ -4,7 +4,7 @@ noarg:
# The EBB handler is 64-bit code and everything links against it
CFLAGS += -m64
PROGS := reg_access_test event_attributes_test cycles_test \
TEST_PROGS := reg_access_test event_attributes_test cycles_test \
cycles_with_freeze_test pmc56_overflow_test \
ebb_vs_cpu_event_test cpu_event_vs_ebb_test \
cpu_event_pinned_vs_ebb_test task_event_vs_ebb_test \
@ -16,18 +16,15 @@ PROGS := reg_access_test event_attributes_test cycles_test \
lost_exception_test no_handler_test \
cycles_with_mmcr2_test
all: $(PROGS)
all: $(TEST_PROGS)
$(PROGS): ../../harness.c ../event.c ../lib.c ebb.c ebb_handler.S trace.c busy_loop.S
$(TEST_PROGS): ../../harness.c ../event.c ../lib.c ebb.c ebb_handler.S trace.c busy_loop.S
instruction_count_test: ../loop.S
lost_exception_test: ../lib.c
run_tests: all
@-for PROG in $(PROGS); do \
./$$PROG; \
done;
include ../../../lib.mk
clean:
rm -f $(PROGS)
rm -f $(TEST_PROGS)

15
tools/testing/selftests/powerpc/primitives/Makefile
View File

@ -1,17 +1,12 @@
CFLAGS += -I$(CURDIR)
PROGS := load_unaligned_zeropad
TEST_PROGS := load_unaligned_zeropad
all: $(PROGS)
all: $(TEST_PROGS)
$(PROGS): ../harness.c
$(TEST_PROGS): ../harness.c
run_tests: all
@-for PROG in $(PROGS); do \
./$$PROG; \
done;
include ../../lib.mk
clean:
rm -f $(PROGS) *.o
.PHONY: all run_tests clean
rm -f $(TEST_PROGS) *.o

15
tools/testing/selftests/powerpc/stringloops/Makefile
View File

@ -2,19 +2,14 @@
CFLAGS += -m64
CFLAGS += -I$(CURDIR)
PROGS := memcmp
TEST_PROGS := memcmp
EXTRA_SOURCES := memcmp_64.S ../harness.c
all: $(PROGS)
all: $(TEST_PROGS)
$(PROGS): $(EXTRA_SOURCES)
$(TEST_PROGS): $(EXTRA_SOURCES)
run_tests: all
@-for PROG in $(PROGS); do \
./$$PROG; \
done;
include ../../lib.mk
clean:
rm -f $(PROGS) *.o
.PHONY: all run_tests clean
rm -f $(TEST_PROGS) *.o

15
tools/testing/selftests/powerpc/tm/Makefile
View File

@ -1,15 +1,10 @@
PROGS := tm-resched-dscr
TEST_PROGS := tm-resched-dscr
all: $(PROGS)
all: $(TEST_PROGS)
$(PROGS): ../harness.c
$(TEST_PROGS): ../harness.c
run_tests: all
@-for PROG in $(PROGS); do \
./$$PROG; \
done;
include ../../lib.mk
clean:
rm -f $(PROGS) *.o
.PHONY: all run_tests clean
rm -f $(TEST_PROGS) *.o

5
tools/testing/selftests/ptrace/Makefile
View File

@ -6,5 +6,6 @@ all: peeksiginfo
clean:
rm -f peeksiginfo
run_tests: all
@./peeksiginfo || echo "peeksiginfo selftests: [FAIL]"
TEST_PROGS := peeksiginfo
include ../lib.mk

7
tools/testing/selftests/size/Makefile
View File

@ -1,12 +1,11 @@
CC = $(CROSS_COMPILE)gcc
all: get_size
get_size: get_size.c
$(CC) -static -ffreestanding -nostartfiles -s $< -o $@
run_tests: all
./get_size
TEST_PROGS := get_size
include ../lib.mk
clean:
$(RM) get_size

12
tools/testing/selftests/sysctl/Makefile
View File

@ -4,16 +4,10 @@
# No binaries, but make sure arg-less "make" doesn't trigger "run_tests".
all:
# Allow specific tests to be selected.
test_num:
@/bin/sh ./run_numerictests
TEST_PROGS := run_numerictests run_stringtests
TEST_FILES := common_tests
test_string:
@/bin/sh ./run_stringtests
run_tests: all test_num test_string
include ../lib.mk
# Nothing to clean up.
clean:
.PHONY: all run_tests clean test_num test_string

0
tools/testing/selftests/sysctl/run_numerictests 100644 → 100755
View File

0
tools/testing/selftests/sysctl/run_stringtests 100644 → 100755
View File

38
tools/testing/selftests/timers/Makefile
View File

@ -1,8 +1,36 @@
all:
gcc posix_timers.c -o posix_timers -lrt
CC = $(CROSS_COMPILE)gcc
BUILD_FLAGS = -DKTEST
CFLAGS += -O3 -Wl,-no-as-needed -Wall $(BUILD_FLAGS)
LDFLAGS += -lrt -lpthread
run_tests: all
./posix_timers
# these are all "safe" tests that don't modify
# system time or require escalated privledges
TEST_PROGS = posix_timers nanosleep nsleep-lat set-timer-lat mqueue-lat \
inconsistency-check raw_skew threadtest rtctest
TEST_PROGS_EXTENDED = alarmtimer-suspend valid-adjtimex change_skew \
skew_consistency clocksource-switch leap-a-day \
leapcrash set-tai set-2038
bins = $(TEST_PROGS) $(TEST_PROGS_EXTENDED)
all: ${bins}
include ../lib.mk
# these tests require escalated privledges
# and may modify the system time or trigger
# other behavior like suspend
run_destructive_tests: run_tests
./alarmtimer-suspend
./valid-adjtimex
./change_skew
./skew_consistency
./clocksource-switch
./leap-a-day -s -i 10
./leapcrash
./set-tai
./set-2038
clean:
rm -f ./posix_timers
rm -f ${bins}

185
tools/testing/selftests/timers/alarmtimer-suspend.c 100644
View File

@ -0,0 +1,185 @@
/* alarmtimer suspend test
* John Stultz (john.stultz@linaro.org)
* (C) Copyright Linaro 2013
* Licensed under the GPLv2
*
* This test makes sure the alarmtimer & RTC wakeup code is
* functioning.
*
* To build:
* $ gcc alarmtimer-suspend.c -o alarmtimer-suspend -lrt
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <stdio.h>
#include <unistd.h>
#include <time.h>
#include <string.h>
#include <signal.h>
#include <stdlib.h>
#include <pthread.h>
#ifdef KTEST
#include "../kselftest.h"
#else
static inline int ksft_exit_pass(void)
{
exit(0);
}
static inline int ksft_exit_fail(void)
{
exit(1);
}
#endif
#define CLOCK_REALTIME 0
#define CLOCK_MONOTONIC 1
#define CLOCK_PROCESS_CPUTIME_ID 2
#define CLOCK_THREAD_CPUTIME_ID 3
#define CLOCK_MONOTONIC_RAW 4
#define CLOCK_REALTIME_COARSE 5
#define CLOCK_MONOTONIC_COARSE 6
#define CLOCK_BOOTTIME 7
#define CLOCK_REALTIME_ALARM 8
#define CLOCK_BOOTTIME_ALARM 9
#define CLOCK_HWSPECIFIC 10
#define CLOCK_TAI 11
#define NR_CLOCKIDS 12
#define NSEC_PER_SEC 1000000000ULL
#define UNREASONABLE_LAT (NSEC_PER_SEC * 4) /* hopefully we resume in 4secs */
#define SUSPEND_SECS 15
int alarmcount;
int alarm_clock_id;
struct timespec start_time;
char *clockstring(int clockid)
{
switch (clockid) {
case CLOCK_REALTIME:
return "CLOCK_REALTIME";
case CLOCK_MONOTONIC:
return "CLOCK_MONOTONIC";
case CLOCK_PROCESS_CPUTIME_ID:
return "CLOCK_PROCESS_CPUTIME_ID";
case CLOCK_THREAD_CPUTIME_ID:
return "CLOCK_THREAD_CPUTIME_ID";
case CLOCK_MONOTONIC_RAW:
return "CLOCK_MONOTONIC_RAW";
case CLOCK_REALTIME_COARSE:
return "CLOCK_REALTIME_COARSE";
case CLOCK_MONOTONIC_COARSE:
return "CLOCK_MONOTONIC_COARSE";
case CLOCK_BOOTTIME:
return "CLOCK_BOOTTIME";
case CLOCK_REALTIME_ALARM:
return "CLOCK_REALTIME_ALARM";
case CLOCK_BOOTTIME_ALARM:
return "CLOCK_BOOTTIME_ALARM";
case CLOCK_TAI:
return "CLOCK_TAI";
};
return "UNKNOWN_CLOCKID";
}
long long timespec_sub(struct timespec a, struct timespec b)
{
long long ret = NSEC_PER_SEC * b.tv_sec + b.tv_nsec;
ret -= NSEC_PER_SEC * a.tv_sec + a.tv_nsec;
return ret;
}
int final_ret = 0;
void sigalarm(int signo)
{
long long delta_ns;
struct timespec ts;
clock_gettime(alarm_clock_id, &ts);
alarmcount++;
delta_ns = timespec_sub(start_time, ts);
delta_ns -= NSEC_PER_SEC * SUSPEND_SECS * alarmcount;
printf("ALARM(%i): %ld:%ld latency: %lld ns ", alarmcount, ts.tv_sec,
ts.tv_nsec, delta_ns);
if (delta_ns > UNREASONABLE_LAT) {
printf("[FAIL]\n");
final_ret = -1;
} else
printf("[OK]\n");
}
int main(void)
{
timer_t tm1;
struct itimerspec its1, its2;
struct sigevent se;
struct sigaction act;
int signum = SIGRTMAX;
/* Set up signal handler: */
sigfillset(&act.sa_mask);
act.sa_flags = 0;
act.sa_handler = sigalarm;
sigaction(signum, &act, NULL);
/* Set up timer: */
memset(&se, 0, sizeof(se));
se.sigev_notify = SIGEV_SIGNAL;
se.sigev_signo = signum;
se.sigev_value.sival_int = 0;
for (alarm_clock_id = CLOCK_REALTIME_ALARM;
alarm_clock_id <= CLOCK_BOOTTIME_ALARM;
alarm_clock_id++) {
alarmcount = 0;
timer_create(alarm_clock_id, &se, &tm1);
clock_gettime(alarm_clock_id, &start_time);
printf("Start time (%s): %ld:%ld\n", clockstring(alarm_clock_id),
start_time.tv_sec, start_time.tv_nsec);
printf("Setting alarm for every %i seconds\n", SUSPEND_SECS);
its1.it_value = start_time;
its1.it_value.tv_sec += SUSPEND_SECS;
its1.it_interval.tv_sec = SUSPEND_SECS;
its1.it_interval.tv_nsec = 0;
timer_settime(tm1, TIMER_ABSTIME, &its1, &its2);
while (alarmcount < 5)
sleep(1); /* First 5 alarms, do nothing */
printf("Starting suspend loops\n");
while (alarmcount < 10) {
int ret;
sleep(1);
ret = system("echo mem > /sys/power/state");
if (ret)
break;
}
timer_delete(tm1);
}
if (final_ret)
return ksft_exit_fail();
return ksft_exit_pass();
}

107
tools/testing/selftests/timers/change_skew.c 100644
View File

@ -0,0 +1,107 @@
/* ADJ_FREQ Skew change test
* by: john stultz (johnstul@us.ibm.com)
* (C) Copyright IBM 2012
* Licensed under the GPLv2
*
* NOTE: This is a meta-test which cranks the ADJ_FREQ knob and
* then uses other tests to detect problems. Thus this test requires
* that the raw_skew, inconsistency-check and nanosleep tests be
* present in the same directory it is run from.
*
* To build:
* $ gcc change_skew.c -o change_skew -lrt
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <sys/timex.h>
#include <time.h>
#ifdef KTEST
#include "../kselftest.h"
#else
static inline int ksft_exit_pass(void)
{
exit(0);
}
static inline int ksft_exit_fail(void)
{
exit(1);
}
#endif
#define NSEC_PER_SEC 1000000000LL
int change_skew_test(int ppm)
{
struct timex tx;
int ret;
tx.modes = ADJ_FREQUENCY;
tx.freq = ppm << 16;
ret = adjtimex(&tx);
if (ret < 0) {
printf("Error adjusting freq\n");
return ret;
}
ret = system("./raw_skew");
ret |= system("./inconsistency-check");
ret |= system("./nanosleep");
return ret;
}
int main(int argv, char **argc)
{
struct timex tx;
int i, ret;
int ppm[5] = {0, 250, 500, -250, -500};
/* Kill ntpd */
ret = system("killall -9 ntpd");
/* Make sure there's no offset adjustment going on */
tx.modes = ADJ_OFFSET;
tx.offset = 0;
ret = adjtimex(&tx);
if (ret < 0) {
printf("Maybe you're not running as root?\n");
return -1;
}
for (i = 0; i < 5; i++) {
printf("Using %i ppm adjustment\n", ppm[i]);
ret = change_skew_test(ppm[i]);
if (ret)
break;
}
/* Set things back */
tx.modes = ADJ_FREQUENCY;
tx.offset = 0;
adjtimex(&tx);
if (ret) {
printf("[FAIL]");
return ksft_exit_fail();
}
printf("[OK]");
return ksft_exit_pass();
}

179
tools/testing/selftests/timers/clocksource-switch.c 100644
View File

@ -0,0 +1,179 @@
/* Clocksource change test
* by: john stultz (johnstul@us.ibm.com)
* (C) Copyright IBM 2012
* Licensed under the GPLv2
*
* NOTE: This is a meta-test which quickly changes the clocksourc and
* then uses other tests to detect problems. Thus this test requires
* that the inconsistency-check and nanosleep tests be present in the
* same directory it is run from.
*
* To build:
* $ gcc clocksource-switch.c -o clocksource-switch -lrt
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/time.h>
#include <sys/timex.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <sys/wait.h>
#ifdef KTEST
#include "../kselftest.h"
#else
static inline int ksft_exit_pass(void)
{
exit(0);
}
static inline int ksft_exit_fail(void)
{
exit(1);
}
#endif
int get_clocksources(char list[][30])
{
int fd, i;
size_t size;
char buf[512];
char *head, *tmp;
fd = open("/sys/devices/system/clocksource/clocksource0/available_clocksource", O_RDONLY);
size = read(fd, buf, 512);
close(fd);
for (i = 0; i < 30; i++)
list[i][0] = '\0';
head = buf;
i = 0;
while (head - buf < size) {
/* Find the next space */
for (tmp = head; *tmp != ' '; tmp++) {
if (*tmp == '\n')
break;
if (*tmp == '\0')
break;
}
*tmp = '\0';
strcpy(list[i], head);
head = tmp + 1;
i++;
}
return i-1;
}
int get_cur_clocksource(char *buf, size_t size)
{
int fd;
fd = open("/sys/devices/system/clocksource/clocksource0/current_clocksource", O_RDONLY);
size = read(fd, buf, size);
return 0;
}
int change_clocksource(char *clocksource)
{
int fd;
size_t size;
fd = open("/sys/devices/system/clocksource/clocksource0/current_clocksource", O_WRONLY);
if (fd < 0)
return -1;
size = write(fd, clocksource, strlen(clocksource));
if (size < 0)
return -1;
close(fd);
return 0;
}
int run_tests(int secs)
{
int ret;
char buf[255];
sprintf(buf, "./inconsistency-check -t %i", secs);
ret = system(buf);
if (ret)
return ret;
ret = system("./nanosleep");
return ret;
}
char clocksource_list[10][30];
int main(int argv, char **argc)
{
char orig_clk[512];
int count, i, status;
pid_t pid;
get_cur_clocksource(orig_clk, 512);
count = get_clocksources(clocksource_list);
if (change_clocksource(clocksource_list[0])) {
printf("Error: You probably need to run this as root\n");
return -1;
}
/* Check everything is sane before we start switching asyncrhonously */
for (i = 0; i < count; i++) {
printf("Validating clocksource %s\n", clocksource_list[i]);
if (change_clocksource(clocksource_list[i])) {
status = -1;
goto out;
}
if (run_tests(5)) {
status = -1;
goto out;
}
}
printf("Running Asyncrhonous Switching Tests...\n");
pid = fork();
if (!pid)
return run_tests(60);
while (pid != waitpid(pid, &status, WNOHANG))
for (i = 0; i < count; i++)
if (change_clocksource(clocksource_list[i])) {
status = -1;
goto out;
}
out:
change_clocksource(orig_clk);
if (status)
return ksft_exit_fail();
return ksft_exit_pass();
}

204
tools/testing/selftests/timers/inconsistency-check.c 100644
View File

@ -0,0 +1,204 @@
/* Time inconsistency check test
* by: john stultz (johnstul@us.ibm.com)
* (C) Copyright IBM 2003, 2004, 2005, 2012
* (C) Copyright Linaro Limited 2015
* Licensed under the GPLv2
*
* To build:
* $ gcc inconsistency-check.c -o inconsistency-check -lrt
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>
#include <sys/timex.h>
#include <string.h>
#include <signal.h>
#ifdef KTEST
#include "../kselftest.h"
#else
static inline int ksft_exit_pass(void)
{
exit(0);
}
static inline int ksft_exit_fail(void)
{
exit(1);
}
#endif
#define CALLS_PER_LOOP 64
#define NSEC_PER_SEC 1000000000ULL
#define CLOCK_REALTIME 0
#define CLOCK_MONOTONIC 1
#define CLOCK_PROCESS_CPUTIME_ID 2
#define CLOCK_THREAD_CPUTIME_ID 3
#define CLOCK_MONOTONIC_RAW 4
#define CLOCK_REALTIME_COARSE 5
#define CLOCK_MONOTONIC_COARSE 6
#define CLOCK_BOOTTIME 7
#define CLOCK_REALTIME_ALARM 8
#define CLOCK_BOOTTIME_ALARM 9
#define CLOCK_HWSPECIFIC 10
#define CLOCK_TAI 11
#define NR_CLOCKIDS 12
char *clockstring(int clockid)
{
switch (clockid) {
case CLOCK_REALTIME:
return "CLOCK_REALTIME";
case CLOCK_MONOTONIC:
return "CLOCK_MONOTONIC";
case CLOCK_PROCESS_CPUTIME_ID:
return "CLOCK_PROCESS_CPUTIME_ID";
case CLOCK_THREAD_CPUTIME_ID:
return "CLOCK_THREAD_CPUTIME_ID";
case CLOCK_MONOTONIC_RAW:
return "CLOCK_MONOTONIC_RAW";
case CLOCK_REALTIME_COARSE:
return "CLOCK_REALTIME_COARSE";
case CLOCK_MONOTONIC_COARSE:
return "CLOCK_MONOTONIC_COARSE";
case CLOCK_BOOTTIME:
return "CLOCK_BOOTTIME";
case CLOCK_REALTIME_ALARM:
return "CLOCK_REALTIME_ALARM";
case CLOCK_BOOTTIME_ALARM:
return "CLOCK_BOOTTIME_ALARM";
case CLOCK_TAI:
return "CLOCK_TAI";
};
return "UNKNOWN_CLOCKID";
}
/* returns 1 if a <= b, 0 otherwise */
static inline int in_order(struct timespec a, struct timespec b)
{
/* use unsigned to avoid false positives on 2038 rollover */
if ((unsigned long)a.tv_sec < (unsigned long)b.tv_sec)
return 1;
if ((unsigned long)a.tv_sec > (unsigned long)b.tv_sec)
return 0;
if (a.tv_nsec > b.tv_nsec)
return 0;
return 1;
}
int consistency_test(int clock_type, unsigned long seconds)
{
struct timespec list[CALLS_PER_LOOP];
int i, inconsistent;
long now, then;
time_t t;
char *start_str;
clock_gettime(clock_type, &list[0]);
now = then = list[0].tv_sec;
/* timestamp start of test */
t = time(0);
start_str = ctime(&t);
while (seconds == -1 || now - then < seconds) {
inconsistent = 0;
/* Fill list */
for (i = 0; i < CALLS_PER_LOOP; i++)
clock_gettime(clock_type, &list[i]);
/* Check for inconsistencies */
for (i = 0; i < CALLS_PER_LOOP - 1; i++)
if (!in_order(list[i], list[i+1]))
inconsistent = i;
/* display inconsistency */
if (inconsistent) {
unsigned long long delta;
printf("\%s\n", start_str);
for (i = 0; i < CALLS_PER_LOOP; i++) {
if (i == inconsistent)
printf("--------------------\n");
printf("%lu:%lu\n", list[i].tv_sec,
list[i].tv_nsec);
if (i == inconsistent + 1)
printf("--------------------\n");
}
delta = list[inconsistent].tv_sec * NSEC_PER_SEC;
delta += list[inconsistent].tv_nsec;
delta -= list[inconsistent+1].tv_sec * NSEC_PER_SEC;
delta -= list[inconsistent+1].tv_nsec;
printf("Delta: %llu ns\n", delta);
fflush(0);
/* timestamp inconsistency*/
t = time(0);
printf("%s\n", ctime(&t));
printf("[FAILED]\n");
return -1;
}
now = list[0].tv_sec;
}
printf("[OK]\n");
return 0;
}
int main(int argc, char *argv[])
{
int clockid, opt;
int userclock = CLOCK_REALTIME;
int maxclocks = NR_CLOCKIDS;
int runtime = 10;
struct timespec ts;
/* Process arguments */
while ((opt = getopt(argc, argv, "t:c:")) != -1) {
switch (opt) {
case 't':
runtime = atoi(optarg);
break;
case 'c':
userclock = atoi(optarg);
maxclocks = userclock + 1;
break;
default:
printf("Usage: %s [-t <secs>] [-c <clockid>]\n", argv[0]);
printf(" -t: Number of seconds to run\n");
printf(" -c: clockid to use (default, all clockids)\n");
exit(-1);
}
}
setbuf(stdout, NULL);
for (clockid = userclock; clockid < maxclocks; clockid++) {
if (clockid == CLOCK_HWSPECIFIC)
continue;
if (!clock_gettime(clockid, &ts)) {
printf("Consistent %-30s ", clockstring(clockid));
if (consistency_test(clockid, runtime))
return ksft_exit_fail();
}
}
return ksft_exit_pass();
}

319
tools/testing/selftests/timers/leap-a-day.c 100644
View File

@ -0,0 +1,319 @@
/* Leap second stress test
* by: John Stultz (john.stultz@linaro.org)
* (C) Copyright IBM 2012
* (C) Copyright 2013, 2015 Linaro Limited
* Licensed under the GPLv2
*
* This test signals the kernel to insert a leap second
* every day at midnight GMT. This allows for stessing the
* kernel's leap-second behavior, as well as how well applications
* handle the leap-second discontinuity.
*
* Usage: leap-a-day [-s] [-i <num>]
*
* Options:
* -s: Each iteration, set the date to 10 seconds before midnight GMT.
* This speeds up the number of leapsecond transitions tested,
* but because it calls settimeofday frequently, advancing the
* time by 24 hours every ~16 seconds, it may cause application
* disruption.
*
* -i: Number of iterations to run (default: infinite)
*
* Other notes: Disabling NTP prior to running this is advised, as the two
* may conflict in their commands to the kernel.
*
* To build:
* $ gcc leap-a-day.c -o leap-a-day -lrt
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>
#include <sys/timex.h>
#include <string.h>
#include <signal.h>
#include <unistd.h>
#ifdef KTEST
#include "../kselftest.h"
#else
static inline int ksft_exit_pass(void)
{
exit(0);
}
static inline int ksft_exit_fail(void)
{
exit(1);
}
#endif
#define NSEC_PER_SEC 1000000000ULL
#define CLOCK_TAI 11
/* returns 1 if a <= b, 0 otherwise */
static inline int in_order(struct timespec a, struct timespec b)
{
if (a.tv_sec < b.tv_sec)
return 1;
if (a.tv_sec > b.tv_sec)
return 0;
if (a.tv_nsec > b.tv_nsec)
return 0;
return 1;
}
struct timespec timespec_add(struct timespec ts, unsigned long long ns)
{
ts.tv_nsec += ns;
while (ts.tv_nsec >= NSEC_PER_SEC) {
ts.tv_nsec -= NSEC_PER_SEC;
ts.tv_sec++;
}
return ts;
}
char *time_state_str(int state)
{
switch (state) {
case TIME_OK: return "TIME_OK";
case TIME_INS: return "TIME_INS";
case TIME_DEL: return "TIME_DEL";
case TIME_OOP: return "TIME_OOP";
case TIME_WAIT: return "TIME_WAIT";
case TIME_BAD: return "TIME_BAD";
}
return "ERROR";
}
/* clear NTP time_status & time_state */
int clear_time_state(void)
{
struct timex tx;
int ret;
/*
* We have to call adjtime twice here, as kernels
* prior to 6b1859dba01c7 (included in 3.5 and
* -stable), had an issue with the state machine
* and wouldn't clear the STA_INS/DEL flag directly.
*/
tx.modes = ADJ_STATUS;
tx.status = STA_PLL;
ret = adjtimex(&tx);
/* Clear maxerror, as it can cause UNSYNC to be set */
tx.modes = ADJ_MAXERROR;
tx.maxerror = 0;
ret = adjtimex(&tx);
/* Clear the status */
tx.modes = ADJ_STATUS;
tx.status = 0;
ret = adjtimex(&tx);
return ret;
}
/* Make sure we cleanup on ctrl-c */
void handler(int unused)
{
clear_time_state();
exit(0);
}
/* Test for known hrtimer failure */
void test_hrtimer_failure(void)
{
struct timespec now, target;
clock_gettime(CLOCK_REALTIME, &now);
target = timespec_add(now, NSEC_PER_SEC/2);
clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &target, NULL);
clock_gettime(CLOCK_REALTIME, &now);
if (!in_order(target, now))
printf("ERROR: hrtimer early expiration failure observed.\n");
}
int main(int argc, char **argv)
{
int settime = 0;
int tai_time = 0;
int insert = 1;
int iterations = -1;
int opt;
/* Process arguments */
while ((opt = getopt(argc, argv, "sti:")) != -1) {
switch (opt) {
case 's':
printf("Setting time to speed up testing\n");
settime = 1;
break;
case 'i':
iterations = atoi(optarg);
break;
case 't':
tai_time = 1;
break;
default:
printf("Usage: %s [-s] [-i <iterations>]\n", argv[0]);
printf(" -s: Set time to right before leap second each iteration\n");
printf(" -i: Number of iterations\n");
printf(" -t: Print TAI time\n");
exit(-1);
}
}
/* Make sure TAI support is present if -t was used */
if (tai_time) {
struct timespec ts;
if (clock_gettime(CLOCK_TAI, &ts)) {
printf("System doesn't support CLOCK_TAI\n");
ksft_exit_fail();
}
}
signal(SIGINT, handler);
signal(SIGKILL, handler);
if (iterations < 0)
printf("This runs continuously. Press ctrl-c to stop\n");
else
printf("Running for %i iterations. Press ctrl-c to stop\n", iterations);
printf("\n");
while (1) {
int ret;
struct timespec ts;
struct timex tx;
time_t now, next_leap;
/* Get the current time */
clock_gettime(CLOCK_REALTIME, &ts);
/* Calculate the next possible leap second 23:59:60 GMT */
next_leap = ts.tv_sec;
next_leap += 86400 - (next_leap % 86400);
if (settime) {
struct timeval tv;
tv.tv_sec = next_leap - 10;
tv.tv_usec = 0;
settimeofday(&tv, NULL);
printf("Setting time to %s", ctime(&tv.tv_sec));
}
/* Reset NTP time state */
clear_time_state();
/* Set the leap second insert flag */
tx.modes = ADJ_STATUS;
if (insert)
tx.status = STA_INS;
else
tx.status = STA_DEL;
ret = adjtimex(&tx);
if (ret < 0) {
printf("Error: Problem setting STA_INS/STA_DEL!: %s\n",
time_state_str(ret));
return ksft_exit_fail();
}
/* Validate STA_INS was set */
tx.modes = 0;
ret = adjtimex(&tx);
if (tx.status != STA_INS && tx.status != STA_DEL) {
printf("Error: STA_INS/STA_DEL not set!: %s\n",
time_state_str(ret));
return ksft_exit_fail();
}
if (tai_time) {
printf("Using TAI time,"
" no inconsistencies should be seen!\n");
}
printf("Scheduling leap second for %s", ctime(&next_leap));
/* Wake up 3 seconds before leap */
ts.tv_sec = next_leap - 3;
ts.tv_nsec = 0;
while (clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &ts, NULL))
printf("Something woke us up, returning to sleep\n");
/* Validate STA_INS is still set */
tx.modes = 0;
ret = adjtimex(&tx);
if (tx.status != STA_INS && tx.status != STA_DEL) {
printf("Something cleared STA_INS/STA_DEL, setting it again.\n");
tx.modes = ADJ_STATUS;
if (insert)
tx.status = STA_INS;
else
tx.status = STA_DEL;
ret = adjtimex(&tx);
}
/* Check adjtimex output every half second */
now = tx.time.tv_sec;
while (now < next_leap + 2) {
char buf[26];
struct timespec tai;
tx.modes = 0;
ret = adjtimex(&tx);
if (tai_time) {
clock_gettime(CLOCK_TAI, &tai);
printf("%ld sec, %9ld ns\t%s\n",
tai.tv_sec,
tai.tv_nsec,
time_state_str(ret));
} else {
ctime_r(&tx.time.tv_sec, buf);
buf[strlen(buf)-1] = 0; /*remove trailing\n */
printf("%s + %6ld us (%i)\t%s\n",
buf,
tx.time.tv_usec,
tx.tai,
time_state_str(ret));
}
now = tx.time.tv_sec;
/* Sleep for another half second */
ts.tv_sec = 0;
ts.tv_nsec = NSEC_PER_SEC / 2;
clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, NULL);
}
/* Switch to using other mode */
insert = !insert;
/* Note if kernel has known hrtimer failure */
test_hrtimer_failure();
printf("Leap complete\n\n");
if ((iterations != -1) && !(--iterations))
break;
}
clear_time_state();
return ksft_exit_pass();
}

120
tools/testing/selftests/timers/leapcrash.c 100644
View File

@ -0,0 +1,120 @@
/* Demo leapsecond deadlock
* by: John Stultz (john.stultz@linaro.org)
* (C) Copyright IBM 2012
* (C) Copyright 2013, 2015 Linaro Limited
* Licensed under the GPL
*
* This test demonstrates leapsecond deadlock that is possibe
* on kernels from 2.6.26 to 3.3.
*
* WARNING: THIS WILL LIKELY HARDHANG SYSTEMS AND MAY LOSE DATA
* RUN AT YOUR OWN RISK!
* To build:
* $ gcc leapcrash.c -o leapcrash -lrt
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>
#include <sys/timex.h>
#include <string.h>
#include <signal.h>
#ifdef KTEST
#include "../kselftest.h"
#else
static inline int ksft_exit_pass(void)
{
exit(0);
}
static inline int ksft_exit_fail(void)
{
exit(1);
}
#endif
/* clear NTP time_status & time_state */
int clear_time_state(void)
{
struct timex tx;
int ret;
/*
* We have to call adjtime twice here, as kernels
* prior to 6b1859dba01c7 (included in 3.5 and
* -stable), had an issue with the state machine
* and wouldn't clear the STA_INS/DEL flag directly.
*/
tx.modes = ADJ_STATUS;
tx.status = STA_PLL;
ret = adjtimex(&tx);
tx.modes = ADJ_STATUS;
tx.status = 0;
ret = adjtimex(&tx);
return ret;
}
/* Make sure we cleanup on ctrl-c */
void handler(int unused)
{
clear_time_state();
exit(0);
}
int main(void)
{
struct timex tx;
struct timespec ts;
time_t next_leap;
int count = 0;
setbuf(stdout, NULL);
signal(SIGINT, handler);
signal(SIGKILL, handler);
printf("This runs for a few minutes. Press ctrl-c to stop\n");
clear_time_state();
/* Get the current time */
clock_gettime(CLOCK_REALTIME, &ts);
/* Calculate the next possible leap second 23:59:60 GMT */
next_leap = ts.tv_sec;
next_leap += 86400 - (next_leap % 86400);
for (count = 0; count < 20; count++) {
struct timeval tv;
/* set the time to 2 seconds before the leap */
tv.tv_sec = next_leap - 2;
tv.tv_usec = 0;
if (settimeofday(&tv, NULL)) {
printf("Error: You're likely not running with proper (ie: root) permissions\n");
return ksft_exit_fail();
}
tx.modes = 0;
adjtimex(&tx);
/* hammer on adjtime w/ STA_INS */
while (tx.time.tv_sec < next_leap + 1) {
/* Set the leap second insert flag */
tx.modes = ADJ_STATUS;
tx.status = STA_INS;
adjtimex(&tx);
}
clear_time_state();
printf(".");
}
printf("[OK]\n");
return ksft_exit_pass();
}

124
tools/testing/selftests/timers/mqueue-lat.c 100644
View File

@ -0,0 +1,124 @@
/* Measure mqueue timeout latency
* by: john stultz (john.stultz@linaro.org)
* (C) Copyright Linaro 2013
*
* Inspired with permission from example test by:
* Romain Francoise <romain@orebokech.com>
* Licensed under the GPLv2
*
* To build:
* $ gcc mqueue-lat.c -o mqueue-lat -lrt
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>
#include <sys/timex.h>
#include <string.h>
#include <signal.h>
#include <errno.h>
#include <mqueue.h>
#ifdef KTEST
#include "../kselftest.h"
#else
static inline int ksft_exit_pass(void)
{
exit(0);
}
static inline int ksft_exit_fail(void)
{
exit(1);
}
#endif
#define NSEC_PER_SEC 1000000000ULL
#define TARGET_TIMEOUT 100000000 /* 100ms in nanoseconds */
#define UNRESONABLE_LATENCY 40000000 /* 40ms in nanosecs */
long long timespec_sub(struct timespec a, struct timespec b)
{
long long ret = NSEC_PER_SEC * b.tv_sec + b.tv_nsec;
ret -= NSEC_PER_SEC * a.tv_sec + a.tv_nsec;
return ret;
}
struct timespec timespec_add(struct timespec ts, unsigned long long ns)
{
ts.tv_nsec += ns;
while (ts.tv_nsec >= NSEC_PER_SEC) {
ts.tv_nsec -= NSEC_PER_SEC;
ts.tv_sec++;
}
return ts;
}
int mqueue_lat_test(void)
{
mqd_t q;
struct mq_attr attr;
struct timespec start, end, now, target;
int i, count, ret;
q = mq_open("/foo", O_CREAT | O_RDONLY, 0666, NULL);
if (q < 0) {
perror("mq_open");
return -1;
}
mq_getattr(q, &attr);
count = 100;
clock_gettime(CLOCK_MONOTONIC, &start);
for (i = 0; i < count; i++) {
char buf[attr.mq_msgsize];
clock_gettime(CLOCK_REALTIME, &now);
target = now;
target = timespec_add(now, TARGET_TIMEOUT); /* 100ms */
ret = mq_timedreceive(q, buf, sizeof(buf), NULL, &target);
if (ret < 0 && errno != ETIMEDOUT) {
perror("mq_timedreceive");
return -1;
}
}
clock_gettime(CLOCK_MONOTONIC, &end);
mq_close(q);
if ((timespec_sub(start, end)/count) > TARGET_TIMEOUT + UNRESONABLE_LATENCY)
return -1;
return 0;
}
int main(int argc, char **argv)
{
int ret;
printf("Mqueue latency : ");
ret = mqueue_lat_test();
if (ret < 0) {
printf("[FAILED]\n");
return ksft_exit_fail();
}
printf("[OK]\n");
return ksft_exit_pass();
}

174
tools/testing/selftests/timers/nanosleep.c 100644
View File

@ -0,0 +1,174 @@
/* Make sure timers don't return early
* by: john stultz (johnstul@us.ibm.com)
* John Stultz (john.stultz@linaro.org)
* (C) Copyright IBM 2012
* (C) Copyright Linaro 2013 2015
* Licensed under the GPLv2
*
* To build:
* $ gcc nanosleep.c -o nanosleep -lrt
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>
#include <sys/timex.h>
#include <string.h>
#include <signal.h>
#ifdef KTEST
#include "../kselftest.h"
#else
static inline int ksft_exit_pass(void)
{
exit(0);
}
static inline int ksft_exit_fail(void)
{
exit(1);
}
#endif
#define NSEC_PER_SEC 1000000000ULL
#define CLOCK_REALTIME 0
#define CLOCK_MONOTONIC 1
#define CLOCK_PROCESS_CPUTIME_ID 2
#define CLOCK_THREAD_CPUTIME_ID 3
#define CLOCK_MONOTONIC_RAW 4
#define CLOCK_REALTIME_COARSE 5
#define CLOCK_MONOTONIC_COARSE 6
#define CLOCK_BOOTTIME 7
#define CLOCK_REALTIME_ALARM 8
#define CLOCK_BOOTTIME_ALARM 9
#define CLOCK_HWSPECIFIC 10
#define CLOCK_TAI 11
#define NR_CLOCKIDS 12
#define UNSUPPORTED 0xf00f
char *clockstring(int clockid)
{
switch (clockid) {
case CLOCK_REALTIME:
return "CLOCK_REALTIME";
case CLOCK_MONOTONIC:
return "CLOCK_MONOTONIC";
case CLOCK_PROCESS_CPUTIME_ID:
return "CLOCK_PROCESS_CPUTIME_ID";
case CLOCK_THREAD_CPUTIME_ID:
return "CLOCK_THREAD_CPUTIME_ID";
case CLOCK_MONOTONIC_RAW:
return "CLOCK_MONOTONIC_RAW";
case CLOCK_REALTIME_COARSE:
return "CLOCK_REALTIME_COARSE";
case CLOCK_MONOTONIC_COARSE:
return "CLOCK_MONOTONIC_COARSE";
case CLOCK_BOOTTIME:
return "CLOCK_BOOTTIME";
case CLOCK_REALTIME_ALARM:
return "CLOCK_REALTIME_ALARM";
case CLOCK_BOOTTIME_ALARM:
return "CLOCK_BOOTTIME_ALARM";
case CLOCK_TAI:
return "CLOCK_TAI";
};
return "UNKNOWN_CLOCKID";
}
/* returns 1 if a <= b, 0 otherwise */
static inline int in_order(struct timespec a, struct timespec b)
{
if (a.tv_sec < b.tv_sec)
return 1;
if (a.tv_sec > b.tv_sec)
return 0;
if (a.tv_nsec > b.tv_nsec)
return 0;
return 1;
}
struct timespec timespec_add(struct timespec ts, unsigned long long ns)
{
ts.tv_nsec += ns;
while (ts.tv_nsec >= NSEC_PER_SEC) {
ts.tv_nsec -= NSEC_PER_SEC;
ts.tv_sec++;
}
return ts;
}
int nanosleep_test(int clockid, long long ns)
{
struct timespec now, target, rel;
/* First check abs time */
if (clock_gettime(clockid, &now))
return UNSUPPORTED;
target = timespec_add(now, ns);
if (clock_nanosleep(clockid, TIMER_ABSTIME, &target, NULL))
return UNSUPPORTED;
clock_gettime(clockid, &now);
if (!in_order(target, now))
return -1;
/* Second check reltime */
clock_gettime(clockid, &now);
rel.tv_sec = 0;
rel.tv_nsec = 0;
rel = timespec_add(rel, ns);
target = timespec_add(now, ns);
clock_nanosleep(clockid, 0, &rel, NULL);
clock_gettime(clockid, &now);
if (!in_order(target, now))
return -1;
return 0;
}
int main(int argc, char **argv)
{
long long length;
int clockid, ret;
for (clockid = CLOCK_REALTIME; clockid < NR_CLOCKIDS; clockid++) {
/* Skip cputime clockids since nanosleep won't increment cputime */
if (clockid == CLOCK_PROCESS_CPUTIME_ID ||
clockid == CLOCK_THREAD_CPUTIME_ID ||
clockid == CLOCK_HWSPECIFIC)
continue;
printf("Nanosleep %-31s ", clockstring(clockid));
length = 10;
while (length <= (NSEC_PER_SEC * 10)) {
ret = nanosleep_test(clockid, length);
if (ret == UNSUPPORTED) {
printf("[UNSUPPORTED]\n");
goto next;
}
if (ret < 0) {
printf("[FAILED]\n");
return ksft_exit_fail();
}
length *= 100;
}
printf("[OK]\n");
next:
ret = 0;
}
return ksft_exit_pass();
}

190
tools/testing/selftests/timers/nsleep-lat.c 100644
View File

@ -0,0 +1,190 @@
/* Measure nanosleep timer latency
* by: john stultz (john.stultz@linaro.org)
* (C) Copyright Linaro 2013
* Licensed under the GPLv2
*
* To build:
* $ gcc nsleep-lat.c -o nsleep-lat -lrt
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>
#include <sys/timex.h>
#include <string.h>
#include <signal.h>
#ifdef KTEST
#include "../kselftest.h"
#else
static inline int ksft_exit_pass(void)
{
exit(0);
}
static inline int ksft_exit_fail(void)
{
exit(1);
}
#endif
#define NSEC_PER_SEC 1000000000ULL
#define UNRESONABLE_LATENCY 40000000 /* 40ms in nanosecs */
#define CLOCK_REALTIME 0
#define CLOCK_MONOTONIC 1
#define CLOCK_PROCESS_CPUTIME_ID 2
#define CLOCK_THREAD_CPUTIME_ID 3
#define CLOCK_MONOTONIC_RAW 4
#define CLOCK_REALTIME_COARSE 5
#define CLOCK_MONOTONIC_COARSE 6
#define CLOCK_BOOTTIME 7
#define CLOCK_REALTIME_ALARM 8
#define CLOCK_BOOTTIME_ALARM 9
#define CLOCK_HWSPECIFIC 10
#define CLOCK_TAI 11
#define NR_CLOCKIDS 12
#define UNSUPPORTED 0xf00f
char *clockstring(int clockid)
{
switch (clockid) {
case CLOCK_REALTIME:
return "CLOCK_REALTIME";
case CLOCK_MONOTONIC:
return "CLOCK_MONOTONIC";
case CLOCK_PROCESS_CPUTIME_ID:
return "CLOCK_PROCESS_CPUTIME_ID";
case CLOCK_THREAD_CPUTIME_ID:
return "CLOCK_THREAD_CPUTIME_ID";
case CLOCK_MONOTONIC_RAW:
return "CLOCK_MONOTONIC_RAW";
case CLOCK_REALTIME_COARSE:
return "CLOCK_REALTIME_COARSE";
case CLOCK_MONOTONIC_COARSE:
return "CLOCK_MONOTONIC_COARSE";
case CLOCK_BOOTTIME:
return "CLOCK_BOOTTIME";
case CLOCK_REALTIME_ALARM:
return "CLOCK_REALTIME_ALARM";
case CLOCK_BOOTTIME_ALARM:
return "CLOCK_BOOTTIME_ALARM";
case CLOCK_TAI:
return "CLOCK_TAI";
};
return "UNKNOWN_CLOCKID";
}
struct timespec timespec_add(struct timespec ts, unsigned long long ns)
{
ts.tv_nsec += ns;
while (ts.tv_nsec >= NSEC_PER_SEC) {
ts.tv_nsec -= NSEC_PER_SEC;
ts.tv_sec++;
}
return ts;
}
long long timespec_sub(struct timespec a, struct timespec b)
{
long long ret = NSEC_PER_SEC * b.tv_sec + b.tv_nsec;
ret -= NSEC_PER_SEC * a.tv_sec + a.tv_nsec;
return ret;
}
int nanosleep_lat_test(int clockid, long long ns)
{
struct timespec start, end, target;
long long latency = 0;
int i, count;
target.tv_sec = ns/NSEC_PER_SEC;
target.tv_nsec = ns%NSEC_PER_SEC;
if (clock_gettime(clockid, &start))
return UNSUPPORTED;
if (clock_nanosleep(clockid, 0, &target, NULL))
return UNSUPPORTED;
count = 10;
/* First check relative latency */
clock_gettime(clockid, &start);
for (i = 0; i < count; i++)
clock_nanosleep(clockid, 0, &target, NULL);
clock_gettime(clockid, &end);
if (((timespec_sub(start, end)/count)-ns) > UNRESONABLE_LATENCY) {
printf("Large rel latency: %lld ns :", (timespec_sub(start, end)/count)-ns);
return -1;
}
/* Next check absolute latency */
for (i = 0; i < count; i++) {
clock_gettime(clockid, &start);
target = timespec_add(start, ns);
clock_nanosleep(clockid, TIMER_ABSTIME, &target, NULL);
clock_gettime(clockid, &end);
latency += timespec_sub(target, end);
}
if (latency/count > UNRESONABLE_LATENCY) {
printf("Large abs latency: %lld ns :", latency/count);
return -1;
}
return 0;
}
int main(int argc, char **argv)
{
long long length;
int clockid, ret;
for (clockid = CLOCK_REALTIME; clockid < NR_CLOCKIDS; clockid++) {
/* Skip cputime clockids since nanosleep won't increment cputime */
if (clockid == CLOCK_PROCESS_CPUTIME_ID ||
clockid == CLOCK_THREAD_CPUTIME_ID ||
clockid == CLOCK_HWSPECIFIC)
continue;
printf("nsleep latency %-26s ", clockstring(clockid));
length = 10;
while (length <= (NSEC_PER_SEC * 10)) {
ret = nanosleep_lat_test(clockid, length);
if (ret)
break;
length *= 100;
}
if (ret == UNSUPPORTED) {
printf("[UNSUPPORTED]\n");
continue;
}
if (ret < 0) {
printf("[FAILED]\n");
return ksft_exit_fail();
}
printf("[OK]\n");
}
return ksft_exit_pass();
}

9
tools/testing/selftests/timers/posix_timers.c
View File

@ -35,10 +35,11 @@ static void user_loop(void)
static void kernel_loop(void)
{
void *addr = sbrk(0);
int err = 0;
while (!done) {
brk(addr + 4096);
brk(addr);
while (!done && !err) {
err = brk(addr + 4096);
err |= brk(addr);
}
}
@ -190,8 +191,6 @@ static int check_timer_create(int which)
int main(int argc, char **argv)
{
int err;
printf("Testing posix timers. False negative may happen on CPU execution \n");
printf("based timers if other threads run on the CPU...\n");

154
tools/testing/selftests/timers/raw_skew.c 100644
View File

@ -0,0 +1,154 @@
/* CLOCK_MONOTONIC vs CLOCK_MONOTONIC_RAW skew test
* by: john stultz (johnstul@us.ibm.com)
* John Stultz <john.stultz@linaro.org>
* (C) Copyright IBM 2012
* (C) Copyright Linaro Limited 2015
* Licensed under the GPLv2
*
* To build:
* $ gcc raw_skew.c -o raw_skew -lrt
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/time.h>
#include <sys/timex.h>
#include <time.h>
#ifdef KTEST
#include "../kselftest.h"
#else
static inline int ksft_exit_pass(void)
{
exit(0);
}
static inline int ksft_exit_fail(void)
{
exit(1);
}
#endif
#define CLOCK_MONOTONIC_RAW 4
#define NSEC_PER_SEC 1000000000LL
#define shift_right(x, s) ({ \
__typeof__(x) __x = (x); \
__typeof__(s) __s = (s); \
__x < 0 ? -(-__x >> __s) : __x >> __s; \
})
long long llabs(long long val)
{
if (val < 0)
val = -val;
return val;
}
unsigned long long ts_to_nsec(struct timespec ts)
{
return ts.tv_sec * NSEC_PER_SEC + ts.tv_nsec;
}
struct timespec nsec_to_ts(long long ns)
{
struct timespec ts;
ts.tv_sec = ns/NSEC_PER_SEC;
ts.tv_nsec = ns%NSEC_PER_SEC;
return ts;
}
long long diff_timespec(struct timespec start, struct timespec end)
{
long long start_ns, end_ns;
start_ns = ts_to_nsec(start);
end_ns = ts_to_nsec(end);
return end_ns - start_ns;
}
void get_monotonic_and_raw(struct timespec *mon, struct timespec *raw)
{
struct timespec start, mid, end;
long long diff = 0, tmp;
int i;
for (i = 0; i < 3; i++) {
long long newdiff;
clock_gettime(CLOCK_MONOTONIC, &start);
clock_gettime(CLOCK_MONOTONIC_RAW, &mid);
clock_gettime(CLOCK_MONOTONIC, &end);
newdiff = diff_timespec(start, end);
if (diff == 0 || newdiff < diff) {
diff = newdiff;
*raw = mid;
tmp = (ts_to_nsec(start) + ts_to_nsec(end))/2;
*mon = nsec_to_ts(tmp);
}
}
}
int main(int argv, char **argc)
{
struct timespec mon, raw, start, end;
long long delta1, delta2, interval, eppm, ppm;
struct timex tx1, tx2;
setbuf(stdout, NULL);
if (clock_gettime(CLOCK_MONOTONIC_RAW, &raw)) {
printf("ERR: NO CLOCK_MONOTONIC_RAW\n");
return -1;
}
tx1.modes = 0;
adjtimex(&tx1);
get_monotonic_and_raw(&mon, &raw);
start = mon;
delta1 = diff_timespec(mon, raw);
if (tx1.offset)
printf("WARNING: ADJ_OFFSET in progress, this will cause inaccurate results\n");
printf("Estimating clock drift: ");
sleep(120);
get_monotonic_and_raw(&mon, &raw);
end = mon;
tx2.modes = 0;
adjtimex(&tx2);
delta2 = diff_timespec(mon, raw);
interval = diff_timespec(start, end);
/* calculate measured ppm between MONOTONIC and MONOTONIC_RAW */
eppm = ((delta2-delta1)*NSEC_PER_SEC)/interval;
eppm = -eppm;
printf("%lld.%i(est)", eppm/1000, abs((int)(eppm%1000)));
/* Avg the two actual freq samples adjtimex gave us */
ppm = (tx1.freq + tx2.freq) * 1000 / 2;
ppm = (long long)tx1.freq * 1000;
ppm = shift_right(ppm, 16);
printf(" %lld.%i(act)", ppm/1000, abs((int)(ppm%1000)));
if (llabs(eppm - ppm) > 1000) {
printf(" [FAILED]\n");
return ksft_exit_fail();
}
printf(" [OK]\n");
return ksft_exit_pass();
}

271
tools/testing/selftests/timers/rtctest.c 100644
View File

@ -0,0 +1,271 @@
/*
* Real Time Clock Driver Test/Example Program
*
* Compile with:
* gcc -s -Wall -Wstrict-prototypes rtctest.c -o rtctest
*
* Copyright (C) 1996, Paul Gortmaker.
*
* Released under the GNU General Public License, version 2,
* included herein by reference.
*
*/
#include <stdio.h>
#include <linux/rtc.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
/*
* This expects the new RTC class driver framework, working with
* clocks that will often not be clones of what the PC-AT had.
* Use the command line to specify another RTC if you need one.
*/
static const char default_rtc[] = "/dev/rtc0";
int main(int argc, char **argv)
{
int i, fd, retval, irqcount = 0;
unsigned long tmp, data;
struct rtc_time rtc_tm;
const char *rtc = default_rtc;
struct timeval start, end, diff;
switch (argc) {
case 2:
rtc = argv[1];
/* FALLTHROUGH */
case 1:
break;
default:
fprintf(stderr, "usage: rtctest [rtcdev]\n");
return 1;
}
fd = open(rtc, O_RDONLY);
if (fd == -1) {
perror(rtc);
exit(errno);
}
fprintf(stderr, "\n\t\t\tRTC Driver Test Example.\n\n");
/* Turn on update interrupts (one per second) */
retval = ioctl(fd, RTC_UIE_ON, 0);
if (retval == -1) {
if (errno == ENOTTY) {
fprintf(stderr,
"\n...Update IRQs not supported.\n");
goto test_READ;
}
perror("RTC_UIE_ON ioctl");
exit(errno);
}
fprintf(stderr, "Counting 5 update (1/sec) interrupts from reading %s:",
rtc);
fflush(stderr);
for (i=1; i<6; i++) {
/* This read will block */
retval = read(fd, &data, sizeof(unsigned long));
if (retval == -1) {
perror("read");
exit(errno);
}
fprintf(stderr, " %d",i);
fflush(stderr);
irqcount++;
}
fprintf(stderr, "\nAgain, from using select(2) on /dev/rtc:");
fflush(stderr);
for (i=1; i<6; i++) {
struct timeval tv = {5, 0}; /* 5 second timeout on select */
fd_set readfds;
FD_ZERO(&readfds);
FD_SET(fd, &readfds);
/* The select will wait until an RTC interrupt happens. */
retval = select(fd+1, &readfds, NULL, NULL, &tv);
if (retval == -1) {
perror("select");
exit(errno);
}
/* This read won't block unlike the select-less case above. */
retval = read(fd, &data, sizeof(unsigned long));
if (retval == -1) {
perror("read");
exit(errno);
}
fprintf(stderr, " %d",i);
fflush(stderr);
irqcount++;
}
/* Turn off update interrupts */
retval = ioctl(fd, RTC_UIE_OFF, 0);
if (retval == -1) {
perror("RTC_UIE_OFF ioctl");
exit(errno);
}
test_READ:
/* Read the RTC time/date */
retval = ioctl(fd, RTC_RD_TIME, &rtc_tm);
if (retval == -1) {
perror("RTC_RD_TIME ioctl");
exit(errno);
}
fprintf(stderr, "\n\nCurrent RTC date/time is %d-%d-%d, %02d:%02d:%02d.\n",
rtc_tm.tm_mday, rtc_tm.tm_mon + 1, rtc_tm.tm_year + 1900,
rtc_tm.tm_hour, rtc_tm.tm_min, rtc_tm.tm_sec);
/* Set the alarm to 5 sec in the future, and check for rollover */
rtc_tm.tm_sec += 5;
if (rtc_tm.tm_sec >= 60) {
rtc_tm.tm_sec %= 60;
rtc_tm.tm_min++;
}
if (rtc_tm.tm_min == 60) {
rtc_tm.tm_min = 0;
rtc_tm.tm_hour++;
}
if (rtc_tm.tm_hour == 24)
rtc_tm.tm_hour = 0;
retval = ioctl(fd, RTC_ALM_SET, &rtc_tm);
if (retval == -1) {
if (errno == ENOTTY) {
fprintf(stderr,
"\n...Alarm IRQs not supported.\n");
goto test_PIE;
}
perror("RTC_ALM_SET ioctl");
exit(errno);
}
/* Read the current alarm settings */
retval = ioctl(fd, RTC_ALM_READ, &rtc_tm);
if (retval == -1) {
perror("RTC_ALM_READ ioctl");
exit(errno);
}
fprintf(stderr, "Alarm time now set to %02d:%02d:%02d.\n",
rtc_tm.tm_hour, rtc_tm.tm_min, rtc_tm.tm_sec);
/* Enable alarm interrupts */
retval = ioctl(fd, RTC_AIE_ON, 0);
if (retval == -1) {
perror("RTC_AIE_ON ioctl");
exit(errno);
}
fprintf(stderr, "Waiting 5 seconds for alarm...");
fflush(stderr);
/* This blocks until the alarm ring causes an interrupt */
retval = read(fd, &data, sizeof(unsigned long));
if (retval == -1) {
perror("read");
exit(errno);
}
irqcount++;
fprintf(stderr, " okay. Alarm rang.\n");
/* Disable alarm interrupts */
retval = ioctl(fd, RTC_AIE_OFF, 0);
if (retval == -1) {
perror("RTC_AIE_OFF ioctl");
exit(errno);
}
test_PIE:
/* Read periodic IRQ rate */
retval = ioctl(fd, RTC_IRQP_READ, &tmp);
if (retval == -1) {
/* not all RTCs support periodic IRQs */
if (errno == ENOTTY) {
fprintf(stderr, "\nNo periodic IRQ support\n");
goto done;
}
perror("RTC_IRQP_READ ioctl");
exit(errno);
}
fprintf(stderr, "\nPeriodic IRQ rate is %ldHz.\n", tmp);
fprintf(stderr, "Counting 20 interrupts at:");
fflush(stderr);
/* The frequencies 128Hz, 256Hz, ... 8192Hz are only allowed for root. */
for (tmp=2; tmp<=64; tmp*=2) {
retval = ioctl(fd, RTC_IRQP_SET, tmp);
if (retval == -1) {
/* not all RTCs can change their periodic IRQ rate */
if (errno == ENOTTY) {
fprintf(stderr,
"\n...Periodic IRQ rate is fixed\n");
goto done;
}
perror("RTC_IRQP_SET ioctl");
exit(errno);
}
fprintf(stderr, "\n%ldHz:\t", tmp);
fflush(stderr);
/* Enable periodic interrupts */
retval = ioctl(fd, RTC_PIE_ON, 0);
if (retval == -1) {
perror("RTC_PIE_ON ioctl");
exit(errno);
}
for (i=1; i<21; i++) {
gettimeofday(&start, NULL);
/* This blocks */
retval = read(fd, &data, sizeof(unsigned long));
if (retval == -1) {
perror("read");
exit(errno);
}
gettimeofday(&end, NULL);
timersub(&end, &start, &diff);
if (diff.tv_sec > 0 ||
diff.tv_usec > ((1000000L / tmp) * 1.10)) {
fprintf(stderr, "\nPIE delta error: %ld.%06ld should be close to 0.%06ld\n",
diff.tv_sec, diff.tv_usec,
(1000000L / tmp));
fflush(stdout);
exit(-1);
}
fprintf(stderr, " %d",i);
fflush(stderr);
irqcount++;
}
/* Disable periodic interrupts */
retval = ioctl(fd, RTC_PIE_OFF, 0);
if (retval == -1) {
perror("RTC_PIE_OFF ioctl");
exit(errno);
}
}
done:
fprintf(stderr, "\n\n\t\t\t *** Test complete ***\n");
close(fd);
return 0;
}

144
tools/testing/selftests/timers/set-2038.c 100644
View File

@ -0,0 +1,144 @@
/* Time bounds setting test
* by: john stultz (johnstul@us.ibm.com)
* (C) Copyright IBM 2012
* Licensed under the GPLv2
*
* NOTE: This is a meta-test which sets the time to edge cases then
* uses other tests to detect problems. Thus this test requires that
* the inconsistency-check and nanosleep tests be present in the same
* directory it is run from.
*
* To build:
* $ gcc set-2038.c -o set-2038 -lrt
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <sys/time.h>
#ifdef KTEST
#include "../kselftest.h"
#else
static inline int ksft_exit_pass(void)
{
exit(0);
}
static inline int ksft_exit_fail(void)
{
exit(1);
}
#endif
#define NSEC_PER_SEC 1000000000LL
#define KTIME_MAX ((long long)~((unsigned long long)1 << 63))
#define KTIME_SEC_MAX (KTIME_MAX / NSEC_PER_SEC)
#define YEAR_1901 (-0x7fffffffL)
#define YEAR_1970 1
#define YEAR_2038 0x7fffffffL /*overflows 32bit time_t */
#define YEAR_2262 KTIME_SEC_MAX /*overflows 64bit ktime_t */
#define YEAR_MAX ((long long)((1ULL<<63)-1)) /*overflows 64bit time_t */
int is32bits(void)
{
return (sizeof(long) == 4);
}
int settime(long long time)
{
struct timeval now;
int ret;
now.tv_sec = (time_t)time;
now.tv_usec = 0;
ret = settimeofday(&now, NULL);
printf("Setting time to 0x%lx: %d\n", (long)time, ret);
return ret;
}
int do_tests(void)
{
int ret;
ret = system("date");
ret = system("./inconsistency-check -c 0 -t 20");
ret |= system("./nanosleep");
ret |= system("./nsleep-lat");
return ret;
}
int main(int argc, char *argv[])
{
int ret = 0;
int opt, dangerous = 0;
time_t start;
/* Process arguments */
while ((opt = getopt(argc, argv, "d")) != -1) {
switch (opt) {
case 'd':
dangerous = 1;
}
}
start = time(0);
/* First test that crazy values don't work */
if (!settime(YEAR_1901)) {
ret = -1;
goto out;
}
if (!settime(YEAR_MAX)) {
ret = -1;
goto out;
}
if (!is32bits() && !settime(YEAR_2262)) {
ret = -1;
goto out;
}
/* Now test behavior near edges */
settime(YEAR_1970);
ret = do_tests();
if (ret)
goto out;
settime(YEAR_2038 - 600);
ret = do_tests();
if (ret)
goto out;
/* The rest of the tests can blowup on 32bit systems */
if (is32bits() && !dangerous)
goto out;
/* Test rollover behavior 32bit edge */
settime(YEAR_2038 - 10);
ret = do_tests();
if (ret)
goto out;
settime(YEAR_2262 - 600);
ret = do_tests();
out:
/* restore clock */
settime(start);
if (ret)
return ksft_exit_fail();
return ksft_exit_pass();
}

79
tools/testing/selftests/timers/set-tai.c 100644
View File

@ -0,0 +1,79 @@
/* Set tai offset
* by: John Stultz <john.stultz@linaro.org>
* (C) Copyright Linaro 2013
* Licensed under the GPLv2
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>
#include <sys/timex.h>
#include <string.h>
#include <signal.h>
#include <unistd.h>
#ifdef KTEST
#include "../kselftest.h"
#else
static inline int ksft_exit_pass(void)
{
exit(0);
}
static inline int ksft_exit_fail(void)
{
exit(1);
}
#endif
int set_tai(int offset)
{
struct timex tx;
memset(&tx, 0, sizeof(tx));
tx.modes = ADJ_TAI;
tx.constant = offset;
return adjtimex(&tx);
}
int get_tai(void)
{
struct timex tx;
memset(&tx, 0, sizeof(tx));
adjtimex(&tx);
return tx.tai;
}
int main(int argc, char **argv)
{
int i, ret;
ret = get_tai();
printf("tai offset started at %i\n", ret);
printf("Checking tai offsets can be properly set: ");
for (i = 1; i <= 60; i++) {
ret = set_tai(i);
ret = get_tai();
if (ret != i) {
printf("[FAILED] expected: %i got %i\n", i, ret);
return ksft_exit_fail();
}
}
printf("[OK]\n");
return ksft_exit_pass();
}

216
tools/testing/selftests/timers/set-timer-lat.c 100644
View File

@ -0,0 +1,216 @@
/* set_timer latency test
* John Stultz (john.stultz@linaro.org)
* (C) Copyright Linaro 2014
* Licensed under the GPLv2
*
* This test makes sure the set_timer api is correct
*
* To build:
* $ gcc set-timer-lat.c -o set-timer-lat -lrt
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <stdio.h>
#include <unistd.h>
#include <time.h>
#include <string.h>
#include <signal.h>
#include <stdlib.h>
#include <pthread.h>
#ifdef KTEST
#include "../kselftest.h"
#else
static inline int ksft_exit_pass(void)
{
exit(0);
}
static inline int ksft_exit_fail(void)
{
exit(1);
}
#endif
#define CLOCK_REALTIME 0
#define CLOCK_MONOTONIC 1
#define CLOCK_PROCESS_CPUTIME_ID 2
#define CLOCK_THREAD_CPUTIME_ID 3
#define CLOCK_MONOTONIC_RAW 4
#define CLOCK_REALTIME_COARSE 5
#define CLOCK_MONOTONIC_COARSE 6
#define CLOCK_BOOTTIME 7
#define CLOCK_REALTIME_ALARM 8
#define CLOCK_BOOTTIME_ALARM 9
#define CLOCK_HWSPECIFIC 10
#define CLOCK_TAI 11
#define NR_CLOCKIDS 12
#define NSEC_PER_SEC 1000000000ULL
#define UNRESONABLE_LATENCY 40000000 /* 40ms in nanosecs */
#define TIMER_SECS 1
int alarmcount;
int clock_id;
struct timespec start_time;
long long max_latency_ns;
char *clockstring(int clockid)
{
switch (clockid) {
case CLOCK_REALTIME:
return "CLOCK_REALTIME";
case CLOCK_MONOTONIC:
return "CLOCK_MONOTONIC";
case CLOCK_PROCESS_CPUTIME_ID:
return "CLOCK_PROCESS_CPUTIME_ID";
case CLOCK_THREAD_CPUTIME_ID:
return "CLOCK_THREAD_CPUTIME_ID";
case CLOCK_MONOTONIC_RAW:
return "CLOCK_MONOTONIC_RAW";
case CLOCK_REALTIME_COARSE:
return "CLOCK_REALTIME_COARSE";
case CLOCK_MONOTONIC_COARSE:
return "CLOCK_MONOTONIC_COARSE";
case CLOCK_BOOTTIME:
return "CLOCK_BOOTTIME";
case CLOCK_REALTIME_ALARM:
return "CLOCK_REALTIME_ALARM";
case CLOCK_BOOTTIME_ALARM:
return "CLOCK_BOOTTIME_ALARM";
case CLOCK_TAI:
return "CLOCK_TAI";
};
return "UNKNOWN_CLOCKID";
}
long long timespec_sub(struct timespec a, struct timespec b)
{
long long ret = NSEC_PER_SEC * b.tv_sec + b.tv_nsec;
ret -= NSEC_PER_SEC * a.tv_sec + a.tv_nsec;
return ret;
}
void sigalarm(int signo)
{
long long delta_ns;
struct timespec ts;
clock_gettime(clock_id, &ts);
alarmcount++;
delta_ns = timespec_sub(start_time, ts);
delta_ns -= NSEC_PER_SEC * TIMER_SECS * alarmcount;
if (delta_ns < 0)
printf("%s timer fired early: FAIL\n", clockstring(clock_id));
if (delta_ns > max_latency_ns)
max_latency_ns = delta_ns;
}
int do_timer(int clock_id, int flags)
{
struct sigevent se;
timer_t tm1;
struct itimerspec its1, its2;
int err;
/* Set up timer: */
memset(&se, 0, sizeof(se));
se.sigev_notify = SIGEV_SIGNAL;
se.sigev_signo = SIGRTMAX;
se.sigev_value.sival_int = 0;
max_latency_ns = 0;
alarmcount = 0;
err = timer_create(clock_id, &se, &tm1);
if (err) {
if ((clock_id == CLOCK_REALTIME_ALARM) ||
(clock_id == CLOCK_BOOTTIME_ALARM)) {
printf("%-22s %s missing CAP_WAKE_ALARM? : [UNSUPPORTED]\n",
clockstring(clock_id),
flags ? "ABSTIME":"RELTIME");
return 0;
}
printf("%s - timer_create() failed\n", clockstring(clock_id));
return -1;
}
clock_gettime(clock_id, &start_time);
if (flags) {
its1.it_value = start_time;
its1.it_value.tv_sec += TIMER_SECS;
} else {
its1.it_value.tv_sec = TIMER_SECS;
its1.it_value.tv_nsec = 0;
}
its1.it_interval.tv_sec = TIMER_SECS;
its1.it_interval.tv_nsec = 0;
err = timer_settime(tm1, flags, &its1, &its2);
if (err) {
printf("%s - timer_settime() failed\n", clockstring(clock_id));
return -1;
}
while (alarmcount < 5)
sleep(1);
printf("%-22s %s max latency: %10lld ns : ",
clockstring(clock_id),
flags ? "ABSTIME":"RELTIME",
max_latency_ns);
timer_delete(tm1);
if (max_latency_ns < UNRESONABLE_LATENCY) {
printf("[OK]\n");
return 0;
}
printf("[FAILED]\n");
return -1;
}
int main(void)
{
struct sigaction act;
int signum = SIGRTMAX;
int ret = 0;
/* Set up signal handler: */
sigfillset(&act.sa_mask);
act.sa_flags = 0;
act.sa_handler = sigalarm;
sigaction(signum, &act, NULL);
printf("Setting timers for every %i seconds\n", TIMER_SECS);
for (clock_id = 0; clock_id < NR_CLOCKIDS; clock_id++) {
if ((clock_id == CLOCK_PROCESS_CPUTIME_ID) ||
(clock_id == CLOCK_THREAD_CPUTIME_ID) ||
(clock_id == CLOCK_MONOTONIC_RAW) ||
(clock_id == CLOCK_REALTIME_COARSE) ||
(clock_id == CLOCK_MONOTONIC_COARSE) ||
(clock_id == CLOCK_HWSPECIFIC))
continue;
ret |= do_timer(clock_id, TIMER_ABSTIME);
ret |= do_timer(clock_id, 0);
}
if (ret)
return ksft_exit_fail();
return ksft_exit_pass();
}

89
tools/testing/selftests/timers/skew_consistency.c 100644
View File

@ -0,0 +1,89 @@
/* ADJ_FREQ Skew consistency test
* by: john stultz (johnstul@us.ibm.com)
* (C) Copyright IBM 2012
* Licensed under the GPLv2
*
* NOTE: This is a meta-test which cranks the ADJ_FREQ knob back
* and forth and watches for consistency problems. Thus this test requires
* that the inconsistency-check tests be present in the same directory it
* is run from.
*
* To build:
* $ gcc skew_consistency.c -o skew_consistency -lrt
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/timex.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#ifdef KTEST
#include "../kselftest.h"
#else
static inline int ksft_exit_pass(void)
{
exit(0);
}
static inline int ksft_exit_fail(void)
{
exit(1);
}
#endif
#define NSEC_PER_SEC 1000000000LL
int main(int argv, char **argc)
{
struct timex tx;
int ret, ppm;
pid_t pid;
printf("Running Asyncrhonous Frequency Changing Tests...\n");
pid = fork();
if (!pid)
return system("./inconsistency-check -c 1 -t 600");
ppm = 500;
ret = 0;
while (pid != waitpid(pid, &ret, WNOHANG)) {
ppm = -ppm;
tx.modes = ADJ_FREQUENCY;
tx.freq = ppm << 16;
adjtimex(&tx);
usleep(500000);
}
/* Set things back */
tx.modes = ADJ_FREQUENCY;
tx.offset = 0;
adjtimex(&tx);
if (ret) {
printf("[FAILED]\n");
return ksft_exit_fail();
}
printf("[OK]\n");
return ksft_exit_pass();
}

204
tools/testing/selftests/timers/threadtest.c 100644
View File

@ -0,0 +1,204 @@
/* threadtest.c
* by: john stultz (johnstul@us.ibm.com)
* (C) Copyright IBM 2004, 2005, 2006, 2012
* Licensed under the GPLv2
*
* To build:
* $ gcc threadtest.c -o threadtest -lrt
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/time.h>
#include <pthread.h>
#ifdef KTEST
#include "../kselftest.h"
#else
static inline int ksft_exit_pass(void)
{
exit(0);
}
static inline int ksft_exit_fail(void)
{
exit(1);
}
#endif
/* serializes shared list access */
pthread_mutex_t list_lock = PTHREAD_MUTEX_INITIALIZER;
/* serializes console output */
pthread_mutex_t print_lock = PTHREAD_MUTEX_INITIALIZER;
#define MAX_THREADS 128
#define LISTSIZE 128
int done = 0;
struct timespec global_list[LISTSIZE];
int listcount = 0;
void checklist(struct timespec *list, int size)
{
int i, j;
struct timespec *a, *b;
/* scan the list */
for (i = 0; i < size-1; i++) {
a = &list[i];
b = &list[i+1];
/* look for any time inconsistencies */
if ((b->tv_sec <= a->tv_sec) &&
(b->tv_nsec < a->tv_nsec)) {
/* flag other threads */
done = 1;
/*serialize printing to avoid junky output*/
pthread_mutex_lock(&print_lock);
/* dump the list */
printf("\n");
for (j = 0; j < size; j++) {
if (j == i)
printf("---------------\n");
printf("%lu:%lu\n", list[j].tv_sec, list[j].tv_nsec);
if (j == i+1)
printf("---------------\n");
}
printf("[FAILED]\n");
pthread_mutex_unlock(&print_lock);
}
}
}
/* The shared thread shares a global list
* that each thread fills while holding the lock.
* This stresses clock syncronization across cpus.
*/
void *shared_thread(void *arg)
{
while (!done) {
/* protect the list */
pthread_mutex_lock(&list_lock);
/* see if we're ready to check the list */
if (listcount >= LISTSIZE) {
checklist(global_list, LISTSIZE);
listcount = 0;
}
clock_gettime(CLOCK_MONOTONIC, &global_list[listcount++]);
pthread_mutex_unlock(&list_lock);
}
return NULL;
}
/* Each independent thread fills in its own
* list. This stresses clock_gettime() lock contention.
*/
void *independent_thread(void *arg)
{
struct timespec my_list[LISTSIZE];
int count;
while (!done) {
/* fill the list */
for (count = 0; count < LISTSIZE; count++)
clock_gettime(CLOCK_MONOTONIC, &my_list[count]);
checklist(my_list, LISTSIZE);
}
return NULL;
}
#define DEFAULT_THREAD_COUNT 8
#define DEFAULT_RUNTIME 30
int main(int argc, char **argv)
{
int thread_count, i;
time_t start, now, runtime;
char buf[255];
pthread_t pth[MAX_THREADS];
int opt;
void *tret;
int ret = 0;
void *(*thread)(void *) = shared_thread;
thread_count = DEFAULT_THREAD_COUNT;
runtime = DEFAULT_RUNTIME;
/* Process arguments */
while ((opt = getopt(argc, argv, "t:n:i")) != -1) {
switch (opt) {
case 't':
runtime = atoi(optarg);
break;
case 'n':
thread_count = atoi(optarg);
break;
case 'i':
thread = independent_thread;
printf("using independent threads\n");
break;
default:
printf("Usage: %s [-t <secs>] [-n <numthreads>] [-i]\n", argv[0]);
printf(" -t: time to run\n");
printf(" -n: number of threads\n");
printf(" -i: use independent threads\n");
return -1;
}
}
if (thread_count > MAX_THREADS)
thread_count = MAX_THREADS;
setbuf(stdout, NULL);
start = time(0);
strftime(buf, 255, "%a, %d %b %Y %T %z", localtime(&start));
printf("%s\n", buf);
printf("Testing consistency with %i threads for %ld seconds: ", thread_count, runtime);
/* spawn */
for (i = 0; i < thread_count; i++)
pthread_create(&pth[i], 0, thread, 0);
while (time(&now) < start + runtime) {
sleep(1);
if (done) {
ret = 1;
strftime(buf, 255, "%a, %d %b %Y %T %z", localtime(&now));
printf("%s\n", buf);
goto out;
}
}
printf("[OK]\n");
done = 1;
out:
/* wait */
for (i = 0; i < thread_count; i++)
pthread_join(pth[i], &tret);
/* die */
if (ret)
ksft_exit_fail();
return ksft_exit_pass();
}

202
tools/testing/selftests/timers/valid-adjtimex.c 100644
View File

@ -0,0 +1,202 @@
/* valid adjtimex test
* by: John Stultz <john.stultz@linaro.org>
* (C) Copyright Linaro 2015
* Licensed under the GPLv2
*
* This test validates adjtimex interface with valid
* and invalid test data.
*
* Usage: valid-adjtimex
*
* To build:
* $ gcc valid-adjtimex.c -o valid-adjtimex -lrt
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>
#include <sys/timex.h>
#include <string.h>
#include <signal.h>
#include <unistd.h>
#ifdef KTEST
#include "../kselftest.h"
#else
static inline int ksft_exit_pass(void)
{
exit(0);
}
static inline int ksft_exit_fail(void)
{
exit(1);
}
#endif
#define NSEC_PER_SEC 1000000000L
/* clear NTP time_status & time_state */
int clear_time_state(void)
{
struct timex tx;
int ret;
tx.modes = ADJ_STATUS;
tx.status = 0;
ret = adjtimex(&tx);
return ret;
}
#define NUM_FREQ_VALID 32
#define NUM_FREQ_OUTOFRANGE 4
#define NUM_FREQ_INVALID 2
long valid_freq[NUM_FREQ_VALID] = {
-499<<16,
-450<<16,
-400<<16,
-350<<16,
-300<<16,
-250<<16,
-200<<16,
-150<<16,
-100<<16,
-75<<16,
-50<<16,
-25<<16,
-10<<16,
-5<<16,
-1<<16,
-1000,
1<<16,
5<<16,
10<<16,
25<<16,
50<<16,
75<<16,
100<<16,
150<<16,
200<<16,
250<<16,
300<<16,
350<<16,
400<<16,
450<<16,
499<<16,
};
long outofrange_freq[NUM_FREQ_OUTOFRANGE] = {
-1000<<16,
-550<<16,
550<<16,
1000<<16,
};
#define LONG_MAX (~0UL>>1)
#define LONG_MIN (-LONG_MAX - 1)
long invalid_freq[NUM_FREQ_INVALID] = {
LONG_MAX,
LONG_MIN,
};
int validate_freq(void)
{
struct timex tx;
int ret, pass = 0;
int i;
clear_time_state();
memset(&tx, 0, sizeof(struct timex));
/* Set the leap second insert flag */
printf("Testing ADJ_FREQ... ");
for (i = 0; i < NUM_FREQ_VALID; i++) {
tx.modes = ADJ_FREQUENCY;
tx.freq = valid_freq[i];
ret = adjtimex(&tx);
if (ret < 0) {
printf("[FAIL]\n");
printf("Error: adjtimex(ADJ_FREQ, %ld - %ld ppm\n",
valid_freq[i], valid_freq[i]>>16);
pass = -1;
goto out;
}
tx.modes = 0;
ret = adjtimex(&tx);
if (tx.freq != valid_freq[i]) {
printf("Warning: freq value %ld not what we set it (%ld)!\n",
tx.freq, valid_freq[i]);
}
}
for (i = 0; i < NUM_FREQ_OUTOFRANGE; i++) {
tx.modes = ADJ_FREQUENCY;
tx.freq = outofrange_freq[i];
ret = adjtimex(&tx);
if (ret < 0) {
printf("[FAIL]\n");
printf("Error: adjtimex(ADJ_FREQ, %ld - %ld ppm\n",
outofrange_freq[i], outofrange_freq[i]>>16);
pass = -1;
goto out;
}
tx.modes = 0;
ret = adjtimex(&tx);
if (tx.freq == outofrange_freq[i]) {
printf("[FAIL]\n");
printf("ERROR: out of range value %ld actually set!\n",
tx.freq);
pass = -1;
goto out;
}
}
if (sizeof(long) == 8) { /* this case only applies to 64bit systems */
for (i = 0; i < NUM_FREQ_INVALID; i++) {
tx.modes = ADJ_FREQUENCY;
tx.freq = invalid_freq[i];
ret = adjtimex(&tx);
if (ret >= 0) {
printf("[FAIL]\n");
printf("Error: No failure on invalid ADJ_FREQUENCY %ld\n",
invalid_freq[i]);
pass = -1;
goto out;
}
}
}
printf("[OK]\n");
out:
/* reset freq to zero */
tx.modes = ADJ_FREQUENCY;
tx.freq = 0;
ret = adjtimex(&tx);
return pass;
}
int main(int argc, char **argv)
{
if (validate_freq())
return ksft_exit_fail();
return ksft_exit_pass();
}

5
tools/testing/selftests/user/Makefile
View File

@ -3,5 +3,6 @@
# No binaries, but make sure arg-less "make" doesn't trigger "run_tests"
all:
run_tests: all
./test_user_copy.sh
TEST_PROGS := test_user_copy.sh
include ../lib.mk

7
tools/testing/selftests/vm/Makefile
View File

@ -1,6 +1,5 @@
# Makefile for vm selftests
CC = $(CROSS_COMPILE)gcc
CFLAGS = -Wall
BINARIES = hugepage-mmap hugepage-shm map_hugetlb thuge-gen hugetlbfstest
BINARIES += transhuge-stress
@ -9,8 +8,10 @@ all: $(BINARIES)
%: %.c
$(CC) $(CFLAGS) -o $@ $^ -lrt
run_tests: all
@/bin/sh ./run_vmtests || (echo "vmtests: [FAIL]"; exit 1)
TEST_PROGS := run_vmtests
TEST_FILES := $(BINARIES)
include ../lib.mk
clean:
$(RM) $(BINARIES)

0
tools/testing/selftests/vm/run_vmtests 100644 → 100755
View File