Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 532 → Rev 531

/shark/trunk/tracer/include/FTrace_OSD.h
5,8 → 5,12
 
#include <FTrace_types.h>
 
#define FTRACE_OSD_CHUNK_HEAD 24
#define FTRACE_OSD_CHUNK_HEAD 68
 
#define FTRACE_OSD_NEXT1 1
#define FTRACE_OSD_NEXT2 2
#define FTRACE_OSD_NEXT3 3
 
#define FTrace_printf cprintf
 
void FTrace_OSD_save_event(WORD type, WORD par1);
20,8 → 24,14
int FTrace_OSD_update_chunk_flags(FTrace_Chunk_Ptr c);
 
/* OSD Chunk Link */
int FTrace_OSD_chunk_link(FTrace_Chunk_Ptr a, FTrace_Chunk_Ptr b);
int FTrace_OSD_chunk_link(FTrace_Chunk_Ptr a, FTrace_Chunk_Ptr b, int osd_flags);
 
/* OSD Save Global Pointers */
int FTrace_OSD_save_pointers();
 
/* OSD Load Global Pointers */
int FTrace_OSD_load_pointers();
 
/* OSD Chunk compress function */
int FTrace_OSD_compress_chunk(int number, void *temp_data, int *data_size);
 
/shark/trunk/tracer/include/FTrace_chunk.h
20,8 → 20,8
int FTrace_enable();
int FTrace_disable();
 
/* Create a chunk of specified size (normal/emergency) */
int FTrace_chunk_create(int normal_size, int emergency_size, FTrace_flags flags);
/* Create n chunks of specified size (normal/emergency) */
int FTrace_chunk_create(int n, int normal_size, int emergency_size, FTrace_flags flags);
 
/* Delete a Chunk */
int FTrace_chunk_delete(int number);
36,7 → 36,7
int FTrace_actual_chunk_select(int number);
 
/* Link two chunks */
int FTrace_chunk_link(int chunk_A, int chunk_B);
int FTrace_chunk_link(int chunk_A, int chunk_B, int osd_flags);
 
/* Find the first chunk with specific flags*/
int FTrace_get_first_chunk(FTrace_flags flags);
/shark/trunk/tracer/newtrace/FTrace_OSD_ll.c
5,23 → 5,38
 
/* OSD_pointers
 
00 - Actual Chunk Position
04 - Actual Chunk Start
08 - Actual Chunk Size
12 - Actual Chunk Emergency Size
16 - Actual Chunk Flags
00 - Next pointer
 
20 - Next OSD pointer
04 - Actual Chunk Position
08 - Actual Chunk Start
12 - Actual Chunk Size
16 - Actual Chunk Emergency Size
20 - Actual Chunk Flags
 
24 - Next1 Chunk Position
28 - Next1 Chunk Start
32 - Next1 Chunk Size
36 - Next1 Chunk Emergency Size
40 - Next1 Chunk Flags
 
44 - Next1 Chunk Position
48 - Next1 Chunk Start
52 - Next1 Chunk Size
56 - Next1 Chunk Emergency Size
60 - Next1 Chunk Flags
 
64 - Fast_Access
 
*/
 
