root/modules/dbg_dump.c

DEFINITIONS

1. dbg_dump_write
2. dbg_dump_assert

   1 #include "camera_info.h"
   2 #include "conf.h"
   3 #include "script.h"
   4 #include "meminfo.h"
   5 #include "cache.h"
   6 #include "module_load.h"
   7 #include "clock.h"
   8 #include "cachebit.h"
   9 #include "time.h"
  11 // to keep format simple, we always write meminfo for each
  12 // but can skip actual getmeminfo since call might crash on mem corruption
  13 #define DBG_DUMP_FL_NOMEMINFO   0x1
  14 #define DBG_DUMP_FL_NOEXMEMINFO 0x2
  16 #define DBG_DUMP_VERSION        2 
  17 // version 2 - added module info, tick, uncached bit, max_ram_addr, build_string
  18 /*
  19 dump debug info to a file
  20 format
  21  header
  22  meminfo (camera heap, may be mostly -1 if meminfo not supported,0s if desabled)
  23  meminfo (exmem, 0s if exmem disabled)
  24  module info, length given by module_count * module_info_size
  25  stack dump (length in words given stack_count)
  26  user data (variable length given in user_data_len)
  27 */
  28 typedef struct {
  29     int ver;
  30     int time;
  31     int tick;
  32     int platform_id;
  33     int romstart;    // could look up the following 3 manually but makes auto parsing easier
  34     int uncached_bit;
  35     int max_ram_addr;
  36     int text_start; // == _start
  37     int data_start; // == text_end
  38     int bss_start;  // == data_end
  39     int bss_end;    // == _end
  40     int module_count; // number of loaded modules
  41     int module_info_size; // dump version should change if this changes, but will keep the rest of dump readable if it doesn't 
  42     int sp;
  43     int stack_count; // number of words of stack dumped (not related to number of words in stack!)
  44     int user_val; // user_data address if not null, otherwise treat user_data_size as an arbitrary int and put it here
  45     int user_data_len;
  46     int flags;
  47     char build_string[100]; // "platform,sub,date,time,version,rev", oversized for simplicity
  48 } dumpheader;
  50 typedef struct {
  51     int index;
module_entry m;
flat_hdr h;
  54 } mod_info;
  56 // this does not describe the structure, just a convenient way to access uncached + use less memory
  57 typedef union {
dumpheader h;
cam_meminfo m;
mod_info mi;
  61 } dumpinfo;
  63 // number of words to dump -- could get initial SP from task
  64 #define STACK_DUMP_COUNT 512
  67 void dbg_dump_write(const char *dumpname,unsigned flags, int user_data_len, char *user_data) {
  68     static dumpinfo buf;
  69     // convenient access to uncached version
dumpinfo *pb = ADR_TO_UNCACHED(&buf);
  72     // use open + uncached mem because we may not have enough memory for fopen
  73     int fd=open(dumpname, O_WRONLY|O_CREAT|O_TRUNC, 0777);
  74     if(fd >= 0) {
  75         int *sp;
  76         asm volatile( "MOV %0,SP\n" :"=r"(sp));
pb->h.ver = DBG_DUMP_VERSION;
pb->h.time = time(NULL);
pb->h.tick = get_tick_count();
pb->h.platform_id = conf.platformid;
pb->h.romstart = camera_info.rombaseaddr;
pb->h.uncached_bit = camera_info.cam_uncached_bit;
pb->h.max_ram_addr = camera_info.maxramaddr;
pb->h.text_start = camera_info.text_start;
pb->h.data_start = camera_info.data_start;
pb->h.bss_start = camera_info.bss_start;
pb->h.bss_end = camera_info.bss_end;
pb->h.sp = (int)sp;
pb->h.stack_count = STACK_DUMP_COUNT;
  90         if(user_data) {
pb->h.user_data_len = user_data_len;
pb->h.user_val = (int)user_data;
  93         } else {
pb->h.user_data_len = 0;
pb->h.user_val = user_data_len;
  96         }
pb->h.flags = flags;
 100         int m_count=0;
 101         // count so we can store it in the header
 102         int i;
 103         for(i=0;i<MAX_NUM_LOADED_MODULES;i++) {
 104             const module_entry *m = module_get_adr(i);
 105             if(m) {
m_count++;
 107             }
 108         }
pb->h.module_count = m_count;
pb->h.module_info_size = sizeof(mod_info);
sprintf(pb->h.build_string,"%s,%s,%s,%s,%s,%s", 
camera_info.platform,
camera_info.platformsub,
camera_info.build_date,
camera_info.build_time,
camera_info.build_number,
camera_info.build_svnrev);
write(fd,&pb->h,sizeof(dumpheader));
 121         if(!(flags & DBG_DUMP_FL_NOMEMINFO)) {
GetMemInfo(&pb->m);
 123         } else {
memset(&pb->m,0,sizeof(cam_meminfo));
 125         }
write(fd,&pb->m,sizeof(cam_meminfo));
 128         // if no exmem don't check
memset(&pb->m,0,sizeof(cam_meminfo));
 130         if(!(flags & DBG_DUMP_FL_NOEXMEMINFO)) {
GetExMemInfo(&pb->m);
 132         }
write(fd,&pb->m,sizeof(cam_meminfo));
 135         // assume modules haven't gone away since count, might not be valid?
 136         for(i=0;i<MAX_NUM_LOADED_MODULES;i++) {
 137             const module_entry *m = module_get_adr(i);
 138             if(!m) {
 139                 continue;
 140             }
pb->mi.index = i;
memcpy(&pb->mi.m,m,sizeof(module_entry));
memcpy(&pb->mi.h,m->hdr,sizeof(flat_hdr));
write(fd,&pb->mi,sizeof(mod_info));
 145         }
 147         // clean cache for write()
dcache_clean_all();
write(fd,ADR_TO_UNCACHED(sp),STACK_DUMP_COUNT*4);
 151         if(user_data_len && user_data) {
 152             // we assume user_data has been flushed out by preceding
write(fd,ADR_TO_UNCACHED(user_data),user_data_len);
 154         }
close(fd);
 156     } else {
script_console_add_error( (long)"failed to open dump file" );
 158     }
 159 }
 161 void dbg_dump_assert(const char *dumpfile,const char *expr,const char *file,int line) {
 162     static char buf[128]; // could overflow if expr is long
sprintf(buf,"ASSERT %s:%d %s",file,line,expr);
script_console_add_error( (long)buf );
dbg_dump_write(dumpfile,0,sizeof(buf),buf);
 166 }