/*
|
* Copyright (C) 2013 Philippe Gerum <rpm@xenomai.org>.
|
*
|
* This library is free software; you can redistribute it and/or
|
* modify it under the terms of the GNU Lesser General Public
|
* License as published by the Free Software Foundation; either
|
* version 2 of the License, or (at your option) any later version.
|
*
|
* This library 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
|
* Lesser General Public License for more details.
|
|
* You should have received a copy of the GNU Lesser General Public
|
* License along with this library; if not, write to the Free Software
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
*/
|
#include <stdio.h>
|
#include <stdlib.h>
|
#include "boilerplate/lock.h"
|
#include "copperplate/traceobj.h"
|
#include "copperplate/threadobj.h"
|
#include "copperplate/heapobj.h"
|
#include "xenomai/init.h"
|
#include "internal.h"
|
#ifdef CONFIG_XENO_VALGRIND_API
|
#include <valgrind/valgrind.h>
|
static inline int valgrind_detected(void)
|
{
|
return RUNNING_ON_VALGRIND;
|
}
|
#else
|
static inline int valgrind_detected(void)
|
{
|
return 0;
|
}
|
#endif
|
|
struct tracemark {
|
const char *file;
|
int line;
|
int mark;
|
};
|
|
int traceobj_init(struct traceobj *trobj, const char *label, int nr_marks)
|
{
|
pthread_mutexattr_t mattr;
|
pthread_condattr_t cattr;
|
int ret;
|
|
pthread_mutexattr_init(&mattr);
|
pthread_mutexattr_settype(&mattr, mutex_type_attribute);
|
pthread_mutexattr_setprotocol(&mattr, PTHREAD_PRIO_INHERIT);
|
pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_PRIVATE);
|
ret = __bt(-__RT(pthread_mutex_init(&trobj->lock, &mattr)));
|
pthread_mutexattr_destroy(&mattr);
|
if (ret)
|
return ret;
|
|
pthread_condattr_init(&cattr);
|
pthread_condattr_setpshared(&cattr, PTHREAD_PROCESS_PRIVATE);
|
ret = __bt(-__RT(pthread_cond_init(&trobj->join, &cattr)));
|
pthread_condattr_destroy(&cattr);
|
if (ret) {
|
__RT(pthread_mutex_destroy(&trobj->lock));
|
return ret;
|
}
|
|
/*
|
* We make sure not to unblock from threadobj_join() until at
|
* least one thread has called trace_enter() for this trace
|
* object.
|
*/
|
trobj->nr_threads = -1;
|
|
trobj->label = label;
|
trobj->nr_marks = nr_marks;
|
trobj->cur_mark = 0;
|
|
if (nr_marks > 0) {
|
trobj->marks = malloc(sizeof(struct tracemark) * nr_marks);
|
if (trobj->marks == NULL)
|
panic("cannot allocate mark table for tracing");
|
}
|
|
return 0;
|
}
|
|
static void compare_marks(struct traceobj *trobj, int tseq[], int nr_seq) /* lock held */
|
{
|
int mark;
|
|
for (mark = 0; mark < trobj->cur_mark || mark < nr_seq; mark++) {
|
if (mark >= trobj->cur_mark) {
|
fprintf(stderr, " <missing mark> | [%d] expected\n",
|
tseq[mark]);
|
} else if (mark < nr_seq)
|
__RT(fprintf(stderr, "at %s:%d | [%d] should be [%d]\n",
|
trobj->marks[mark].file,
|
trobj->marks[mark].line,
|
trobj->marks[mark].mark,
|
tseq[mark]));
|
else
|
__RT(fprintf(stderr, "at %s:%d | unexpected [%d]\n",
|
trobj->marks[mark].file,
|
trobj->marks[mark].line,
|
trobj->marks[mark].mark));
|
}
|
|
fflush(stderr);
|
}
|
|
void traceobj_verify(struct traceobj *trobj, int tseq[], int nr_seq)
|
{
|
int end_mark, mark, state;
|
struct service svc;
|
|
CANCEL_DEFER(svc);
|
|
read_lock_safe(&trobj->lock, state);
|
|
if (nr_seq > trobj->nr_marks)
|
goto fail;
|
|
end_mark = trobj->cur_mark;
|
if (end_mark == 0) {
|
read_unlock_safe(&trobj->lock, state);
|
panic("no mark defined");
|
}
|
|
if (end_mark != nr_seq)
|
goto fail;
|
|
for (mark = 0; mark < end_mark; mark++) {
|
if (trobj->marks[mark].mark != tseq[mark])
|
goto fail;
|
}
|
out:
|
read_unlock_safe(&trobj->lock, state);
|
|
CANCEL_RESTORE(svc);
|
|
return;
|
|
fail:
|
if (valgrind_detected()) {
|
warning("valgrind detected: ignoring sequence mismatch");
|
goto out;
|
}
|
|
warning("mismatching execution sequence detected");
|
compare_marks(trobj, tseq, nr_seq);
|
read_unlock_safe(&trobj->lock, state);
|
|
CANCEL_RESTORE(svc);
|
|
#ifdef CONFIG_XENO_MERCURY
|
/*
|
* The Mercury core does not force any affinity, which may
|
* lead to wrong results with some unit tests checking strict
|
* ordering of operations. Tell the user about this. Normally,
|
* such unit tests on Mercury should be pinned on a single CPU
|
* using --cpu-affinity.
|
*/
|
if (CPU_COUNT(&__base_setup_data.cpu_affinity) == 0)
|
warning("NOTE: --cpu-affinity option was not given - this might explain?");
|
#endif
|
#ifndef CONFIG_XENO_ASYNC_CANCEL
|
/*
|
* Lack of async cancellation support might also explain why
|
* some tests have failed.
|
*/
|
warning("NOTE: --disable-async-cancel option was given - this might explain?");
|
#endif
|
exit(5);
|
}
|
|
void traceobj_destroy(struct traceobj *trobj)
|
{
|
free(trobj->marks);
|
__RT(pthread_mutex_destroy(&trobj->lock));
|
}
|
|
static void dump_marks(struct traceobj *trobj) /* lock held */
|
{
|
int mark;
|
|
for (mark = 0; mark < trobj->cur_mark; mark++)
|
fprintf(stderr, "[%d] at %s:%d\n",
|
trobj->marks[mark].mark,
|
trobj->marks[mark].file,
|
trobj->marks[mark].line);
|
|
fflush(stderr);
|
}
|
|
static void dump_marks_on_error(struct traceobj *trobj)
|
{
|
struct service svc;
|
|
CANCEL_DEFER(svc);
|
|
read_lock(&trobj->lock);
|
dump_marks(trobj);
|
read_unlock(&trobj->lock);
|
|
CANCEL_RESTORE(svc);
|
}
|
|
void __traceobj_assert_failed(struct traceobj *trobj,
|
const char *file, int line, const char *cond)
|
{
|
dump_marks_on_error(trobj);
|
panic("trace assertion failed:\n %s:%d => \"%s\"", file, line, cond);
|
}
|
|
void __traceobj_check_abort(struct traceobj *trobj,
|
const char *file, int line,
|
int received, int expected)
|
{
|
dump_marks_on_error(trobj);
|
panic("wrong return status:\n %s:%d => %s (want %s)", file, line,
|
symerror(received), symerror(expected));
|
}
|
|
void __traceobj_check_warn(struct traceobj *trobj,
|
const char *file, int line,
|
int received, int expected)
|
{
|
dump_marks_on_error(trobj);
|
warning("wrong return status:\n %s:%d => %s (want %s)", file, line,
|
symerror(received), symerror(expected));
|
}
|
|
void __traceobj_mark(struct traceobj *trobj,
|
const char *file, int line, int mark)
|
{
|
struct tracemark *tmk;
|
struct service svc;
|
int cur_mark;
|
|
CANCEL_DEFER(svc);
|
|
pthread_testcancel();
|
push_cleanup_lock(&trobj->lock);
|
write_lock(&trobj->lock);
|
|
cur_mark = trobj->cur_mark;
|
if (cur_mark >= trobj->nr_marks) {
|
dump_marks(trobj);
|
panic("too many marks: [%d] at %s:%d", mark, file, line);
|
}
|
|
tmk = trobj->marks + cur_mark;
|
tmk->file = file;
|
tmk->line = line;
|
tmk->mark = mark;
|
trobj->cur_mark++;
|
|
write_unlock(&trobj->lock);
|
pop_cleanup_lock(&trobj->lock);
|
|
CANCEL_RESTORE(svc);
|
}
|
|
void traceobj_enter(struct traceobj *trobj)
|
{
|
struct threadobj *current = threadobj_current();
|
struct service svc;
|
|
if (current)
|
current->tracer = trobj;
|
|
CANCEL_DEFER(svc);
|
|
write_lock_nocancel(&trobj->lock);
|
|
if (++trobj->nr_threads == 0)
|
trobj->nr_threads = 1;
|
|
write_unlock(&trobj->lock);
|
|
CANCEL_RESTORE(svc);
|
}
|
|
/* May be directly called from finalizer. */
|
void traceobj_unwind(struct traceobj *trobj)
|
{
|
struct service svc;
|
int state;
|
|
CANCEL_DEFER(svc);
|
|
write_lock_safe(&trobj->lock, state);
|
|
if (--trobj->nr_threads <= 0)
|
threadobj_cond_signal(&trobj->join);
|
|
write_unlock_safe(&trobj->lock, state);
|
|
CANCEL_RESTORE(svc);
|
}
|
|
void traceobj_exit(struct traceobj *trobj)
|
{
|
struct threadobj *current = threadobj_current();
|
|
if (current)
|
current->tracer = NULL;
|
|
traceobj_unwind(trobj);
|
}
|
|
void traceobj_join(struct traceobj *trobj)
|
{
|
struct service svc;
|
|
CANCEL_DEFER(svc);
|
|
push_cleanup_lock(&trobj->lock);
|
read_lock(&trobj->lock);
|
|
while (trobj->nr_threads < 0 || trobj->nr_threads > 0)
|
threadobj_cond_wait(&trobj->join, &trobj->lock);
|
|
read_unlock(&trobj->lock);
|
pop_cleanup_lock(&trobj->lock);
|
|
CANCEL_RESTORE(svc);
|
}
|