void FTrace_safe_ipoint(WORD type, WORD par1, DWORD par2)
{
 
extern void *OSD_current_pointer;
extern BYTE OSD_pointers[FTRACE_OSD_CHUNK_HEAD];
extern BYTE FTrace_enable;
 
DWORD tsclow, tschigh;
DWORD next;
DWORD current;
DWORD start;
DWORD size;
33,10 → 48,11
 
if (FTrace_enable) {
 
current = *(DWORD *)(OSD_current_pointer);
start = *(DWORD *)(OSD_current_pointer + 4);
size = *(DWORD *)(OSD_current_pointer + 8);
flags = *(DWORD *)(OSD_current_pointer + 16);
next = *(DWORD *)(OSD_pointers);
current = *(DWORD *)(OSD_pointers + next);
start = *(DWORD *)(OSD_pointers + next + 4);
size = *(DWORD *)(OSD_pointers + next + 8);
flags = *(DWORD *)(OSD_pointers + next + 16);
 
if (current == NULL) {
ll_frestore(f);
55,11 → 71,10
if ((flags & 0x0C) == FTRACE_CHUNK_FLAG_CYC) {
current = start;
} else {
*(DWORD *)(OSD_current_pointer + 16) |= FTRACE_CHUNK_FLAG_FULL;
*(WORD *)(OSD_pointers + next + 16) |= FTRACE_CHUNK_FLAG_FULL;
if ((flags & 0x0C) == FTRACE_CHUNK_FLAG_JTN) {
OSD_current_pointer = (void *)(*(DWORD *)(OSD_current_pointer + 20));
ll_frestore(f);
return;
*(DWORD *)(OSD_pointers) += 20;
next = *(DWORD *)(OSD_pointers);
}
}
}
68,19 → 83,18
"rdtsc\n\t"
: "=a" (tsclow), "=d" (tschigh) : : "ecx","ebx");
*(DWORD *)current = (DWORD)(par1 << 16 | type);
*(DWORD *)current = (DWORD)(type << 16 | par1);
*(DWORD *)(current + 4) = tschigh;
*(DWORD *)(current + 8) = tsclow;
*(DWORD *)(current + 16) = par2;
 
*(DWORD *)(OSD_current_pointer) = current + 16;
*(DWORD *)(OSD_pointers + 64) = *(DWORD *)(OSD_pointers + next) = current + 16;
 
} else {
 
*(WORD *)(OSD_current_pointer + 16) |= FTRACE_CHUNK_FLAG_FULL;
OSD_current_pointer = (void *)(*(DWORD *)(OSD_current_pointer + 20));
ll_frestore(f);
return;
*(WORD *)(OSD_pointers + next + 16) |= FTRACE_CHUNK_FLAG_FULL;
*(DWORD *)(OSD_pointers) += 20;
*(DWORD *)(OSD_pointers + 64) = *(DWORD *)(OSD_pointers + *(DWORD *)(OSD_pointers) + 4); //Fast Access
 
}
 
106,7 → 120,7
"movl %%eax,12(%%ebx)\n\t" /* DWORD par2 */
"addl $16,(%%edi)\n\t" /* Inc Position */
"popfl\n\t"
:: "D" ((DWORD *)(OSD_pointers)), "S" (par1 << 16 | (type | 0x8000)));
:: "D" ((DWORD *)(OSD_pointers+64)), "S" ((type | 0x8000) << 16 | par1));
 
}
 
/shark/trunk/tracer/newtrace/FTrace.c
9,8 → 9,8
FTrace_Chunk_Ptr ChunkTable[MAX_CHUNK]; /* Chunk array */
FTrace_Chunk_Ptr ActualChunk = NULL; /* Actual Chunk */
 
/* OSD Pointer */
void *OSD_current_pointer;
/* Global Pointers */
BYTE OSD_pointers[FTRACE_OSD_CHUNK_HEAD];
 
int FTraceInit = 0;
int FTraceEnable = 0;
63,7 → 63,7
 
FTrace_lock();
 
OSD_current_pointer = NULL;
memset(OSD_pointers,0,sizeof(OSD_pointers));
 
for (i = 0;i < MAX_CHUNK;i++)
ChunkTable[i] = NULL;
114,11 → 114,11
}
 
int FTrace_chunk_create(int size, int emergency_size, FTrace_flags flags)
int FTrace_chunk_create(int n, int size, int emergency_size, FTrace_flags flags)
{
 
FTrace_Chunk_Ptr FT_temp;
int number, err;
int i, number, err;
 
FTrace_lock();
 
133,44 → 133,48
}
}
 
