Changeset 02a99d2 in mainline


Ignore:
Timestamp:
2005-05-11T19:51:55Z (19 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
69515260
Parents:
45671f48
Message:

NDEBUG debug symbol, ASSERT debug macro, fancier panic() in debug mode
indentation fixes, ASSERTs

Files:
23 edited

Legend:

Unmodified
Added
Removed

  • arch/ia32/src/debug/panic.s

    r45671f48 r02a99d2  
    2828
    2929.text
    30 .global panic
     30.global panic_printf
    3131
    32 panic:
     32panic_printf:
    3333        movl $halt,(%esp)       # fake stack to make printf return to halt
    3434        jmp printf

  • arch/ia32/src/interrupt.c

    r45671f48 r02a99d2  
    2929#include <arch/interrupt.h>
    3030#include <print.h>
     31#include <debug.h>
    3132#include <panic.h>
    3233#include <arch/i8259.h>
    … …  
    4950iroutine trap_register(__u8 n, iroutine f)
    5051{
     52        ASSERT(n < IVT_ITEMS);
     53       
    5154        iroutine old;
    52    
     55       
    5356        old = ivt[n];
    5457        ivt[n] = f;
    55    
    56         return old;
     58       
     59        return old;
    5760}
    5861
    … …  
    6366void trap_dispatcher(__u8 n, __u32 stack[])
    6467{
    65         ivt[n](n,stack);
     68        ASSERT(n < IVT_ITEMS);
     69       
     70        ivt[n](n, stack);
    6671}
    6772
    … …  
    113118                enable_irqs_function(irqmask);
    114119        else
    115                 panic(PANIC "no enable_irqs_function\n");
     120                panic("no enable_irqs_function\n");
    116121}
    117122
    … …  
    121126                disable_irqs_function(irqmask);
    122127        else
    123                 panic(PANIC "no disable_irqs_function\n");
     128                panic("no disable_irqs_function\n");
    124129}
    125130
    … …  
    129134                eoi_function();
    130135        else
    131                 panic(PANIC "no eoi_function\n");
     136                panic("no eoi_function\n");
    132137
    133138}

  • arch/ia32/src/pm.c

    r45671f48 r02a99d2  
    144144                tss_p = (struct tss *) malloc(sizeof(struct tss));
    145145                if (!tss_p)
    146                         panic(PANIC "could not allocate TSS\n");
     146                        panic("could not allocate TSS\n");
    147147        }
    148148

  • arch/ia32/src/smp/mps.c

    r45671f48 r02a99d2  
    470470                 */
    471471                if (!(gdt_new = (struct descriptor *) malloc(GDT_ITEMS*sizeof(struct descriptor))))
    472                         panic(PANIC "couldn't allocate memory for GDT\n");
     472                        panic("couldn't allocate memory for GDT\n");
    473473
    474474                memcopy(gdt, gdt_new, GDT_ITEMS*sizeof(struct descriptor));

  • arch/ia64/src/fake.s

    r45671f48 r02a99d2  
    4848.global map_page_to_frame
    4949.global memsetb
    50 .global panic
     50.global panic_printf
    5151
    5252before_thread_runs_arch:
    … …  
    6969map_page_to_frame:
    7070memsetb:
    71 panic:
     71panic_printf:
    7272        br.ret.sptk.many b0
    7373

  • arch/mips/src/cache.c

    r45671f48 r02a99d2  
    3232void cache_error(void)
    3333{
    34         panic(PANIC "cache_error exception\n");
     34        panic("cache_error exception\n");
    3535}

  • arch/mips/src/exception.c

    r45671f48 r02a99d2  
    5252                case EXC_TLBL:
    5353                case EXC_TLBS: tlb_invalid(); break;
    54                 default: panic(PANIC "unhandled exception %d\n", excno); break;
     54                default: panic("unhandled exception %d\n", excno); break;
    5555        }
    5656       

  • arch/mips/src/interrupt.c

    r45671f48 r02a99d2  
    7676                            case 0x4:
    7777                            case 0x5:
    78                             case 0x6: panic(PANIC "unhandled interrupt %d\n", i); break;
     78                            case 0x6: panic("unhandled interrupt %d\n", i); break;
    7979                            case 0x7:
    8080                                    /* clear timer interrupt */

  • arch/mips/src/mm/tlb.c

    r45671f48 r02a99d2  
    4242        }
    4343       
    44         panic(PANIC "tlb_refill exception\n");
     44        panic("tlb_refill exception\n");
    4545}
    4646
    4747void tlb_invalid(void)
    4848{
    49         panic(PANIC "%X: TLB exception at %X", cp0_badvaddr_read(), THREAD ? THREAD->saved_epc : 0);
     49        panic("%X: TLB exception at %X", cp0_badvaddr_read(), THREAD ? THREAD->saved_epc : 0);
    5050}
    5151

  • arch/mips/src/panic.s

    r45671f48 r02a99d2  
    3333.set nomacro
    3434
    35 .global panic
     35.global panic_printf
    3636       
    37 panic:
     37panic_printf:
    3838        jal printf
    3939        nop

  • include/list.h

    r45671f48 r02a99d2  
    6969}
    7070
    71 #define list_empty(head) (((head)->next == (head))?1:0)
     71#define list_empty(head) (((head)->next == (head))?true:false)
    7272
    7373#define list_get_instance(link,type,member) (type *)(((__u8*)(link))-((__u8*)&(((type *)NULL)->member)))

  • include/panic.h

    r45671f48 r02a99d2  
    3030#define __PANIC_H__
    3131
    32 #define PANIC "KERNEL PANIC: "
     32#ifndef NDEBUG
     33#       define panic(format, ...) panic_printf("Kernel panic in %s() at %s on line %d: " format, __FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__);
     34#else
     35#       define panic(format, ...) panic_printf("Kernel panic: " format, ##__VA_ARGS__);
     36#endif
    3337
    34 extern void panic(char *fmt, ...);
     38extern void panic_printf(char *fmt, ...);
    3539
    3640#endif

  • include/print.h

    r45671f48 r02a99d2  
    3838static void print_str(const char *str);
    3939static void print_fixed_hex(const __native num, const int width);
    40 static void print_number(const __native num, const int base);
     40static void print_number(const __native num, const unsigned int base);
    4141
    4242extern void putchar(const char c);

  • include/typedefs.h

    r45671f48 r02a99d2  
    3535typedef short bool;
    3636
     37typedef unsigned int size_t;
     38
    3739typedef struct config config_t;
    3840typedef struct cpu_private_data cpu_private_data_t;

  • src/debug/print.c

    r45671f48 r02a99d2  
    4747void print_str(const char *str)
    4848{
    49         int i = 0;
     49        int i = 0;
    5050        char c;
    51    
     51       
    5252        while (c = str[i++])
    53             putchar(c);
     53                putchar(c);
    5454}
    5555
    … …  
    8585 *
    8686 */
    87 void print_number(const __native num, const int base)
     87void print_number(const __native num, const unsigned int base)
    8888{
    8989        int val = num;
    9090        char d[sizeof(__native)*8+1];           /* this is good enough even for base == 2 */
    91         int i = sizeof(__native)*8-1;
    92    
     91        int i = sizeof(__native)*8-1;
     92       
    9393        do {
    9494                d[i--] = digits[val % base];

  • src/main/kinit.c

    r45671f48 r02a99d2  
    120120         */
    121121        m = vm_create();
    122         if (!m) panic(PANIC "vm_create");
     122        if (!m) panic("vm_create");
    123123        u = task_create(m);
    124         if (!u) panic(PANIC "task_create");
     124        if (!u) panic("task_create");
    125125        t = thread_create(uinit, NULL, u, THREAD_USER_STACK);
    126         if (!t) panic(PANIC "thread_create");
     126        if (!t) panic("thread_create");
    127127
    128128        /*
    … …  
    130130         */     
    131131        a = vm_area_create(m, VMA_TEXT, 1, UTEXT_ADDRESS);
    132         if (!a) panic(PANIC "vm_area_create: vm_text");
     132        if (!a) panic("vm_area_create: vm_text");
    133133        memcopy((__address) utext, PA2KA(a->mapping[0]), utext_size < PAGE_SIZE ? utext_size : PAGE_SIZE);             
    134134
    … …  
    137137         */
    138138        a = vm_area_create(m, VMA_STACK, 1, USTACK_ADDRESS);
    139         if (!a) panic(PANIC "vm_area_create: vm_stack");
     139        if (!a) panic("vm_area_create: vm_stack");
    140140       
    141141        thread_ready(t);

  • src/main/main.c

    r45671f48 r02a99d2  
    3030#include <arch/context.h>
    3131#include <print.h>
     32#include <panic.h>
    3233#include <config.h>
    3334#include <time/clock.h>

  • src/mm/frame.c

    r45671f48 r02a99d2  
    7272                frame_bitmap = (__u8 *) malloc(frame_bitmap_octets);
    7373                if (!frame_bitmap)
    74                         panic(PANIC "malloc/frame_bitmap\n");
     74                        panic("malloc/frame_bitmap\n");
    7575
    7676                /*
    … …  
    145145                        }
    146146                }
    147                 panic(PANIC "frames_free inconsistent (%d)\n", frames_free);
     147                panic("frames_free inconsistent (%d)\n", frames_free);
    148148        }
    149149        spinlock_unlock(&framelock);
    … …  
    151151
    152152        if (flags & FRAME_PANIC)
    153                 panic(PANIC "unable to allocate frame\n");
     153                panic("unable to allocate frame\n");
    154154               
    155155        /* TODO: implement sleeping logic here */
    156         panic(PANIC "sleep not supported\n");
     156        panic("sleep not supported\n");
    157157       
    158158        goto loop;
    … …  
    196196                        }       
    197197                }
    198                 else panic(PANIC "frame_free: frame already free\n");
    199         }
    200         else panic(PANIC "frame_free: frame number too big\n");
     198                else panic("frame_free: frame already free\n");
     199        }
     200        else panic("frame_free: frame number too big\n");
    201201       
    202202        spinlock_unlock(&framelock);

  • src/mm/heap.c

    r45671f48 r02a99d2  
    3131#include <func.h>
    3232#include <memstr.h>
     33#include <panic.h>
    3334#include <arch/types.h>
    3435

  • src/mm/vm.c

    r45671f48 r02a99d2  
    6363       
    6464        if (addr % PAGE_SIZE)
    65                 panic(PANIC "addr not aligned to a page boundary");
     65                panic("addr not aligned to a page boundary");
    6666       
    6767        pri = cpu_priority_high();
    … …  
    125125                        break;
    126126                default:
    127                         panic(PANIC "unexpected vm_type_t %d", a->type);
     127                        panic("unexpected vm_type_t %d", a->type);
    128128        }
    129129       

  • src/proc/scheduler.c

    r45671f48 r02a99d2  
    3838#include <arch/asm.h>
    3939#include <list.h>
     40#include <panic.h>
    4041#include <typedefs.h>
    4142#include <mm/page.h>

  • src/synch/rwlock.c

    r45671f48 r02a99d2  
    185185                                break;
    186186                        case ESYNCH_OK_ATOMIC:
    187                                 panic(PANIC "_mutex_lock_timeout()==ESYNCH_OK_ATOMIC");
     187                                panic("_mutex_lock_timeout()==ESYNCH_OK_ATOMIC");
    188188                                break;
    189189                        dafault:
    190                                 panic(PANIC "invalid ESYNCH");
     190                                panic("invalid ESYNCH");
    191191                                break;
    192192                }

  • src/time/timeout.c

    r45671f48 r02a99d2  
    3131#include <arch/types.h>
    3232#include <config.h>
     33#include <panic.h>
    3334#include <synch/spinlock.h>
    3435#include <func.h>
Note: See TracChangeset for help on using the changeset viewer.