Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 500 → Rev 501

/shark/trunk/tracer/newtrace/FTrace_OSD_ll.c
1,35 → 1,91
#include <FTrace_types.h>
#include <FTrace_OSD.h>
 
#include <ll/i386/hw-instr.h>
 
/* OSD_pointers
 
00 - Actual Chunk Event Pointer Delta
04 - Actual Chunk Mask
00 - Next pointer
 
04 - Actual Chunk Position
08 - Actual Chunk Start
12 - Actual Chunk Flags
16 - Actual Chunk Fast-Access-Pointer
12 - Actual Chunk Size
16 - Actual Chunk Emergency Size
20 - Actual Chunk Flags
 
20 - Delta (0 Actual, 24 Next)
24 - Next1 Chunk Event Pointer Delta
28 - Next1 Chunk Mask
32 - Next1 Chunk Start
36 - Next1 Chunk Flags
40 - Next1 Chunk Fast-Access-Pointer
44 - Delta
24 - Next1 Chunk Position
28 - Next1 Chunk Start
32 - Next1 Chunk Size
36 - Next1 Chunk Emergency Size
60 - Next1 Chunk Flags
 
*/
 
void FTrace_safe_ipoint(DWORD type, DWORD par1, DOWRD par2)
void FTrace_safe_ipoint(WORD type, WORD par1, DWORD par2)
{
 
extern BYTE OSD_pointers[FTRACE_OSD_CHUNK_HEAD];
extern BYTE FTrace_enable;
 
DWORD tsclow, tschigh;
DWORD next = *(DWORD *)(OSD_pointers);
DWORD current = *(DWORD *)(OSD_pointers + next);
DWORD start = *(DWORD *)(OSD_pointers + next + 4);
DWORD size = *(DWORD *)(OSD_pointers + next + 8);
DWORD flags = *(DWORD *)(OSD_pointers + next + 16);
SYS_FLAGS f;
 
if (FTrace_enable) {
 
f = ll_fsave();
 
if (type != FTrace_EVT_next_chunk) {
 
if ((flags & FTRACE_CHUNK_FLAG_FULL) == FTRACE_CHUNK_FLAG_FULL) {
ll_frestore(f);
return;
}
 
/* Cyclical Buffer */
if (current + 16 >= (start + size)) {
if ((flags & 0x0C) == FTRACE_CHUNK_FLAG_CYC) {
current = start;
} else {
*(WORD *)(OSD_pointers + next + 16) &= FTRACE_CHUNK_FLAG_FULL;
if ((flags & 0x0C) == FTRACE_CHUNK_FLAG_JTN) {
*(DWORD *)(OSD_pointers) += 20;
next = *(DWORD *)(OSD_pointers);
}
}
}
 
__asm__("cpuid\n\t"
"rdtsc\n\t"
: "=a" (tsclow), "=b" (tschigh) : : "ecx","edx");
*(DWORD *)current = (DWORD)(type << 16 | par1);
*(DWORD *)(current + 4) = tschigh;
*(DWORD *)(current + 8) = tsclow;
*(DWORD *)(current + 16) = par2;
 
*(DWORD *)(OSD_pointers + next) = current + 16;
 
} else {
 
*(WORD *)(OSD_pointers + next + 16) &= FTRACE_CHUNK_FLAG_FULL;
if ((flags & 0x0C) == FTRACE_CHUNK_FLAG_JTN)
*(DWORD *)(OSD_pointers) += 20;
 
}
 
ll_frestore(f);
}
 
}
 
void FTrace_unsafe_ipoint(DWORD type, DWORD par1, DWORD par2)
void FTrace_unsafe_ipoint(WORD type, WORD par1)
{
 
extern BYTE OSD_pointers[FTRACE_OSD_CHUNK_HEAD];
38,12 → 94,13
"cli\n\t"
"cpuid\n\t"
"rdtsc\n\t"
"movl %%esi,(%%edi)\n\t" /* Save TYPE + WORD par2 */
"movl %%edx,4(%%edi)\n\t" /* Save TSC HIGH */
"movl %%eax,8(%%edi)\n\t" /* Save TSC LOW */
"addl $12,(%%edi)\n\t" /* Inc Fast-Access-Pointer */
"movl (%%edi),%%ebx\n\t"
"movl %%esi,(%%ebx)\n\t" /* Save TYPE + WORD par1 */
"movl %%edx,4(%%ebx)\n\t" /* Save TSC HIGH */
"movl %%eax,8(%%ebx)\n\t" /* Save TSC LOW */
"addl $12,(%%edi)\n\t" /* Inc Position */
"popfl\n\t"
:: "D" (*(DWORD * )(OSD_pointers+16)), "S" (type));
:: "D" ((DWORD *)(OSD_pointers)), "S" ((type | 0x8000) << 16 | par1));
 
}
 