number = FTrace_find_free_slot();
if (number == -1) {
#ifdef FTRACE_DEBUG
FTrace_printf("FTrace Error: cannot find free slot for chunk\n");
#endif
FTrace_unlock();
return -1;
}
for (i = 0;i < n;i++) {
 
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");
#endif
FTrace_unlock();
return -1;
}
number = FTrace_find_free_slot();
if (number == -1) {
#ifdef FTRACE_DEBUG
FTrace_printf("FTrace Error: cannot find free slot for chunk\n");
#endif
FTrace_unlock();
return -1;
}
 
memset(FT_temp,0,sizeof(struct FTrace_Chunk) + FTRACE_OSD_CHUNK_HEAD + size + emergency_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");
#endif
FTrace_unlock();
return -1;
}
 
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");
#endif
FTrace_unlock();
return -1;
}
memset(FT_temp,0,sizeof(struct FTrace_Chunk) + FTRACE_OSD_CHUNK_HEAD + size + emergency_size);
 
/* Set the ChunkTable */
ChunkTable[number] = FT_temp;
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");
#endif
FTrace_unlock();
return -1;
}
 
#ifdef FTRACE_DEBUG
FTrace_printf("FTrace Debug: Chunk %d created at addr %x\n",number,(int)FT_temp);
#endif
/* Set the ChunkTable */
ChunkTable[number] = FT_temp;
 
#ifdef FTRACE_DEBUG
FTrace_printf("FTrace Debug: Chunk %d created at addr %x\n",number,(int)FT_temp);
#endif
 
}
 
FTrace_unlock();
return number;
return 0;
 
}
 
265,11 → 269,9
FTrace_unlock();
return -1;
}
FTrace_OSD_update_chunk_flags(FT_temp); *flags = FT_temp->flags;
 
FTrace_unlock();
 
*flags = FT_temp->flags;
return 0;
}
306,8 → 308,9
 
/* Update the actual_chunk and OSD_pointers */
FTrace_fsave();
FTrace_OSD_save_pointers();
ActualChunk = FT_temp;
OSD_current_pointer = (void *)FT_temp->osd;
FTrace_OSD_load_pointers();
FTrace_frestore();
 
} else {
366,7 → 369,7
}
 
/* Link two chunks */
int FTrace_chunk_link(int chunk_A, int chunk_B)
int FTrace_chunk_link(int chunk_A, int chunk_B, int osd_flags)
{
 
FTrace_Chunk_Ptr ckA = ChunkTable[chunk_A];
412,7 → 415,9
 
/* FTrace Low Level Blocking Part */
FTrace_fsave();
err = FTrace_OSD_chunk_link(ckA,ckB);
FTrace_OSD_save_pointers();
 
err = FTrace_OSD_chunk_link(ckA,ckB,osd_flags);
if (err != 0) {
#ifdef FTRACE_DEBUG
FTrace_printf("FTrace Error: Cannot link the chunks\n");
419,6 → 424,8
#endif
return -1;
}
 
FTrace_OSD_load_pointers();
FTrace_frestore();
 
FTrace_unlock();
427,6 → 434,25
 
}
 
/* Update the OSD of actual chunk */
int FTrace_update_actual_chunk()
{
 
FTrace_lock();
 
if (ActualChunk == NULL) return 0;
 
FTrace_fsave();
FTrace_OSD_save_pointers();
FTrace_frestore();
 
FTrace_unlock();
 
return 0;
 
}
 
