perftool/cpel_util.c - fdio/vpp - Gitiles

 /*
  *------------------------------------------------------------------
  * Copyright (c) 2006-2016 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 #include <stdio.h>
 #include <stdlib.h>
 #include <netinet/in.h>
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <sys/fcntl.h>
 #include <sys/mman.h>
 #include <unistd.h>
 #include <ctype.h>
 #include <vppinfra/clib.h>
 #include <vppinfra/vec.h>
 #include <vppinfra/hash.h>
 #include <vppinfra/bitmap.h>
 #include <vppinfra/byte_order.h>
 #include <pwd.h>
 #include <stdarg.h>
 #include <time.h>
 #include "cpel.h"
 #include "cpel_util.h"

 evt_t *the_events;

 track_t *the_tracks;
 u32 *track_alpha_map;

 event_definition_t *the_event_definitions;
 i64 min_timestamp;

 /* Hash tables, used to find previous instances of the same items */
 uword *the_track_hash;
 uword *the_msg_event_hash;
 uword *the_strtab_hash;
 uword *the_pidtid_hash;
 uword *the_pid_to_name_hash;
 u8 *the_strtab;

 uword *the_event_id_bitmap;

 /*
  * find_or_add_strtab
  * Finds or adds a string to the string table
  */
 u32 find_or_add_strtab(void *s_arg)
 {
     uword *p;
     int len;
     u8 *this_string;
     u8 *scopy=0;
     char *s = s_arg;

     p = hash_get_mem(the_strtab_hash, s);
     if (p) {
         return (p[0]);
     }

     /*
      * Here's a CLIB bear-trap. We can't add the string-table
      * strings to the to the hash table (directly), since it
      * expands and moves periodically. All of the hash table
      * entries turn into dangling references, yadda yadda.
      */

     len = strlen(s)+1;
     vec_add2(the_strtab, this_string, len);
     memcpy(this_string, s, len);

     /* Make a copy which won't be moving around... */
     vec_validate(scopy, len);
     memcpy(scopy, s, len);

     hash_set_mem(the_strtab_hash, scopy, this_string - the_strtab);

     return(this_string - the_strtab);
 }

 /*
  * find_or_add_track
  * returns index in track table
  */
 u32 find_or_add_track(void *s_arg)
 {
     uword *p;
     track_t *this_track;
     u8 *copy_s;
     char *s=s_arg;

     p = hash_get_mem(the_track_hash, s);
     if (p) {
         return (p[0]);
     }
     vec_add2(the_tracks, this_track, 1);

     this_track->original_index = this_track - the_tracks;
     this_track->strtab_offset = find_or_add_strtab(s);

     copy_s = (u8 *)vec_dup(s);

     hash_set_mem(the_track_hash, copy_s, this_track - the_tracks);
     return(this_track - the_tracks);
 }

 /*
  * find_or_add_event
  * Adds an event to the event definition vector and add it to
  * the event hash table
  */

 u32 find_or_add_event(void *s_arg, char *datum_format)
 {
     uword *p;
     u8 *copy_s;
     event_definition_t *this_event_definition;
     u32 event_id;
     char *s=s_arg;

     p = hash_get_mem(the_msg_event_hash, s);
     if (p) {
         return (p[0]);
     }
     vec_add2(the_event_definitions, this_event_definition, 1);

     /* Allocate a new event-id */
     event_id = clib_bitmap_first_clear (the_event_id_bitmap);
     the_event_id_bitmap = clib_bitmap_set(the_event_id_bitmap, event_id, 1);
     this_event_definition->event = event_id;
     this_event_definition->event_format = find_or_add_strtab(s);
     this_event_definition->datum_format = find_or_add_strtab(datum_format);

     copy_s = (u8 *)vec_dup(s);

     hash_set_mem(the_msg_event_hash, copy_s, event_id);

     return(event_id);
 }

 /*
  * write_string_table
  */
 int write_string_table(FILE *ofp)
 {
     cpel_section_header_t sh;

     /* Round up string table size */
     while (vec_len(the_strtab) & 0x7)
         vec_add1(the_strtab, 0);

     sh.section_type = ntohl(CPEL_SECTION_STRTAB);
     sh.data_length = ntohl(vec_len(the_strtab));

     if (fwrite(&sh, sizeof(sh), 1, ofp) != 1)
         return(0);

     if (fwrite(the_strtab, 1, vec_len(the_strtab), ofp) !=
         vec_len(the_strtab))
         return(0);

     return(1);
 }

 /*
  * write_cpel_header
  */
 int write_cpel_header(FILE *ofp, u32 nsections)
 {
     cpel_file_header_t h;

     h.endian_version = CPEL_FILE_VERSION;
     h.pad = 0;
     h.nsections = ntohs(nsections);
     h.file_date = ntohl(time(0));
     if (fwrite(&h, sizeof(h), 1, ofp) != 1)
         return (0);

     return(1);
 }

 /*
  * write_event_defs
  */
 int write_event_defs(FILE *ofp)
 {
     cpel_section_header_t sh;
     event_definition_section_header_t edsh;
     event_definition_t *this_event_definition;
     int i;

     /* Next, the event definitions */
     sh.section_type = ntohl(CPEL_SECTION_EVTDEF);
     sh.data_length = ntohl(vec_len(the_event_definitions)
                            *sizeof(the_event_definitions[0])
                            + sizeof(event_definition_section_header_t));

     if (fwrite(&sh, sizeof(sh), 1, ofp) != 1)
         return(0);

     memset(&edsh, 0, sizeof(edsh));

     strcpy(edsh.string_table_name, "FileStrtab");
     edsh.number_of_event_definitions = ntohl(vec_len(the_event_definitions));

     if (fwrite(&edsh, sizeof(edsh), 1, ofp) != 1)
         return(0);

     for (i = 0; i < vec_len(the_event_definitions); i++) {
         this_event_definition = &the_event_definitions[i];
         /* Endian fixup */
         this_event_definition->event = ntohl(this_event_definition->event);
         this_event_definition->event_format =
             ntohl(this_event_definition->event_format);
         this_event_definition->datum_format =
             ntohl(this_event_definition->datum_format);

         if (fwrite(this_event_definition, sizeof(the_event_definitions[0]),
                    1, ofp) != 1)
             return(0);
     }
     return(1);
 }

 /*
  * ntohll
  */
 u64 ntohll (u64 x) {
     if (clib_arch_is_little_endian)
 	x = ((((x >> 0) & 0xff) << 56)
 	     | (((x >> 8) & 0xff) << 48)
 	     | (((x >> 16) & 0xff) << 40)
 	     | (((x >> 24) & 0xff) << 32)
 	     | (((x >> 32) & 0xff) << 24)
 	     | (((x >> 40) & 0xff) << 16)
 	     | (((x >> 48) & 0xff) << 8)
 	     | (((x >> 56) & 0xff) << 0));

     return x;
 }

 /*
  * write_events
  */
 int write_events(FILE *ofp, u64 clock_ticks_per_second)
 {
     cpel_section_header_t sh;
     event_section_header_t eh;
     u32 number_of_events;
     int i;
     event_entry_t e;
     u64 net_timestamp;
     evt_t *this_event;
     u32 time0, time1;

     number_of_events = vec_len(the_events);

     sh.section_type = ntohl(CPEL_SECTION_EVENT);
     sh.data_length = ntohl(number_of_events * sizeof(e) +
                            sizeof(event_section_header_t));

     if (fwrite(&sh, sizeof(sh), 1, ofp) != 1)
         return(0);

     memset(&eh, 0, sizeof(eh));
     strcpy(eh.string_table_name, "FileStrtab");
     eh.number_of_events = ntohl(number_of_events);
     eh.clock_ticks_per_second = ntohl(clock_ticks_per_second);

     if (fwrite(&eh, sizeof(eh), 1, ofp) != 1)
         return(0);

     for (i = 0; i < number_of_events; i++) {
         this_event = &the_events[i];
         net_timestamp = ntohll(this_event->timestamp);

         time1 = net_timestamp>>32;
         time0 = net_timestamp & 0xFFFFFFFF;

         e.time[0] = time0;
         e.time[1] = time1;
         e.track = ntohl(this_event->track_id);
         e.event_code = ntohl(this_event->event_id);
         e.event_datum = ntohl(this_event->datum);

         if (fwrite(&e, sizeof(e), 1, ofp) != 1)
             return(0);
     }
     return(1);
 }

 /*
  * write_track_defs
  */
 int write_track_defs(FILE *ofp)
 {
     cpel_section_header_t sh;
     track_definition_section_header_t tdsh;
     track_definition_t record;
     track_definition_t *this_track_definition = &record;
     int i;
     event_definition_section_header_t edsh;

     /* Next, the event definitions */
     sh.section_type = ntohl(CPEL_SECTION_TRACKDEF);
     sh.data_length = ntohl(vec_len(the_tracks)
                            *sizeof(this_track_definition[0])
                            + sizeof(track_definition_section_header_t));

     if (fwrite(&sh, sizeof(sh), 1, ofp) != 1)
         return(0);

     memset(&tdsh, 0, sizeof(tdsh));

     strcpy(tdsh.string_table_name, "FileStrtab");
     tdsh.number_of_track_definitions = ntohl(vec_len(the_tracks));

     if (fwrite(&tdsh, sizeof(edsh), 1, ofp) != 1)
         return(0);

     for (i = 0; i < vec_len(the_tracks); i++) {
         this_track_definition->track = ntohl(i);
         this_track_definition->track_format =
             ntohl(the_tracks[i].strtab_offset);

         if (fwrite(this_track_definition, sizeof(this_track_definition[0]),
                    1, ofp) != 1)
             return(0);
     }
     return(1);
 }

 void cpel_util_init (void)
 {
     u8 *eventstr;

     the_strtab_hash = hash_create_string (0, sizeof (uword));
     the_msg_event_hash = hash_create_string (0, sizeof (uword));
     the_track_hash = hash_create_string (0, sizeof (uword));
     the_pidtid_hash = hash_create_string (0, sizeof(uword));
     the_pid_to_name_hash = hash_create(0, sizeof(uword));

     /* Must be first, or no supper... */
     find_or_add_strtab("FileStrtab");

     /* Historical canned events, no longer used. */
     if (0) {
         /* event 0 (not used) */
         eventstr = format(0, "PlaceholderNotUsed");
         vec_add1(eventstr, 0);
         find_or_add_event(eventstr, "%s");
         vec_free(eventstr);

         /* event 1 (thread on CPU) */
         eventstr = format(0, "THREAD/THRUNNING");
         vec_add1(eventstr, 0);
         find_or_add_event(eventstr, "%s");
         vec_free(eventstr);

         /* event 2 (thread ready) */
         eventstr = format(0, "THREAD/THREADY");
         vec_add1(eventstr, 0);
         find_or_add_event(eventstr, "%s");
         vec_free(eventstr);

         /* event 3 (function enter) */
         eventstr = format(0, "FUNC/ENTER");
         vec_add1(eventstr, 0);
         find_or_add_event(eventstr, "0x%x");
         vec_free(eventstr);

         /* event 4 (function enter) */
         eventstr = format(0, "FUNC/EXIT");
         vec_add1(eventstr, 0);
         find_or_add_event(eventstr, "0x%x");
         vec_free(eventstr);
     }
 }

 /*
  * alpha_compare_tracks
  */
 static int alpha_compare_tracks(const void *a1, const void *a2)
 {
     int i;
     track_t *t1 = (track_t *)a1;
     track_t *t2 = (track_t *)a2;
     u8 *s1 = &the_strtab[t1->strtab_offset];
     u8 *s2 = &the_strtab[t2->strtab_offset];

     for (i = 0; s1[i] && s2[i]; i++) {
         if (s1[i] < s2[i])
             return(-1);
         if (s1[i] > s2[i])
             return(1);
     }
     return(0);
 }

 /*
  * alpha_sort_tracks
  * Alphabetically sort tracks, set up a mapping
  * vector so we can quickly map the original track index to
  * the new/improved/alpha-sorted index
  */
 void alpha_sort_tracks(void)
 {
     track_t *this_track;
     int i;

     qsort(the_tracks, vec_len(the_tracks), sizeof(track_t),
           alpha_compare_tracks);

     vec_validate(track_alpha_map, vec_len(the_tracks));
     _vec_len(track_alpha_map) = vec_len(the_tracks);

     for (i = 0; i < vec_len(the_tracks); i++) {
         this_track = &the_tracks[i];
         track_alpha_map[this_track->original_index] = i;
     }
 }

 /*
  * fixup_event_tracks
  * Use the track alpha mapping to account for the alphabetic
  * sort performed by the previous routine
  */
 void fixup_event_tracks(void)
 {
     int i;
     u32 old_track;

     for (i = 0; i < vec_len(the_events); i++) {
         old_track = the_events[i].track_id;
         the_events[i].track_id = track_alpha_map[old_track];
     }
 }

 /* Indispensable for debugging in gdb... */

 u32 vl(void *x)
 {
     return vec_len(x);
 }
	/*
	*------------------------------------------------------------------
	* Copyright (c) 2006-2016 Cisco and/or its affiliates.
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at:
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	#include <stdio.h>
	#include <stdlib.h>
	#include <netinet/in.h>
	#include <string.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <fcntl.h>
	#include <sys/fcntl.h>
	#include <sys/mman.h>
	#include <unistd.h>
	#include <ctype.h>
	#include <vppinfra/clib.h>
	#include <vppinfra/vec.h>
	#include <vppinfra/hash.h>
	#include <vppinfra/bitmap.h>
	#include <vppinfra/byte_order.h>
	#include <pwd.h>
	#include <stdarg.h>
	#include <time.h>
	#include "cpel.h"
	#include "cpel_util.h"

	evt_t *the_events;

	track_t *the_tracks;
	u32 *track_alpha_map;

	event_definition_t *the_event_definitions;
	i64 min_timestamp;

	/* Hash tables, used to find previous instances of the same items */
	uword *the_track_hash;
	uword *the_msg_event_hash;
	uword *the_strtab_hash;
	uword *the_pidtid_hash;
	uword *the_pid_to_name_hash;
	u8 *the_strtab;

	uword *the_event_id_bitmap;

	/*
	* find_or_add_strtab
	* Finds or adds a string to the string table
	*/
	u32 find_or_add_strtab(void *s_arg)
	{
	uword *p;
	int len;
	u8 *this_string;
	u8 *scopy=0;
	char *s = s_arg;

	p = hash_get_mem(the_strtab_hash, s);
	if (p) {
	return (p[0]);
	}

	/*
	* Here's a CLIB bear-trap. We can't add the string-table
	* strings to the to the hash table (directly), since it
	* expands and moves periodically. All of the hash table
	* entries turn into dangling references, yadda yadda.
	*/

	len = strlen(s)+1;
	vec_add2(the_strtab, this_string, len);
	memcpy(this_string, s, len);

	/* Make a copy which won't be moving around... */
	vec_validate(scopy, len);
	memcpy(scopy, s, len);

	hash_set_mem(the_strtab_hash, scopy, this_string - the_strtab);

	return(this_string - the_strtab);
	}

	/*
	* find_or_add_track
	* returns index in track table
	*/
	u32 find_or_add_track(void *s_arg)
	{
	uword *p;
	track_t *this_track;
	u8 *copy_s;
	char *s=s_arg;

	p = hash_get_mem(the_track_hash, s);
	if (p) {
	return (p[0]);
	}
	vec_add2(the_tracks, this_track, 1);

	this_track->original_index = this_track - the_tracks;
	this_track->strtab_offset = find_or_add_strtab(s);

	copy_s = (u8 *)vec_dup(s);

	hash_set_mem(the_track_hash, copy_s, this_track - the_tracks);
	return(this_track - the_tracks);
	}

	/*
	* find_or_add_event
	* Adds an event to the event definition vector and add it to
	* the event hash table
	*/

	u32 find_or_add_event(void s_arg, char datum_format)
	{
	uword *p;
	u8 *copy_s;
	event_definition_t *this_event_definition;
	u32 event_id;
	char *s=s_arg;

	p = hash_get_mem(the_msg_event_hash, s);
	if (p) {
	return (p[0]);
	}
	vec_add2(the_event_definitions, this_event_definition, 1);

	/* Allocate a new event-id */
	event_id = clib_bitmap_first_clear (the_event_id_bitmap);
	the_event_id_bitmap = clib_bitmap_set(the_event_id_bitmap, event_id, 1);
	this_event_definition->event = event_id;
	this_event_definition->event_format = find_or_add_strtab(s);
	this_event_definition->datum_format = find_or_add_strtab(datum_format);

	copy_s = (u8 *)vec_dup(s);

	hash_set_mem(the_msg_event_hash, copy_s, event_id);

	return(event_id);
	}

	/*
	* write_string_table
	*/
	int write_string_table(FILE *ofp)
	{
	cpel_section_header_t sh;

	/* Round up string table size */
	while (vec_len(the_strtab) & 0x7)
	vec_add1(the_strtab, 0);

	sh.section_type = ntohl(CPEL_SECTION_STRTAB);
	sh.data_length = ntohl(vec_len(the_strtab));

	if (fwrite(&sh, sizeof(sh), 1, ofp) != 1)
	return(0);

	if (fwrite(the_strtab, 1, vec_len(the_strtab), ofp) !=
	vec_len(the_strtab))
	return(0);

	return(1);
	}

	/*
	* write_cpel_header
	*/
	int write_cpel_header(FILE *ofp, u32 nsections)
	{
	cpel_file_header_t h;

	h.endian_version = CPEL_FILE_VERSION;
	h.pad = 0;
	h.nsections = ntohs(nsections);
	h.file_date = ntohl(time(0));
	if (fwrite(&h, sizeof(h), 1, ofp) != 1)
	return (0);

	return(1);
	}

	/*
	* write_event_defs
	*/
	int write_event_defs(FILE *ofp)
	{
	cpel_section_header_t sh;
	event_definition_section_header_t edsh;
	event_definition_t *this_event_definition;
	int i;

	/* Next, the event definitions */
	sh.section_type = ntohl(CPEL_SECTION_EVTDEF);
	sh.data_length = ntohl(vec_len(the_event_definitions)
	*sizeof(the_event_definitions[0])
	+ sizeof(event_definition_section_header_t));

	if (fwrite(&sh, sizeof(sh), 1, ofp) != 1)
	return(0);

	memset(&edsh, 0, sizeof(edsh));

	strcpy(edsh.string_table_name, "FileStrtab");
	edsh.number_of_event_definitions = ntohl(vec_len(the_event_definitions));

	if (fwrite(&edsh, sizeof(edsh), 1, ofp) != 1)
	return(0);

	for (i = 0; i < vec_len(the_event_definitions); i++) {
	this_event_definition = &the_event_definitions[i];
	/* Endian fixup */
	this_event_definition->event = ntohl(this_event_definition->event);
	this_event_definition->event_format =
	ntohl(this_event_definition->event_format);
	this_event_definition->datum_format =
	ntohl(this_event_definition->datum_format);

	if (fwrite(this_event_definition, sizeof(the_event_definitions[0]),
	1, ofp) != 1)
	return(0);
	}
	return(1);
	}

	/*
	* ntohll
	*/
	u64 ntohll (u64 x) {
	if (clib_arch_is_little_endian)
	x = ((((x >> 0) & 0xff) << 56)
	\| (((x >> 8) & 0xff) << 48)
	\| (((x >> 16) & 0xff) << 40)
	\| (((x >> 24) & 0xff) << 32)
	\| (((x >> 32) & 0xff) << 24)
	\| (((x >> 40) & 0xff) << 16)
	\| (((x >> 48) & 0xff) << 8)
	\| (((x >> 56) & 0xff) << 0));

	return x;
	}

	/*
	* write_events
	*/
	int write_events(FILE *ofp, u64 clock_ticks_per_second)
	{
	cpel_section_header_t sh;
	event_section_header_t eh;
	u32 number_of_events;
	int i;
	event_entry_t e;
	u64 net_timestamp;
	evt_t *this_event;
	u32 time0, time1;

	number_of_events = vec_len(the_events);

	sh.section_type = ntohl(CPEL_SECTION_EVENT);
	sh.data_length = ntohl(number_of_events * sizeof(e) +
	sizeof(event_section_header_t));

	if (fwrite(&sh, sizeof(sh), 1, ofp) != 1)
	return(0);

	memset(&eh, 0, sizeof(eh));
	strcpy(eh.string_table_name, "FileStrtab");
	eh.number_of_events = ntohl(number_of_events);
	eh.clock_ticks_per_second = ntohl(clock_ticks_per_second);

	if (fwrite(&eh, sizeof(eh), 1, ofp) != 1)
	return(0);

	for (i = 0; i < number_of_events; i++) {
	this_event = &the_events[i];
	net_timestamp = ntohll(this_event->timestamp);

	time1 = net_timestamp>>32;
	time0 = net_timestamp & 0xFFFFFFFF;

	e.time[0] = time0;
	e.time[1] = time1;
	e.track = ntohl(this_event->track_id);
	e.event_code = ntohl(this_event->event_id);
	e.event_datum = ntohl(this_event->datum);

	if (fwrite(&e, sizeof(e), 1, ofp) != 1)
	return(0);
	}
	return(1);
	}

	/*
	* write_track_defs
	*/
	int write_track_defs(FILE *ofp)
	{
	cpel_section_header_t sh;
	track_definition_section_header_t tdsh;
	track_definition_t record;
	track_definition_t *this_track_definition = &record;
	int i;
	event_definition_section_header_t edsh;

	/* Next, the event definitions */
	sh.section_type = ntohl(CPEL_SECTION_TRACKDEF);
	sh.data_length = ntohl(vec_len(the_tracks)
	*sizeof(this_track_definition[0])
	+ sizeof(track_definition_section_header_t));

	if (fwrite(&sh, sizeof(sh), 1, ofp) != 1)
	return(0);

	memset(&tdsh, 0, sizeof(tdsh));

	strcpy(tdsh.string_table_name, "FileStrtab");
	tdsh.number_of_track_definitions = ntohl(vec_len(the_tracks));

	if (fwrite(&tdsh, sizeof(edsh), 1, ofp) != 1)
	return(0);

	for (i = 0; i < vec_len(the_tracks); i++) {
	this_track_definition->track = ntohl(i);
	this_track_definition->track_format =
	ntohl(the_tracks[i].strtab_offset);

	if (fwrite(this_track_definition, sizeof(this_track_definition[0]),
	1, ofp) != 1)
	return(0);
	}
	return(1);
	}

	void cpel_util_init (void)
	{
	u8 *eventstr;

	the_strtab_hash = hash_create_string (0, sizeof (uword));
	the_msg_event_hash = hash_create_string (0, sizeof (uword));
	the_track_hash = hash_create_string (0, sizeof (uword));
	the_pidtid_hash = hash_create_string (0, sizeof(uword));
	the_pid_to_name_hash = hash_create(0, sizeof(uword));

	/* Must be first, or no supper... */
	find_or_add_strtab("FileStrtab");

	/* Historical canned events, no longer used. */
	if (0) {
	/* event 0 (not used) */
	eventstr = format(0, "PlaceholderNotUsed");
	vec_add1(eventstr, 0);
	find_or_add_event(eventstr, "%s");
	vec_free(eventstr);

	/* event 1 (thread on CPU) */
	eventstr = format(0, "THREAD/THRUNNING");
	vec_add1(eventstr, 0);
	find_or_add_event(eventstr, "%s");
	vec_free(eventstr);

	/* event 2 (thread ready) */
	eventstr = format(0, "THREAD/THREADY");
	vec_add1(eventstr, 0);
	find_or_add_event(eventstr, "%s");
	vec_free(eventstr);

	/* event 3 (function enter) */
	eventstr = format(0, "FUNC/ENTER");
	vec_add1(eventstr, 0);
	find_or_add_event(eventstr, "0x%x");
	vec_free(eventstr);

	/* event 4 (function enter) */
	eventstr = format(0, "FUNC/EXIT");
	vec_add1(eventstr, 0);
	find_or_add_event(eventstr, "0x%x");
	vec_free(eventstr);
	}
	}

	/*
	* alpha_compare_tracks
	*/
	static int alpha_compare_tracks(const void a1, const void a2)
	{
	int i;
	track_t t1 = (track_t )a1;
	track_t t2 = (track_t )a2;
	u8 *s1 = &the_strtab[t1->strtab_offset];
	u8 *s2 = &the_strtab[t2->strtab_offset];

	for (i = 0; s1[i] && s2[i]; i++) {
	if (s1[i] < s2[i])
	return(-1);
	if (s1[i] > s2[i])
	return(1);
	}
	return(0);
	}

	/*
	* alpha_sort_tracks
	* Alphabetically sort tracks, set up a mapping
	* vector so we can quickly map the original track index to
	* the new/improved/alpha-sorted index
	*/
	void alpha_sort_tracks(void)
	{
	track_t *this_track;
	int i;

	qsort(the_tracks, vec_len(the_tracks), sizeof(track_t),
	alpha_compare_tracks);

	vec_validate(track_alpha_map, vec_len(the_tracks));
	_vec_len(track_alpha_map) = vec_len(the_tracks);

	for (i = 0; i < vec_len(the_tracks); i++) {
	this_track = &the_tracks[i];
	track_alpha_map[this_track->original_index] = i;
	}
	}

	/*
	* fixup_event_tracks
	* Use the track alpha mapping to account for the alphabetic
	* sort performed by the previous routine
	*/
	void fixup_event_tracks(void)
	{
	int i;
	u32 old_track;

	for (i = 0; i < vec_len(the_events); i++) {
	old_track = the_events[i].track_id;
	the_events[i].track_id = track_alpha_map[old_track];
	}
	}

	/* Indispensable for debugging in gdb... */

	u32 vl(void *x)
	{
	return vec_len(x);
	}