hc
2024-11-01 2f529f9b558ca1c1bd74be7437a84e4711743404
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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
/*
 * Copyright (C) 2011 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.
 */
#ifndef _BOILERPLATE_DEBUG_H
#define _BOILERPLATE_DEBUG_H
 
#include <stdint.h>
#include <stddef.h>
#include <xeno_config.h>
 
#ifdef CONFIG_XENO_DEBUG
 
#include <pthread.h>
#include <boilerplate/compiler.h>
 
static inline int must_check(void)
{
   return 1;
}
 
struct error_frame {
   int retval;
   int lineno;
   const char *fn;
   const char *file;
   struct error_frame *next;
};
 
struct backtrace_data {
   const char *name;
   struct error_frame *inner;
   pthread_mutex_t lock;
   char eundef[16];
};
 
#ifdef __cplusplus
extern "C" {
#endif
 
void backtrace_init_context(struct backtrace_data *btd,
               const char *name);
 
void backtrace_destroy_context(struct backtrace_data *btd);
 
void backtrace_dump(struct backtrace_data *btd);
 
void backtrace_log(int retval, const char *fn,
          const char *file, int lineno);
 
void backtrace_check(void);
 
void __debug(const char *name, const char *fmt, ...);
 
char *__get_error_buf(size_t *sizep);
 
void debug_init(void);
 
#ifdef __cplusplus
}
#endif
 
#define __bt(__exp)                        \
   ({                            \
       typeof(__exp) __ret = (__exp);            \
       if (__ret < 0)                    \
           backtrace_log((int)__ret, __FUNCTION__,    \
                     __FILE__, __LINE__);    \
       __ret;                        \
   })
 
#define __bterrno(__exp)                    \
   ({                            \
       typeof(__exp) __ret = (__exp);            \
       if (__ret < 0)                    \
           backtrace_log(-errno, __FUNCTION__,    \
                     __FILE__, __LINE__);    \
       __ret;                        \
   })
 
#else /* !CONFIG_XENO_DEBUG */
 
static inline int must_check(void)
{
   return 0;
}
 
struct backtrace_data {
};
 
#define __bt(__exp)            (__exp)
 
#define __bterrno(__exp)        (__exp)
 
#define backtrace_init_context(btd, name)    \
   do { (void)(btd); (void)(name); } while (0)
 
#define backtrace_destroy_context(btd)    \
   do { (void)(btd); } while (0)
 
#define backtrace_dump(btd)        \
   do { (void)(btd); } while (0)
 
#define backtrace_check()        \
   do { } while (0)
/*
 * XXX: We have no thread-private backtrace context in non-debug mode,
 * so there is a potential race if multiple threads want to write to
 * this buffer. This looks acceptable though, since this is primarily
 * a debug feature, and the race won't damage the system anyway.
 */
#define __get_error_buf(sizep)            \
   ({                    \
       static char __buf[16];        \
       *(sizep) = sizeof(__buf);    \
       __buf;                \
   })
 
#define debug_init()    do { } while (0)
 
#endif /* !CONFIG_XENO_DEBUG */
 
static inline int bad_pointer(const void *ptr)
{
   return ptr == NULL ||
       ((intptr_t)ptr & (intptr_t)(sizeof(intptr_t)-1)) != 0;
}
 
#endif /* _BOILERPLATE_DEBUG_H */