13 files changed, 364 insertions, 47 deletions

diff --git a/tools/testing/ktest/ktest.pl b/tools/testing/ktest/ktest.pl
index 0d7fd8b51544..999eab1bc64f 100755
--- a/tools/testing/ktest/ktest.pl
+++ b/tools/testing/ktest/ktest.pl
@@ -1796,7 +1796,7 @@ sub monitor {
                 # We already booted into the kernel we are testing,
                 # but now we booted into another kernel?
                 # Consider this a triple fault.
-                doprint "Aleady booted in Linux kernel $version, but now\n";
+                doprint "Already booted in Linux kernel $version, but now\n";
                 doprint "we booted into Linux kernel $1.\n";
                 doprint "Assuming that this is a triple fault.\n";
                 doprint "To disable this: set DETECT_TRIPLE_FAULT to 0\n";
diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
index 0a63658065f0..4cb14cae3791 100644
--- a/tools/testing/selftests/Makefile
+++ b/tools/testing/selftests/Makefile
@@ -6,6 +6,7 @@ TARGETS += memory-hotplug
 TARGETS += mqueue
 TARGETS += net
 TARGETS += ptrace
+TARGETS += timers
 TARGETS += vm
 
 all:
diff --git a/tools/testing/selftests/cpu-hotplug/Makefile b/tools/testing/selftests/cpu-hotplug/Makefile
index 12657a5e4bf9..ae5faf9aade2 100644
--- a/tools/testing/selftests/cpu-hotplug/Makefile
+++ b/tools/testing/selftests/cpu-hotplug/Makefile
@@ -1,6 +1,6 @@
 all:
 
 run_tests:
-        @./on-off-test.sh || echo "cpu-hotplug selftests: [FAIL]"
+        @/bin/sh ./on-off-test.sh || echo "cpu-hotplug selftests: [FAIL]"
 
 clean:
diff --git a/tools/testing/selftests/kcmp/.gitignore b/tools/testing/selftests/kcmp/.gitignore
new file mode 100644
index 000000000000..5a9b3732b2de
--- /dev/null
+++ b/tools/testing/selftests/kcmp/.gitignore
@@ -0,0 +1,2 @@
+kcmp_test
+kcmp-test-file
diff --git a/tools/testing/selftests/kcmp/Makefile b/tools/testing/selftests/kcmp/Makefile
index 56eb5523dbb8..d7d6bbeeff2f 100644
--- a/tools/testing/selftests/kcmp/Makefile
+++ b/tools/testing/selftests/kcmp/Makefile
@@ -25,5 +25,4 @@ run_tests: all
         @./kcmp_test || echo "kcmp_test: [FAIL]"
 
 clean:
-        rm -fr ./run_test
-        rm -fr ./test-file
+        $(RM) kcmp_test kcmp-test-file
diff --git a/tools/testing/selftests/memory-hotplug/Makefile b/tools/testing/selftests/memory-hotplug/Makefile
index 0f49c3f5f58d..350bfeda3aa8 100644
--- a/tools/testing/selftests/memory-hotplug/Makefile
+++ b/tools/testing/selftests/memory-hotplug/Makefile
@@ -1,6 +1,6 @@
 all:
 
 run_tests:
-        @./on-off-test.sh || echo "memory-hotplug selftests: [FAIL]"
+        @/bin/sh ./on-off-test.sh || echo "memory-hotplug selftests: [FAIL]"
 
 clean:
diff --git a/tools/testing/selftests/net/psock_tpacket.c b/tools/testing/selftests/net/psock_tpacket.c
index c41b58640a05..24adf709bd9d 100644
--- a/tools/testing/selftests/net/psock_tpacket.c
+++ b/tools/testing/selftests/net/psock_tpacket.c
@@ -1,6 +1,7 @@
 /*
  * Copyright 2013 Red Hat, Inc.
  * Author: Daniel Borkmann <dborkman@redhat.com>
+ *         Chetan Loke <loke.chetan@gmail.com> (TPACKET_V3 usage example)
  *
  * A basic test of packet socket's TPACKET_V1/TPACKET_V2/TPACKET_V3 behavior.
  *
@@ -71,18 +72,8 @@
 # define __align_tpacket(x)     __attribute__((aligned(TPACKET_ALIGN(x))))
 #endif
 
-#define BLOCK_STATUS(x)         ((x)->h1.block_status)
-#define BLOCK_NUM_PKTS(x)       ((x)->h1.num_pkts)
-#define BLOCK_O2FP(x)           ((x)->h1.offset_to_first_pkt)
-#define BLOCK_LEN(x)            ((x)->h1.blk_len)
-#define BLOCK_SNUM(x)           ((x)->h1.seq_num)
-#define BLOCK_O2PRIV(x)         ((x)->offset_to_priv)
-#define BLOCK_PRIV(x)           ((void *) ((uint8_t *) (x) + BLOCK_O2PRIV(x)))
-#define BLOCK_HDR_LEN           (ALIGN_8(sizeof(struct block_desc)))
-#define ALIGN_8(x)              (((x) + 8 - 1) & ~(8 - 1))
-#define BLOCK_PLUS_PRIV(sz_pri) (BLOCK_HDR_LEN + ALIGN_8((sz_pri)))
-
 #define NUM_PACKETS             100
+#define ALIGN_8(x)              (((x) + 8 - 1) & ~(8 - 1))
 
 struct ring {
         struct iovec *rd;
@@ -476,41 +467,30 @@ static uint64_t __v3_prev_block_seq_num = 0;
 
 void __v3_test_block_seq_num(struct block_desc *pbd)
 {
-        if (__v3_prev_block_seq_num + 1 != BLOCK_SNUM(pbd)) {
+        if (__v3_prev_block_seq_num + 1 != pbd->h1.seq_num) {
                 fprintf(stderr, "\nprev_block_seq_num:%"PRIu64", expected "
                         "seq:%"PRIu64" != actual seq:%"PRIu64"\n",
                         __v3_prev_block_seq_num, __v3_prev_block_seq_num + 1,
-                        (uint64_t) BLOCK_SNUM(pbd));
+                        (uint64_t) pbd->h1.seq_num);
                 exit(1);
         }
 
-        __v3_prev_block_seq_num = BLOCK_SNUM(pbd);
+        __v3_prev_block_seq_num = pbd->h1.seq_num;
 }
 
 static void __v3_test_block_len(struct block_desc *pbd, uint32_t bytes, int block_num)
 {
-        if (BLOCK_NUM_PKTS(pbd)) {
-                if (bytes != BLOCK_LEN(pbd)) {
-                        fprintf(stderr, "\nblock:%u with %upackets, expected "
-                                "len:%u != actual len:%u\n", block_num,
-                                BLOCK_NUM_PKTS(pbd), bytes, BLOCK_LEN(pbd));
-                        exit(1);
-                }
-        } else {
-                if (BLOCK_LEN(pbd) != BLOCK_PLUS_PRIV(13)) {
-                        fprintf(stderr, "\nblock:%u, expected len:%lu != "
-                                "actual len:%u\n", block_num, BLOCK_HDR_LEN,
-                                BLOCK_LEN(pbd));
-                        exit(1);
-                }
+        if (pbd->h1.num_pkts && bytes != pbd->h1.blk_len) {
+                fprintf(stderr, "\nblock:%u with %upackets, expected "
+                        "len:%u != actual len:%u\n", block_num,
+                        pbd->h1.num_pkts, bytes, pbd->h1.blk_len);
+                exit(1);
         }
 }
 
 static void __v3_test_block_header(struct block_desc *pbd, const int block_num)
 {
-        uint32_t block_status = BLOCK_STATUS(pbd);
-
-        if ((block_status & TP_STATUS_USER) == 0) {
+        if ((pbd->h1.block_status & TP_STATUS_USER) == 0) {
                 fprintf(stderr, "\nblock %u: not in TP_STATUS_USER\n", block_num);
                 exit(1);
         }
@@ -520,14 +500,15 @@ static void __v3_test_block_header(struct block_desc *pbd, const int block_num)
 
 static void __v3_walk_block(struct block_desc *pbd, const int block_num)
 {
-        int num_pkts = BLOCK_NUM_PKTS(pbd), i;
-        unsigned long bytes = 0;
-        unsigned long bytes_with_padding = BLOCK_PLUS_PRIV(13);
+        int num_pkts = pbd->h1.num_pkts, i;
+        unsigned long bytes = 0, bytes_with_padding = ALIGN_8(sizeof(*pbd));
         struct tpacket3_hdr *ppd;
 
         __v3_test_block_header(pbd, block_num);
 
-        ppd = (struct tpacket3_hdr *) ((uint8_t *) pbd + BLOCK_O2FP(pbd));
+        ppd = (struct tpacket3_hdr *) ((uint8_t *) pbd +
+                                       pbd->h1.offset_to_first_pkt);
+
         for (i = 0; i < num_pkts; ++i) {
                 bytes += ppd->tp_snaplen;
 
@@ -551,7 +532,7 @@ static void __v3_walk_block(struct block_desc *pbd, const int block_num)
 
 void __v3_flush_block(struct block_desc *pbd)
 {
-        BLOCK_STATUS(pbd) = TP_STATUS_KERNEL;
+        pbd->h1.block_status = TP_STATUS_KERNEL;
         __sync_synchronize();
 }
 
@@ -577,7 +558,7 @@ static void walk_v3_rx(int sock, struct ring *ring)
         while (total_packets < NUM_PACKETS * 2) {
                 pbd = (struct block_desc *) ring->rd[block_num].iov_base;
 
-                while ((BLOCK_STATUS(pbd) & TP_STATUS_USER) == 0)
+                while ((pbd->h1.block_status & TP_STATUS_USER) == 0)
                         poll(&pfd, 1, 1);
 
                 __v3_walk_block(pbd, block_num);
@@ -624,8 +605,8 @@ static void __v1_v2_fill(struct ring *ring, unsigned int blocks)
 static void __v3_fill(struct ring *ring, unsigned int blocks)
 {
         ring->req3.tp_retire_blk_tov = 64;
-        ring->req3.tp_sizeof_priv = 13;
-        ring->req3.tp_feature_req_word |= TP_FT_REQ_FILL_RXHASH;
+        ring->req3.tp_sizeof_priv = 0;
+        ring->req3.tp_feature_req_word = TP_FT_REQ_FILL_RXHASH;
 
         ring->req3.tp_block_size = getpagesize() << 2;
         ring->req3.tp_frame_size = TPACKET_ALIGNMENT << 7;
diff --git a/tools/testing/selftests/timers/Makefile b/tools/testing/selftests/timers/Makefile
new file mode 100644
index 000000000000..eb2859f4ad21
--- /dev/null
+++ b/tools/testing/selftests/timers/Makefile
@@ -0,0 +1,8 @@
+all:
+        gcc posix_timers.c -o posix_timers -lrt
+
+run_tests: all
+        ./posix_timers
+
+clean:
+        rm -f ./posix_timers
diff --git a/tools/testing/selftests/timers/posix_timers.c b/tools/testing/selftests/timers/posix_timers.c
new file mode 100644
index 000000000000..4fa655d68a81
--- /dev/null
+++ b/tools/testing/selftests/timers/posix_timers.c
@@ -0,0 +1,221 @@
+/*
+ * Copyright (C) 2013 Red Hat, Inc., Frederic Weisbecker <fweisbec@redhat.com>
+ *
+ * Licensed under the terms of the GNU GPL License version 2
+ *
+ * Selftests for a few posix timers interface.
+ *
+ * Kernel loop code stolen from Steven Rostedt <srostedt@redhat.com>
+ */
+
+#include <sys/time.h>
+#include <stdio.h>
+#include <signal.h>
+#include <unistd.h>
+#include <time.h>
+#include <pthread.h>
+
+#define DELAY 2
+#define USECS_PER_SEC 1000000
+
+static volatile int done;
+
+/* Busy loop in userspace to elapse ITIMER_VIRTUAL */
+static void user_loop(void)
+{
+        while (!done);
+}
+
+/*
+ * Try to spend as much time as possible in kernelspace
+ * to elapse ITIMER_PROF.
+ */
+static void kernel_loop(void)
+{
+        void *addr = sbrk(0);
+
+        while (!done) {
+                brk(addr + 4096);
+                brk(addr);
+        }
+}
+
+/*
+ * Sleep until ITIMER_REAL expiration.
+ */
+static void idle_loop(void)
+{
+        pause();
+}
+
+static void sig_handler(int nr)
+{
+        done = 1;
+}
+
+/*
+ * Check the expected timer expiration matches the GTOD elapsed delta since
+ * we armed the timer. Keep a 0.5 sec error margin due to various jitter.
+ */
+static int check_diff(struct timeval start, struct timeval end)
+{
+        long long diff;
+
+        diff = end.tv_usec - start.tv_usec;
+        diff += (end.tv_sec - start.tv_sec) * USECS_PER_SEC;
+
+        if (abs(diff - DELAY * USECS_PER_SEC) > USECS_PER_SEC / 2) {
+                printf("Diff too high: %lld..", diff);
+                return -1;
+        }
+
+        return 0;
+}
+
+static int check_itimer(int which)
+{
+        int err;
+        struct timeval start, end;
+        struct itimerval val = {
+                .it_value.tv_sec = DELAY,
+        };
+
+        printf("Check itimer ");
+
+        if (which == ITIMER_VIRTUAL)
+                printf("virtual... ");
+        else if (which == ITIMER_PROF)
+                printf("prof... ");
+        else if (which == ITIMER_REAL)
+                printf("real... ");
+
+        fflush(stdout);
+
+        done = 0;
+
+        if (which == ITIMER_VIRTUAL)
+                signal(SIGVTALRM, sig_handler);
+        else if (which == ITIMER_PROF)
+                signal(SIGPROF, sig_handler);
+        else if (which == ITIMER_REAL)
+                signal(SIGALRM, sig_handler);
+
+        err = gettimeofday(&start, NULL);
+        if (err < 0) {
+                perror("Can't call gettimeofday()\n");
+                return -1;
+        }
+
+        err = setitimer(which, &val, NULL);
+        if (err < 0) {
+                perror("Can't set timer\n");
+                return -1;
+        }
+
+        if (which == ITIMER_VIRTUAL)
+                user_loop();
+        else if (which == ITIMER_PROF)
+                kernel_loop();
+        else if (which == ITIMER_REAL)
+                idle_loop();
+
+        gettimeofday(&end, NULL);
+        if (err < 0) {
+                perror("Can't call gettimeofday()\n");
+                return -1;
+        }
+
+        if (!check_diff(start, end))
+                printf("[OK]\n");
+        else
+                printf("[FAIL]\n");
+
+        return 0;
+}
+
+static int check_timer_create(int which)
+{
+        int err;
+        timer_t id;
+        struct timeval start, end;
+        struct itimerspec val = {
+                .it_value.tv_sec = DELAY,
+        };
+
+        printf("Check timer_create() ");
+        if (which == CLOCK_THREAD_CPUTIME_ID) {
+                printf("per thread... ");
+        } else if (which == CLOCK_PROCESS_CPUTIME_ID) {
+                printf("per process... ");
+        }
+        fflush(stdout);
+
+        done = 0;
+        timer_create(which, NULL, &id);
+        if (err < 0) {
+                perror("Can't create timer\n");
+                return -1;
+        }
+        signal(SIGALRM, sig_handler);
+
+        err = gettimeofday(&start, NULL);
+        if (err < 0) {
+                perror("Can't call gettimeofday()\n");
+                return -1;
+        }
+
+        err = timer_settime(id, 0, &val, NULL);
+        if (err < 0) {
+                perror("Can't set timer\n");
+                return -1;
+        }
+
+        user_loop();
+
+        gettimeofday(&end, NULL);
+        if (err < 0) {
+                perror("Can't call gettimeofday()\n");
+                return -1;
+        }
+
+        if (!check_diff(start, end))
+                printf("[OK]\n");
+        else
+                printf("[FAIL]\n");
+
+        return 0;
+}
+
+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");
+
+        if (check_itimer(ITIMER_VIRTUAL) < 0)
+                return -1;
+
+        if (check_itimer(ITIMER_PROF) < 0)
+                return -1;
+
+        if (check_itimer(ITIMER_REAL) < 0)
+                return -1;
+
+        if (check_timer_create(CLOCK_THREAD_CPUTIME_ID) < 0)
+                return -1;
+
+        /*
+         * It's unfortunately hard to reliably test a timer expiration
+         * on parallel multithread cputime. We could arm it to expire
+         * on DELAY * nr_threads, with nr_threads busy looping, then wait
+         * the normal DELAY since the time is elapsing nr_threads faster.
+         * But for that we need to ensure we have real physical free CPUs
+         * to ensure true parallelism. So test only one thread until we
+         * find a better solution.
+         */
+        if (check_timer_create(CLOCK_PROCESS_CPUTIME_ID) < 0)
+                return -1;
+
+        return 0;
+}
diff --git a/tools/testing/selftests/vm/.gitignore b/tools/testing/selftests/vm/.gitignore
new file mode 100644
index 000000000000..ff1bb16cec4f
--- /dev/null
+++ b/tools/testing/selftests/vm/.gitignore
@@ -0,0 +1,4 @@
+hugepage-mmap
+hugepage-shm
+map_hugetlb
+thuge-gen
diff --git a/tools/testing/selftests/vm/Makefile b/tools/testing/selftests/vm/Makefile
index 436d2e81868b..3f94e1afd6cf 100644
--- a/tools/testing/selftests/vm/Makefile
+++ b/tools/testing/selftests/vm/Makefile
@@ -2,13 +2,14 @@
 
 CC = $(CROSS_COMPILE)gcc
 CFLAGS = -Wall