/shark/trunk/tracer/newtrace/FTrace.c
23,10 → 23,10
c->number = number; /* Chunk number */
c->flags = flags; /* Chunk flags */
c->size = size; /* Chunk size */
c->emergency_size = emergency_size; /* Chunk size */
c->emergency_size = emergency_size; /* Chunk emergency size */
c->osd = (DWORD)((DWORD)(c) + sizeof(struct FTrace_Chunk));
return FTrace_OSD_chunk_init(c, size, flags);
return FTrace_OSD_chunk_init(c, size, emergency_size, flags);
 
}
 
114,12 → 114,11
}
 
/* Create n chunks of specified size, where size = 2^bits */
int FTrace_chunk_create(int n, int bits, FTrace_flags flags)
int FTrace_chunk_create(int n, int size, int emergency_size, FTrace_flags flags)
{
 
FTrace_Chunk_Ptr FT_temp;
int i, number, err, size;
int i, number, err;
 
FTrace_lock();
 
134,9 → 133,6
}
}
 
/* Get size */
size = 1 << bits;
 
for (i = 0;i < n;i++) {
 
number = FTrace_find_free_slot();
148,7 → 144,7
return -1;
}
 
FT_temp = (FTrace_Chunk_Ptr)FTrace_malloc(sizeof(struct FTrace_Chunk) + FTRACE_OSD_CHUNK_HEAD + size);
FT_temp = (FTrace_Chunk_Ptr)FTrace_malloc(sizeof(struct FTrace_Chunk) + FTRACE_OSD_CHUNK_HEAD + size + emergency_size);
if (FT_temp == NULL) {
#ifdef FTRACE_DEBUG
FTrace_printf("FTrace Error: cannot allocate memory for chunk\n");
157,7 → 153,7
return -1;
}
 
err = FTrace_chunk_init(FT_temp, number, size, flags);
err = FTrace_chunk_init(FT_temp, number, size, emergency_size, flags);
if (err != 0) {
#ifdef FTRACE_DEBUG
FTrace_printf("FTrace Error: cannot initialized the new chunk\n");
464,7 → 460,7
FTrace_unlock();
 
/* Alloc temp memory for */
temp_data = (void *)FTrace_malloc(FT_temp->sizemask+1);
temp_data = (void *)FTrace_malloc(FT_temp->size+FT_temp->emergency_size);
if (temp_data == NULL) {
#ifdef FTRACE_DEBUG
FTrace_printf("FTrace Error: Cannot allocate memory\n");
/shark/trunk/tracer/newtrace/FTrace_OSD.c
55,26 → 55,44
 
}
 
int FTrace_OSD_chunk_init(FTrace_Chunk_Ptr c, int size, FTrace_flags flags)
/* OSD_pointers
00 - Actual Chunk Position
04 - Actual Chunk Start
08 - Actual Chunk Size
12 - Actual Chunk Emergency Size
16 - Actual Chunk Flags
20 - Next1 Chunk Position
24 - Next1 Chunk Start
28 - Next1 Chunk Size
32 - Next1 Chunk Emergency Size
36 - Next1 Chunk Flags
*/
 
int FTrace_OSD_chunk_init(FTrace_Chunk_Ptr c, int size, int emergency_size, FTrace_flags flags)
{
 
*(DWORD *)(c->osd) = 0;
*(DWORD *)(c->osd + 4) = (DWORD)(c->sizemask);
*(DWORD *)(c->osd + 8) = (DWORD)(c->osd + 60);
*(DWORD *)(c->osd + 12) = 0;
*(DWORD *)(c->osd + 16) = 0;
*(DWORD *)(c->osd) = 4;
 
*(DWORD *)(c->osd + 20) = 0;
*(DWORD *)(c->osd + 4) = (DWORD)(c->osd + FTRACE_OSD_CHUNK_HEAD);
*(DWORD *)(c->osd + 8) = (DWORD)(c->osd + FTRACE_OSD_CHUNK_HEAD);
*(DWORD *)(c->osd + 12) = (DWORD)(c->size);
*(DWORD *)(c->osd + 16) = (DWORD)(c->emergency_size);
*(DWORD *)(c->osd + 20) = (DWORD)(c->flags);
 
*(DWORD *)(c->osd + 24) = 0;
*(DWORD *)(c->osd + 28) = 0;
*(DWORD *)(c->osd + 32) = 0;
*(DWORD *)(c->osd + 36) = 0;
*(DWORD *)(c->osd + 40) = 0;
 
*(DWORD *)(c->osd + 40) = 0;
*(DWORD *)(c->osd + 44) = 0;
*(DWORD *)(c->osd + 48) = 0;
*(DWORD *)(c->osd + 52) = 0;
*(DWORD *)(c->osd + 56) = 0;
*(DWORD *)(c->osd + 60) = 0;
 
return 0;
 
87,9 → 105,9
int delta = 0;
 
if (osd_flags == FTRACE_OSD_NEXT1)
delta = 20;
delta = 24;
if (osd_flags == FTRACE_OSD_NEXT2)
delta = 40;
delta = 44;
 
if (delta == 0) return -1;