/* * Copyright 2015, Cyril Bur, IBM Corp. * * 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 test attempts to see if the VMX registers are correctly reported in a * signal context. Each worker just spins checking its VMX registers, at some * point a signal will interrupt it and C code will check the signal context * ensuring it is also the same. */ #include #include #include #include #include #include #include #include #include #include #include "utils.h" /* Number of times each thread should receive the signal */ #define ITERATIONS 10 /* * Factor by which to multiply number of online CPUs for total number of * worker threads */ #define THREAD_FACTOR 8 __thread vector int varray[] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10,11,12}, {13,14,15,16},{17,18,19,20},{21,22,23,24}, {25,26,27,28},{29,30,31,32},{33,34,35,36}, {37,38,39,40},{41,42,43,44},{45,46,47,48}}; bool bad_context; int running; int threads_starting; extern int preempt_vmx(vector int *varray, int *threads_starting, int *sentinal); void signal_vmx_sig(int sig, siginfo_t *info, void *context) { int i; ucontext_t *uc = context; mcontext_t *mc = &uc->uc_mcontext; /* Only the non volatiles were loaded up */ for (i = 20; i < 32; i++) { if (memcmp(mc->v_regs->vrregs[i], &varray[i - 20], 16)) { int j; /* * Shouldn't printf() in a signal handler, however, this is a * test and we've detected failure. Understanding what failed * is paramount. All that happens after this is tests exit with * failure. */ printf("VMX mismatch at reg %d!\n", i); printf("Reg | Actual | Expected\n"); for (j = 20; j < 32; j++) { printf("%d | 0x%04x%04x%04x%04x | 0x%04x%04x%04x%04x\n", j, mc->v_regs->vrregs[j][0], mc->v_regs->vrregs[j][1], mc->v_regs->vrregs[j][2], mc->v_regs->vrregs[j][3], varray[j - 20][0], varray[j - 20][1], varray[j - 20][2], varray[j - 20][3]); } bad_context = true; break; } } } void *signal_vmx_c(void *p) { int i, j; long rc; struct sigaction act; act.sa_sigaction = signal_vmx_sig; act.sa_flags = SA_SIGINFO; rc = sigaction(SIGUSR1, &act, NULL); if (rc) return p; srand(pthread_self()); for (i = 0; i < 12; i++) for (j = 0; j < 4; j++) varray[i][j] = rand(); rc = preempt_vmx(varray, &threads_starting, &running); return (void *) rc; } int test_signal_vmx(void) { int i, j, rc, threads; void *rc_p; pthread_t *tids; threads = sysconf(_SC_NPROCESSORS_ONLN) * THREAD_FACTOR; tids = malloc(threads * sizeof(pthread_t)); FAIL_IF(!tids); running = true; threads_starting = threads; for (i = 0; i < threads; i++) { rc = pthread_create(&tids[i], NULL, signal_vmx_c, NULL); FAIL_IF(rc); } setbuf(stdout, NULL); printf("\tWaiting for %d workers to start... %d", threads, threads_starting); while (threads_starting) { asm volatile("": : :"memory"); usleep(1000); printf(", %d", threads_starting); } printf(" ...done\n"); printf("\tSending signals to all threads %d times...", ITERATIONS); for (i = 0; i < ITERATIONS; i++) { for (j = 0; j < threads; j++) { pthread_kill(tids[j], SIGUSR1); } sleep(1); } printf("done\n"); printf("\tKilling workers..."); running = 0; for (i = 0; i < threads; i++) { pthread_join(tids[i], &rc_p); /* * Harness will say the fail was here, look at why signal_vmx * returned */ if ((long) rc_p || bad_context) printf("oops\n"); if (bad_context) fprintf(stderr, "\t!! bad_context is true\n"); FAIL_IF((long) rc_p || bad_context); } printf("done\n"); free(tids); return 0; } int main(int argc, char *argv[]) { return test_harness(test_signal_vmx, "vmx_signal"); } ct name='ignorews' onchange='this.form.submit();'>mode:
authorSteven Rostedt (VMware) <rostedt@goodmis.org>2017-01-30 19:27:10 -0500
committerSteven Rostedt (VMware) <rostedt@goodmis.org>2017-01-31 09:13:49 -0500
commit79c6f448c8b79c321e4a1f31f98194e4f6b6cae7 (patch)
tree370efda701f03cccf21e02bb1fdd3b852547d75c /sound/soc/sh/rcar
parent0c744ea4f77d72b3dcebb7a8f2684633ec79be88 (diff)
tracing: Fix hwlat kthread migration
The hwlat tracer creates a kernel thread at start of the tracer. It is pinned to a single CPU and will move to the next CPU after each period of running. If the user modifies the migration thread's affinity, it will not change after that happens. The original code created the thread at the first instance it was called, but later was changed to destroy the thread after the tracer was finished, and would not be created until the next instance of the tracer was established. The code that initialized the affinity was only called on the initial instantiation of the tracer. After that, it was not initialized, and the previous affinity did not match the current newly created one, making it appear that the user modified the thread's affinity when it did not, and the thread failed to migrate again. Cc: stable@vger.kernel.org Fixes: 0330f7aa8ee6 ("tracing: Have hwlat trace migrate across tracing_cpumask CPUs") Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
Diffstat (limited to 'sound/soc/sh/rcar')