+BINARIES = hugepage-mmap hugepage-shm map_hugetlb thuge-gen hugetlbfstest
 
-all: hugepage-mmap hugepage-shm  map_hugetlb thuge-gen
+all: $(BINARIES)
 %: %.c
         $(CC) $(CFLAGS) -o $@ $^
 
 run_tests: all
-        @/bin/sh ./run_vmtests || echo "vmtests: [FAIL]"
+        @/bin/sh ./run_vmtests || (echo "vmtests: [FAIL]"; exit 1)
 
 clean:
-        $(RM) hugepage-mmap hugepage-shm  map_hugetlb
+        $(RM) $(BINARIES)
diff --git a/tools/testing/selftests/vm/hugetlbfstest.c b/tools/testing/selftests/vm/hugetlbfstest.c
new file mode 100644
index 000000000000..ea40ff8c2391
--- /dev/null
+++ b/tools/testing/selftests/vm/hugetlbfstest.c
@@ -0,0 +1,84 @@
+#define _GNU_SOURCE
+#include <assert.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+typedef unsigned long long u64;
+
+static size_t length = 1 << 24;
+
+static u64 read_rss(void)
+{
+        char buf[4096], *s = buf;
+        int i, fd;
+        u64 rss;
+
+        fd = open("/proc/self/statm", O_RDONLY);
+        assert(fd > 2);
+        memset(buf, 0, sizeof(buf));
+        read(fd, buf, sizeof(buf) - 1);
+        for (i = 0; i < 1; i++)
+                s = strchr(s, ' ') + 1;
+        rss = strtoull(s, NULL, 10);
+        return rss << 12; /* assumes 4k pagesize */
+}
+
+static void do_mmap(int fd, int extra_flags, int unmap)
+{
+        int *p;
+        int flags = MAP_PRIVATE | MAP_POPULATE | extra_flags;
+        u64 before, after;
+
+        before = read_rss();
+        p = mmap(NULL, length, PROT_READ | PROT_WRITE, flags, fd, 0);
+        assert(p != MAP_FAILED ||
+                        !"mmap returned an unexpected error");
+        after = read_rss();
+        assert(llabs(after - before - length) < 0x40000 ||
+                        !"rss didn't grow as expected");
+        if (!unmap)
+                return;
+        munmap(p, length);
+        after = read_rss();
+        assert(llabs(after - before) < 0x40000 ||
+                        !"rss didn't shrink as expected");
+}
+
+static int open_file(const char *path)
+{
+        int fd, err;
+
+        unlink(path);
+        fd = open(path, O_CREAT | O_RDWR | O_TRUNC | O_EXCL
+                        | O_LARGEFILE | O_CLOEXEC, 0600);
+        assert(fd > 2);
+        unlink(path);
+        err = ftruncate(fd, length);
+        assert(!err);
+        return fd;
+}
+
+int main(void)
+{
+        int hugefd, fd;
+
+        fd = open_file("/dev/shm/hugetlbhog");
+        hugefd = open_file("/hugepages/hugetlbhog");
+
+        system("echo 100 > /proc/sys/vm/nr_hugepages");
+        do_mmap(-1, MAP_ANONYMOUS, 1);
+        do_mmap(fd, 0, 1);
+        do_mmap(-1, MAP_ANONYMOUS | MAP_HUGETLB, 1);
+        do_mmap(hugefd, 0, 1);
+        do_mmap(hugefd, MAP_HUGETLB, 1);
+        /* Leak the last one to test do_exit() */
+        do_mmap(-1, MAP_ANONYMOUS | MAP_HUGETLB, 0);
+        printf("oll korrekt.\n");
+        return 0;
+}
diff --git a/tools/testing/selftests/vm/run_vmtests b/tools/testing/selftests/vm/run_vmtests
index 4c53cae6c273..c87b6812300d 100644
--- a/tools/testing/selftests/vm/run_vmtests
+++ b/tools/testing/selftests/vm/run_vmtests
@@ -4,6 +4,7 @@
 #we need 256M, below is the size in kB
 needmem=262144
 mnt=./huge
+exitcode=0
 
 #get pagesize and freepages from /proc/meminfo
 while read name size unit; do
@@ -41,6 +42,7 @@ echo "--------------------"
 ./hugepage-mmap
 if [ $? -ne 0 ]; then
         echo "[FAIL]"
+        exitcode=1
 else
         echo "[PASS]"
 fi
@@ -55,6 +57,7 @@ echo "--------------------"
 ./hugepage-shm
 if [ $? -ne 0 ]; then
         echo "[FAIL]"
+        exitcode=1
 else
         echo "[PASS]"
 fi
@@ -67,6 +70,18 @@ echo "--------------------"
 ./map_hugetlb
 if [ $? -ne 0 ]; then
         echo "[FAIL]"
+        exitcode=1
+else
+        echo "[PASS]"
+fi
+
+echo "--------------------"
+echo "running hugetlbfstest"
+echo "--------------------"
+./hugetlbfstest
+if [ $? -ne 0 ]; then
+        echo "[FAIL]"
+        exitcode=1
 else
         echo "[PASS]"
 fi
@@ -75,3 +90,4 @@ fi
 umount $mnt
 rm -rf $mnt
 echo $nr_hugepgs > /proc/sys/vm/nr_hugepages
+exit $exitcode