Index: tools/ev.c
===================================================================
--- tools/ev.c	(revision 572)
+++ tools/ev.c	(working copy)
@@ -35,6 +35,8 @@
 #include "fxt-tools.h"
 #include "fxt_internal.h"
 
+#define BLOCK_SIZE (4*1024)
+
 struct fxt_blockev {
 	/* fichier contenant les traces */
 	fxt_t fxt;
@@ -43,11 +45,18 @@
 	/* block disque contenant les événements */
 	struct fxt_block block;
 
+        /* current data block  */
+        uint8_t data[BLOCK_SIZE];
+        /* current position in the data block */
+        off_t   data_cur_pos;
+        /* size of the data block */
+        off_t   data_size;
+
 	/* position courante dans le fichier
 	 * A étoffer en lisant le fichier par block...
 	 */
 	off_t cur_pos;
-	
+
 	/* Données particulières pour chaque type de trace */
 	union {
 		struct {
@@ -61,6 +70,55 @@
 	};
 };
 
+/* read a block of data */
+int READ_BLOCK(fxt_blockev_t evs)
+{
+  int __res = -1;
+  __res = read(evs->fxt->fd, evs->data, BLOCK_SIZE);
+  if(__res >= 0) {
+    evs->data_size = __res;
+  }
+  evs->data_cur_pos = 0;
+  return __res;
+}
+
+#define BUFFERED_READ(evs, n, value) do {				\
+    uint##n##_t __val;							\
+    int res;								\
+    if(evs->data_cur_pos + sizeof(__val) > evs->data_size)		\
+      {									\
+	/* read a new block */						\
+	res = READ_BLOCK(evs);						\
+	if (res < 0) return -1;						\
+	if (res < sizeof(__val)) {					\
+	  errno = EINVAL;						\
+	  return -1;							\
+	}								\
+      }									\
+    __val = *(uint##n##_t*) &(evs->data[evs->data_cur_pos]);		\
+    evs->data_cur_pos += sizeof(__val);					\
+    SWAP(n,__val);							\
+    (value) = (typeof(value)) __val;					\
+  } while (0)
+
+#define BUFFERED_READRAW(evs, n,value) do {			\
+    uint##n##_t __val;						\
+    int res;							\
+    if(evs->data_cur_pos + sizeof(__val) > evs->data_size)	\
+      {								\
+	res = READ_BLOCK(evs);					\
+	if (res < 0) return -1;					\
+	if (res < sizeof(__val)) {				\
+	  errno = EINVAL;					\
+	  return -1;						\
+	}							\
+      }								\
+    (value) = *(uint##n##_t*) &evs->data[evs->data_cur_pos];	\
+    evs->data_cur_pos += sizeof(__val);				\
+  } while (0)
+
+
+
 static int fxt_fill_blockev(fxt_t fxt, fxt_blockev_t evs)
 {
 	off_t offset=0;
@@ -85,7 +143,6 @@
 		return -1;
 	}
 
-
 	switch (evs->type) {
 	case FXT_TRACE_KERNEL_RAW32:
 	case FXT_TRACE_KERNEL_RAW64:
@@ -123,6 +180,8 @@
 
 	if (fxt_fill_blockev(fxt, evs) < 0) goto outmalloc;
 
+	if( READ_BLOCK(evs) < 0 ) goto out;
+
 	return evs;
  outmalloc:
 	free(evs);
@@ -143,13 +202,16 @@
 	int ret=0;
 	struct fxt_ev_64 e;
 
-#define READEV_VAR(size, var) \
-   { READ(size, var); \
-     size_ev += size/8 ; \
-   }
-#define READEV(size, field) \
-   READEV_VAR(size, e.field)
+#define READEV_VAR(evs, size, var)		\
+	{					\
+	  BUFFERED_READ(evs, size, var);	\
+	  size_ev += size/8 ;			\
+	}
 
+#define READEV(evs, size, field)		\
+	READEV_VAR(evs, size, e.field)
+
+
 	switch (evs->type) {
 	case FXT_TRACE_KERNEL_RAW32:
 	case FXT_TRACE_KERNEL_RAW64:
@@ -157,12 +219,13 @@
 	case FXT_TRACE_USER_RAW64:
 		/* Est-on encore dans la trace ? */
 		if (evs->cur_pos >= evs->raw.end_data) {
+
 			/* Est-ce la fin ? */
 			if (evs->cur_pos!=0 && (evs->type == FXT_TRACE_USER_RAW32 ||
 						evs->type == FXT_TRACE_USER_RAW64)) {
 				return FXT_EV_EOT;
 			}
-						
+
 			/* On repositionne cur_pos */
 			evs->cur_pos = evs->raw.start_data+fxt->infos.page_size;
 			evs->raw.start_data=evs->cur_pos;
@@ -175,8 +238,7 @@
 			{
 				uint32_t u32;
 				int res;
-				res = read(fd, &u32, sizeof(u32));
-				SWAP(32,u32);
+				BUFFERED_READ(evs, 32, u32);
 				if (res < 0)
 					return -1;
 				if (res < sizeof(u32) /* FIXME: pas forcément fin de fichier */
@@ -198,20 +260,21 @@
 				evs->cur_pos += 32/8;
 			}
 			}
+			*(int*)0=0;
 		}
 		break;
-	default: NOT_MANAGED;		
+	default: NOT_MANAGED;
 	}
 
 	/* L'événement est présent, on peut le lire dans 'e' */
 	switch (evs->type) {
 	case FXT_TRACE_KERNEL_RAW32:
 	case FXT_TRACE_KERNEL_RAW64:
-		READEV(32,time);
+	  READEV(evs, 32,time);
 		break;
 	case FXT_TRACE_USER_RAW32:
 	case FXT_TRACE_USER_RAW64:
-		READEV(64,time);
+	  READEV(evs, 64,time);
 		break;
 	default:
 		NOT_MANAGED;
@@ -219,13 +282,13 @@
 
 	switch (evs->type) {
 	case FXT_TRACE_KERNEL_RAW32:
-		READEV(16, kernel.pid);
+	  READEV(evs, 16, kernel.pid);
 		break;
 	case FXT_TRACE_USER_RAW32:
-		READEV(32, user.tid);
+	  READEV(evs, 32, user.tid);
 		break;
 	case FXT_TRACE_USER_RAW64:
-		READEV(64, user.tid);
+	  READEV(evs, 64, user.tid);
 		break;
 	default:
 		NOT_MANAGED;
@@ -233,7 +296,7 @@
 
 	switch (evs->type) {
 	case FXT_TRACE_KERNEL_RAW32:
-		READEV(16, cpu);
+	  READEV(evs, 16, cpu);
 		break;
 	case FXT_TRACE_USER_RAW32:
 	case FXT_TRACE_USER_RAW64:
@@ -245,16 +308,17 @@
 	switch (evs->type) {
 	case FXT_TRACE_KERNEL_RAW32:
 	case FXT_TRACE_USER_RAW32:
-		READEV(32, code);
+	  READEV(evs, 32, code);
 		break;
 	case FXT_TRACE_KERNEL_RAW64:
 	case FXT_TRACE_USER_RAW64:
-		READEV(64, code);
+	  READEV(evs, 64, code);
+
 		break;
 	default:
 		NOT_MANAGED;
 	}
-	
+
 	/* calcul du nombre de paramètres */
 	switch (evs->type) {
 	case FXT_TRACE_KERNEL_RAW32:
@@ -300,7 +364,7 @@
 		case FXT_TRACE_KERNEL_RAW32:
 		case FXT_TRACE_USER_RAW32: {
 			uint32_t param;
-			READRAW(32,param);
+			BUFFERED_READRAW(evs, 32,param);
 			if ((i+1)*4<=FXT_MAX_DATA)
 				memcpy(&e.raw[i*4],&param,4);
 			if (i<FXT_MAX_PARAMS)
@@ -310,8 +374,8 @@
 		}
 		case FXT_TRACE_KERNEL_RAW64:
 		case FXT_TRACE_USER_RAW64: {
-			uint64_t param;
-			READRAW(64,param);
+		        uint64_t param;
+			BUFFERED_READRAW(evs, 64,param);
 			if ((i+1)*8<=FXT_MAX_DATA)
 				memcpy(&e.raw[i*8],&param,8);
 			if (i<FXT_MAX_PARAMS)