src/common/error.cpp

Idź do dokumentacji tego pliku.

/***********************************************************
*PANALIX 0.06, (c) Adrian Panasiuk 2002-4                  *
*adek336[at]o2.pl, panalix.prv.pl                          *
*under GPLv3 license                                       *
*                                                          *
*panalix - small osdev project                             *
************************************************************
*       error.cpp, version 1.0                             *
************************************************************
*                                                          *
*here we declare the basic functions for handling errors   *
*like sysfail, etc.                                        *
*                                                          *
*18'04'04- first revision (1.0)                            *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/common/string.hpp"
#include "src/common/io.hpp"
#include "src/tty/teletype.hpp"
#include "src/memory/memset.hpp"
#include "src/module/coresyms.hpp"
#include "src/module/mangle.hpp"
#include "src/module/elf.hpp"
#include "src/common/error.hpp"
#include "src/collection/avlmap.hpp"

uint32 sysfail_dbg=0;

//0xff
const uint32 CALL_TRACE_COUNT   = 0xa;

using namespace Collection;
struct AvlMap<uint32,uint32,generic_cmp<uint32> > *dbg_val_map;
bool dbg_map_availlable = false;

void init_dbg_val_map() {
   dbg_val_map = new struct AvlMap<uint32,uint32,generic_cmp<uint32> >();
   dbg_map_availlable = true;
}

uint32 get_dbg_val(uint32 key) {
   if (dbg_map_availlable == false)
      return 0;
   struct Option<Tuple2<uint32,uint32> > opt= dbg_val_map->find(key);
   if (opt.isNone())
      return 0;
   else
      return opt.get()._2;
}

bool set_dbg_val(uint32 key, uint32 val) {
   if (!dbg_map_availlable) {
      println(key, " -> ", val);
      complain("dbg_map not initialised");
      return false;
   }
   return dbg_val_map->update(key,val);
}

/*=================errors*/

/*stop execution*/
void panic()
 {
        for(;;) Teletype::vidmem[1].ch++;
//      (*(uint32*) 0xb8002)++;
 }

/*=====================debugging*/
// /*alert a value*/
// void logout(char *text) {
//      alert (text);
//  }
// 
// /*alert a number*/
// void logout(uint32 i) {
//      sysfail("logout #i: not permitted");
//  }

/*dump the call trace*/
void debug_dump_call_trace(uint32 eip, uint32 addr)
 {
uint32 *trace;  //the previous %ebp on the stack
char *ch;       //the name of the function
string demangled;//the name, demangled
string num;     //for converting ints to strings
int i;
uint32 cnt=0;
// init
        trace= (uint32*) addr;
        memset(&demangled, 0, sizeof(demangled));
        memset(&num, 0, sizeof(num));

// a welcome message
        alert("\nCALL TRACE: \n");
//the eip's name
        ch= Syms::sym_name (eip, STT_FUNC);     //search for funcs with addr below eip
        if (ch!=NULL)   //discard on error
         {
                i= Syms::Mangle::demangle(ch, &demangled, trace+2); //demangle the name;//trace-> ebp value, trace+1-> eip value, trace+2->first arg
                if ((i == ESUCCESS) && (demangled.v() != NULL))
                        { alert("(#1) "); alert(demangled.v()); alert("\n"); }  //tell the name
         }

// now the traceback
        while (ESUCCESS)
         {
                cnt++;
        // sanity checks
                if (*(trace) < 0x100000)        /* error out. we hardly have any functions below 1Mib */
                        break;
                if (cnt+1>CALL_TRACE_COUNT)     /* don't trace deeper than CALL_TRACE_COUNT */
                        break;
        // get the func name with the current traceback
                ch= Syms::sym_name( *(trace+1), STT_FUNC);      //functions. the eip is after the ebp, so that's what the "+1" stands for
                if (ch==NULL)   //error out
                        break;
        // demangle
                i= Syms::Mangle::demangle(ch, &demangled, trace+2);     //trace-> ebp value, trace+1-> eip value, trace+2->first arg
                if ((i != ESUCCESS)||(demangled.v() == NULL))   //error out
                        break;
        // convert current level to string
                num.decim(cnt+1);
        // put the name
                alert("(#");
                alert(num.v());
                alert(") ");
                alert(demangled.v());
                alert("\n");
        // trace deeper
                trace= (uint32*)*(trace);
         }

// end traceback
        alert("===end traceback\n");
 }

/*dump the call trace*/
void debug_dump_call_trace()
 {
uint32 eip, esp;
        asm volatile ("mov (%%ebp), %%eax\nmov 4(%%ebp), %%ebx" : "=a" (esp), "=b" (eip));
        debug_dump_call_trace(eip,esp);
        alert("\n");
 }

//put a single val; there should be a lock so that io operations don't get interrupted
void put_bochs(char ch)
 {
        IOPorts::outb(PORT_E9, ch);
 }

//use the 0xe9 hack to bochs; works with --enable-port-e9-hack; there should be a lock so that io operations don't get interrupted
void write_bochs(const char *text)
 {
uint32 fl;
        asm volatile("pushf\npopl %0\ncli":"=g" (fl));
        while ( *text != '\0')
                IOPorts::outb(PORT_E9, *(text++));
        asm volatile("pushl %0\npopf"::"g"(fl));
 }

/*cout num*/
void write_bochs_num(uint32 n, uint32 radix, uint32 n_pos, char first_letter)
 {
uint32 cipher;
uint32 fl;
        asm volatile("pushf\npopl %0\ncli":"=g"(fl));
        while (n_pos)
         {
                cipher = n / n_pos;
                if (cipher <= 9) { if (cipher || (radix!=10)) put_bochs(cipher + (char) '0'); }
                        else put_bochs(cipher + first_letter - 0xA);

                n -= cipher * n_pos;
                n_pos = n_pos / radix;
         }
        asm volatile("pushl %0\npopf"::"g"(fl));
 }

//use the 0xe9 hack to bochs; works with --enable-port-e9-hack
void write_bochs(int i)
 {
        write_bochs_num(i, 16, 0x10000000, 'A');
 }

/***********************************************************
*                                                          *
*panalix 0.06 (c) Adrian Panasiuk 2002-4                   *
*adek336[at]o2.pl, panalix.prv.pl                          *
*                                                          *
***********************************************************/

---