~lttng/lttng-ust/lttng-ust

« back to all changes in this revision

Viewing changes to include/ust/kernelcompat.h

  • Committer: Pierre-Marc Fournier
  • Date: 2009-10-27 22:58:15 UTC
  • mfrom: (232.1.5)
  • Revision ID: git-v1:aa08b4413291fabcbd1b1144377d37034ad361de
Merge branch 'for-pierre-marc' of git://git.infradead.org/users/jblunck/ust

Fixed conflicts:
        include/ust/marker.h

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
#ifndef KERNELCOMPAT_H
 
2
#define KERNELCOMPAT_H
 
3
 
 
4
#include <kcompat.h>
 
5
 
 
6
#include <string.h>
 
7
#include <sys/time.h>
 
8
 
 
9
/* FIXME: libkcompat must not define arch-specific local ops, as ust *must*
 
10
 * fallback to the normal atomic ops. Fix things so we don't add them and
 
11
 * break things accidentally.
 
12
 */
 
13
 
 
14
#define container_of(ptr, type, member) ({                      \
 
15
        const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
 
16
        (type *)( (char *)__mptr - offsetof(type,member) );})
 
17
 
 
18
#define KERN_DEBUG ""
 
19
#define KERN_NOTICE ""
 
20
#define KERN_INFO ""
 
21
#define KERN_ERR ""
 
22
#define KERN_ALERT ""
 
23
#define KERN_WARNING ""
 
24
 
 
25
/* ERROR OPS */
 
26
 
 
27
#define MAX_ERRNO       4095
 
28
 
 
29
#define IS_ERR_VALUE(x) unlikely((x) >= (unsigned long)-MAX_ERRNO)
 
30
 
 
31
static inline void *ERR_PTR(long error)
 
32
{
 
33
        return (void *) error;
 
34
}
 
35
 
 
36
static inline long PTR_ERR(const void *ptr)
 
37
{
 
38
        return (long) ptr;
 
39
}
 
40
 
 
41
static inline long IS_ERR(const void *ptr)
 
42
{
 
43
        return IS_ERR_VALUE((unsigned long)ptr);
 
44
}
 
45
 
 
46
 
 
47
/* Min / Max */
 
48
 
 
49
#define min_t(type, x, y) ({                    \
 
50
        type __min1 = (x);                      \
 
51
        type __min2 = (y);                      \
 
52
        __min1 < __min2 ? __min1: __min2; })
 
53
 
 
54
#define max_t(type, x, y) ({                    \
 
55
        type __max1 = (x);                      \
 
56
        type __max2 = (y);                      \
 
57
        __max1 > __max2 ? __max1: __max2; })
 
58
 
 
59
 
 
60
/* MUTEXES */
 
61
 
 
62
#include <pthread.h>
 
63
 
 
64
#define DEFINE_MUTEX(m) pthread_mutex_t (m) = PTHREAD_MUTEX_INITIALIZER;
 
65
#define DECLARE_MUTEX(m) extern pthread_mutex_t (m);
 
66
 
 
67
#define mutex_lock(m) pthread_mutex_lock(m)
 
68
 
 
69
#define mutex_unlock(m) pthread_mutex_unlock(m)
 
70
 
 
71
 
 
72
/* MALLOCATION */
 
73
 
 
74
#include <stdlib.h>
 
75
 
 
76
#define kmalloc(s, t) malloc(s)
 
77
#define kzalloc(s, t) zmalloc(s)
 
78
#define kfree(p) free((void *)p)
 
79
#define kstrdup(s, t) strdup(s)
 
80
 
 
81
#define zmalloc(s) calloc(1, s)
 
82
 
 
83
#define GFP_KERNEL
 
84
 
 
85
/* PRINTK */
 
86
 
 
87
#include <stdio.h>
 
88
#define printk(fmt, args...) printf(fmt, ## args)
 
89
 
 
90
 
 
91
/* ATTRIBUTES */
 
92
 
 
93
#define ____cacheline_aligned
 
94
 
 
95
/* MATH */
 
96
 
 
97
static inline unsigned int hweight32(unsigned int w)
 