/* Create a new memory region where the compressed data are stored */
int FTrace_compress_chunk(int number, FTrace_flags new_flags)
{
555,7 → 581,11
void FTrace_chunk_dump(int number) {
 
FTrace_Chunk_Ptr FT_temp = ChunkTable[number];
int i,t;
DWORD p;
 
FTrace_update_actual_chunk();
 
cprintf("ID = %x\n",FT_temp->id);
cprintf("NUM = %d\n",FT_temp->number);
cprintf("FLAGS = %d\n",FT_temp->flags);
562,5 → 592,25
cprintf("SIZE = %d\n",FT_temp->size);
cprintf("EMERG = %d\n",FT_temp->emergency_size);
 
for (i=0; i<0xFF; i++) {
p = *(DWORD *)(FT_temp->osd + 8);
t = 0;
while((p + 16) < *(DWORD *)(FT_temp->osd + 8) + *(DWORD *)(FT_temp->osd + 12)) {
if (*(WORD *)(p+2) == i) t++;
p += 16;
}
if (t != 0)
cprintf("Event type %02x => %d\n",i,t);
}
}
 
void FTrace_OSD_dump() {
void *p = OSD_pointers;
int i;
 
for (i=0;i<FTRACE_OSD_CHUNK_HEAD;i+=4)
cprintf("DATA %d = %x\n",i,*(unsigned int *)(p+i));
 
}
/shark/trunk/tracer/newtrace/FTrace_OSD.c
8,7 → 8,7
SYS_FLAGS FTracef;
 
extern FTrace_Chunk_Ptr ActualChunk;
extern void *OSD_current_pointer;
extern BYTE OSD_pointers[FTRACE_OSD_CHUNK_HEAD];
 
void FTrace_fsave()
{
56,9 → 56,7
}
 
/* OSD_pointers
 
00 - Fast Access
04 - Actual Chunk Position
08 - Actual Chunk Start
12 - Actual Chunk Size
65,7 → 63,11
16 - Actual Chunk Emergency Size
20 - Actual Chunk Flags
24 - Next Chunk OSD Pointer
24 - Next1 Chunk Position
28 - Next1 Chunk Start
32 - Next1 Chunk Size
36 - Next1 Chunk Emergency Size
40 - Next1 Chunk Flags
*/
 
72,7 → 74,7
int FTrace_OSD_chunk_init(FTrace_Chunk_Ptr c, int size, int emergency_size, FTrace_flags flags)
{
 
*(DWORD *)(c->osd) = (DWORD)(c->osd + FTRACE_OSD_CHUNK_HEAD);
*(DWORD *)(c->osd) = 4;
 
*(DWORD *)(c->osd + 4) = (DWORD)(c->osd + FTRACE_OSD_CHUNK_HEAD);
*(DWORD *)(c->osd + 8) = (DWORD)(c->osd + FTRACE_OSD_CHUNK_HEAD);
81,17 → 83,36
*(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 + 44) = 0;
*(DWORD *)(c->osd + 48) = 0;
*(DWORD *)(c->osd + 52) = 0;
*(DWORD *)(c->osd + 56) = 0;
*(DWORD *)(c->osd + 60) = 0;
 
return 0;
 
}
 
/* OSD Chunk Link */
int FTrace_OSD_chunk_link(FTrace_Chunk_Ptr a, FTrace_Chunk_Ptr b)
int FTrace_OSD_chunk_link(FTrace_Chunk_Ptr a, FTrace_Chunk_Ptr b, int osd_flags)
{
 
*(DWORD *)(a->osd + 24) = (DWORD)(b->osd);
int delta = 0;
 
if (osd_flags == FTRACE_OSD_NEXT1)
delta = 24;
if (osd_flags == FTRACE_OSD_NEXT2)
delta = 44;
 
if (delta == 0) return -1;
 
memcpy((void *)(a->osd+delta),(void *)(b->osd+4),20);
 
return 0;
 
}
105,6 → 126,28
 
}
 
int FTrace_OSD_load_pointers()
{
 
if (ActualChunk == NULL) return -1;
 
memcpy((void *)OSD_pointers,(void *)ActualChunk->osd,FTRACE_OSD_CHUNK_HEAD);
 
return 0;
 
}
 
int FTrace_OSD_save_pointers()
{
 
if (ActualChunk == NULL) return -1;
memcpy((void *)ActualChunk->osd,(void *)OSD_pointers,FTRACE_OSD_CHUNK_HEAD);
return 0;
}
 
int FTrace_OSD_compress_chunk(int number, void *temp_data, int *data_size)
{