/* * Copyright (C) 2013 Red Hat, Inc., Frederic Weisbecker * * 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 */ #include #include #include #include #include #include #include "../kselftest.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); int err = 0; while (!done && !err) { err = brk(addr + 4096); err |= 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(); err = 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; err = 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(); err = 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) { 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 ksft_exit_fail(); if (check_itimer(ITIMER_PROF) < 0) return ksft_exit_fail(); if (check_itimer(ITIMER_REAL) < 0) return ksft_exit_fail(); if (check_timer_create(CLOCK_THREAD_CPUTIME_ID) < 0) return ksft_exit_fail(); /* * 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 ksft_exit_fail(); return ksft_exit_pass(); } class='commit-info'> authorDavid S. Miller <davem@davemloft.net>2017-01-30 14:28:22 -0800 committerDavid S. Miller <davem@davemloft.net>2017-01-30 14:28:22 -0800 commit54791b276b4000b307339f269d3bf7db877d536f (patch) tree1c2616bd373ce5ea28aac2a53e32f5b5834901ce /sound/usb/bcd2000 parent5d0e7705774dd412a465896d08d59a81a345c1e4 (diff)parent047487241ff59374fded8c477f21453681f5995c (diff)
Merge branch 'sparc64-non-resumable-user-error-recovery'
Liam R. Howlett says: ==================== sparc64: Recover from userspace non-resumable PIO & MEM errors A non-resumable error from userspace is able to cause a kernel panic or trap loop due to the setup and handling of the queued traps once in the kernel. This patch series addresses both of these issues. The queues are fixed by simply zeroing the memory before use. PIO errors from userspace will result in a SIGBUS being sent to the user process. The MEM errors form userspace will result in a SIGKILL and also cause the offending pages to be claimed so they are no longer used in future tasks. SIGKILL is used to ensure that the process does not try to coredump and result in an attempt to read the memory again from within kernel space. Although there is a HV call to scrub the memory (mem_scrub), there is no easy way to guarantee that the real memory address(es) are not used by other tasks. Clearing the error with mem_scrub would zero the memory and cause the other processes to proceed with bad data. The handling of other non-resumable errors remain unchanged and will cause a panic. ==================== Signed-off-by: David S. Miller <davem@davemloft.net>
Diffstat (limited to 'sound/usb/bcd2000')