98
{
 
99
        unsigned int res = w - ((w >> 1) & 0x55555555);
 
100
        res = (res & 0x33333333) + ((res >> 2) & 0x33333333);
 
101
        res = (res + (res >> 4)) & 0x0F0F0F0F;
 
102
        res = res + (res >> 8);
 
103
        return (res + (res >> 16)) & 0x000000FF;
 
104
}
 
105
 
 
106
static inline int fls(int x)
 
107
{
 
108
        int r;
 
109
//ust// #ifdef CONFIG_X86_CMOV
 
110
        asm("bsrl %1,%0\n\t"
 
111
            "cmovzl %2,%0"
 
112
            : "=&r" (r) : "rm" (x), "rm" (-1));
 
113
//ust// #else
 
114
//ust//         asm("bsrl %1,%0\n\t"
 
115
//ust//             "jnz 1f\n\t"
 
116
//ust//             "movl $-1,%0\n"
 
117
//ust//             "1:" : "=r" (r) : "rm" (x));
 
118
//ust// #endif
 
119
        return r + 1;
 
120
}
 
121
 
 
122
static __inline__ int get_count_order(unsigned int count)
 
123
{
 
124
        int order;
 
125
        
 
126
        order = fls(count) - 1;
 
127
        if (count & (count - 1))
 
128
                order++;
 
129
        return order;
 
130
}
 
131
 
 
132
 
 
133
 
 
134
 
 
135
#include <unistd.h>
 
136
 
 
137
#define ALIGN(x,a)              __ALIGN_MASK(x,(typeof(x))(a)-1)
 
138
#define __ALIGN_MASK(x,mask)    (((x)+(mask))&~(mask))
 
139
#define PAGE_ALIGN(addr) ALIGN(addr, PAGE_SIZE)
 
140
#define PAGE_SIZE sysconf(_SC_PAGE_SIZE)
 
141
#define PAGE_MASK (~(PAGE_SIZE-1))
 
142
 
 
143
 
 
144
 
 
145
 
 
146
/* ARRAYS */
 
147
 
 
148
#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
 
149
 
 
150
/* TRACE CLOCK */
 
151
 
 
152
/* There are two types of clocks that can be used.
 
153
   - TSC based clock
 
154
   - gettimeofday() clock
 
155
 
 
156
   Microbenchmarks on Linux 2.6.30 on Core2 Duo 3GHz (functions are inlined):
 
157
     Calls (100000000) to tsc(): 4004035641 cycles or 40 cycles/call
 
158
     Calls (100000000) to gettimeofday(): 9723158352 cycles or 97 cycles/call
 
159
 
 
160
   For merging traces with the kernel, a time source compatible with that of
 
161
   the kernel is necessary.
 
162
 
 
163
*/
 
164
 
 
165
#if 0
 
166
/* WARNING: Make sure to set frequency and scaling functions that will not
 
167
 * result in lttv timestamps (sec.nsec) with seconds greater than 2**32-1.
 
168
 */
 
169
static inline u64 trace_clock_read64(void)
 
170
{
 
171
        uint32_t low;
 
172
        uint32_t high;
 
173
        uint64_t retval;
 
174
        __asm__ volatile ("rdtsc\n" : "=a" (low), "=d" (high));
 
175
 
 
176
        retval = high;
 
177
        retval <<= 32;
 
178
        return retval | low;
 
179
}
 
180
#endif
 
181
 
 
182
static inline u64 trace_clock_read64(void)
 
183
{
 
184
        struct timeval tv;
 
185
        u64 retval;
 
186
 
 
187
        gettimeofday(&tv, NULL);
 
188
        retval = tv.tv_sec;
 
189
        retval *= 1000000;
 
190
        retval += tv.tv_usec;
 
191
 
 
192
        return retval;
 
193
}
 
194
 
 
195
static inline u64 trace_clock_frequency(void)
 
196
{
 
197
        return 1000000LL;
 
198
}
 
199
 
 
200
static inline u32 trace_clock_freq_scale(void)
 
201
{
 
202
        return 1;
 
203
}
 
204
 
 
205
 
 
206
#endif /* KERNELCOMPAT_H */