Changeset f651e80 in mainline


Ignore:
Timestamp:
2009-01-08T12:07:38Z (15 years ago)
Author:
Jiri Svoboda <jirik.svoboda@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
7447572
Parents:
c571f42
Message:

Make newlines in panic messages consistent. Add periods at end of messages so that it is obvious whether they are printed entirely.

Location:
kernel
Files:
61 edited

Legend:

Unmodified
Added
Removed
  • kernel/arch/amd64/src/interrupt.c

    rc571f42 rf651e80  
    9595                eoi_function();
    9696        else
    97                 panic("no eoi_function\n");
     97                panic("No eoi_function.");
    9898
    9999}
     
    101101static void null_interrupt(int n, istate_t *istate)
    102102{
    103         fault_if_from_uspace(istate, "Unserviced interrupt: %d", n);
     103        fault_if_from_uspace(istate, "Unserviced interrupt: %d.", n);
    104104        decode_istate(n, istate);
    105         panic("Unserviced interrupt\n");
     105        panic("Unserviced interrupt.");
    106106}
    107107
     
    127127                        return;
    128128                }
    129                 fault_if_from_uspace(istate, "General protection fault");
     129                fault_if_from_uspace(istate, "General protection fault.");
    130130        }
    131131
    132132        decode_istate(n, istate);
    133         panic("General protection fault\n");
     133        panic("General protection fault.");
    134134}
    135135
    136136static void ss_fault(int n, istate_t *istate)
    137137{
    138         fault_if_from_uspace(istate, "Stack fault");
     138        fault_if_from_uspace(istate, "Stack fault.");
    139139        decode_istate(n, istate);
    140         panic("Stack fault\n");
     140        panic("Stack fault.");
    141141}
    142142
     
    146146        scheduler_fpu_lazy_request();
    147147#else
    148         fault_if_from_uspace(istate, "FPU fault");
    149         panic("FPU fault");
     148        fault_if_from_uspace(istate, "FPU fault.");
     149        panic("FPU fault.");
    150150#endif
    151151}
     
    222222                enable_irqs_function(irqmask);
    223223        else
    224                 panic("no enable_irqs_function\n");
     224                panic("No enable_irqs_function.");
    225225}
    226226
     
    230230                disable_irqs_function(irqmask);
    231231        else
    232                 panic("no disable_irqs_function\n");
     232                panic("No disable_irqs_function.");
    233233}
    234234
  • kernel/arch/amd64/src/mm/page.c

    rc571f42 rf651e80  
    181181       
    182182        if (istate->error_word & PFERR_CODE_RSVD)
    183                 panic("Reserved bit set in page table entry.\n");
     183                panic("Reserved bit set in page table entry.");
    184184       
    185185        if (istate->error_word & PFERR_CODE_RW)
     
    191191       
    192192        if (as_page_fault(page, access, istate) == AS_PF_FAULT) {
    193                 fault_if_from_uspace(istate, "Page fault: %#x", page);
     193                fault_if_from_uspace(istate, "Page fault: %#x.", page);
    194194
    195195                decode_istate(n, istate);
    196                 printf("Page fault address: %llx\n", page);
    197                 panic("Page fault\n");
     196                printf("Page fault address: %llx.\n", page);
     197                panic("Page fault.");
    198198        }
    199199}
     
    203203{
    204204        if (last_frame + ALIGN_UP(size, PAGE_SIZE) > KA2PA(KERNEL_ADDRESS_SPACE_END_ARCH))
    205                 panic("Unable to map physical memory %p (%d bytes)", physaddr, size)
     205                panic("Unable to map physical memory %p (%d bytes).", physaddr, size)
    206206       
    207207        uintptr_t virtaddr = PA2KA(last_frame);
  • kernel/arch/amd64/src/pm.c

    rc571f42 rf651e80  
    210210                tss_p = (struct tss *) malloc(sizeof(tss_t), FRAME_ATOMIC);
    211211                if (!tss_p)
    212                         panic("could not allocate TSS\n");
     212                        panic("Cannot allocate TSS.");
    213213        }
    214214
  • kernel/arch/arm32/src/mm/page.c

    rc571f42 rf651e80  
    9191        if (last_frame + ALIGN_UP(size, PAGE_SIZE) >
    9292            KA2PA(KERNEL_ADDRESS_SPACE_END_ARCH)) {
    93                 panic("Unable to map physical memory %p (%d bytes)",
     93                panic("Unable to map physical memory %p (%d bytes).",
    9494                    physaddr, size)
    9595        }
  • kernel/arch/arm32/src/mm/page_fault.c

    rc571f42 rf651e80  
    143143        /* undefined instructions */
    144144        if (instr.condition == 0xf) {
    145                 panic("page_fault - instruction doesn't access memory "
    146                     "(instr_code: %x, badvaddr:%x)", instr, badvaddr);
     145                panic("page_fault - instruction does not access memory "
     146                    "(instr_code: %x, badvaddr:%x).", instr, badvaddr);
    147147                return PF_ACCESS_EXEC;
    148148        }
     
    163163
    164164        panic("page_fault - instruction doesn't access memory "
    165             "(instr_code: %x, badvaddr:%x)", instr, badvaddr);
     165            "(instr_code: %x, badvaddr:%x).", instr, badvaddr);
    166166
    167167        return PF_ACCESS_EXEC;
     
    189189                    access);
    190190
    191                 fault_if_from_uspace(istate, "Page fault: %#x", badvaddr);
    192                 panic("Page fault\n");
     191                fault_if_from_uspace(istate, "Page fault: %#x.", badvaddr);
     192                panic("Page fault.");
    193193        }
    194194}
     
    206206                dprintf("prefetch_abort\n");
    207207                print_istate(istate);
    208                 panic("page fault - prefetch_abort at address: %x\n",
     208                panic("page fault - prefetch_abort at address: %x.",
    209209                    istate->pc);
    210210        }
  • kernel/arch/ia32/src/drivers/vesa.c

    rc571f42 rf651e80  
    8484                break;
    8585        default:
    86                 panic("Unsupported bits per pixel");
     86                panic("Unsupported bits per pixel.");
    8787        }
    8888       
  • kernel/arch/ia32/src/interrupt.c

    rc571f42 rf651e80  
    9090                eoi_function();
    9191        else
    92                 panic("no eoi_function\n");
     92                panic("No eoi_function.");
    9393
    9494}
     
    9696static void null_interrupt(int n, istate_t *istate)
    9797{
    98         fault_if_from_uspace(istate, "Unserviced interrupt: %d", n);
    99 
    100         decode_istate(istate);
    101         panic("Unserviced interrupt: %d\n", n);
     98        fault_if_from_uspace(istate, "Unserviced interrupt: %d.", n);
     99
     100        decode_istate(istate);
     101        panic("Unserviced interrupt: %d.", n);
    102102}
    103103
     
    123123                        return;
    124124                }
    125                 fault_if_from_uspace(istate, "General protection fault");
     125                fault_if_from_uspace(istate, "General protection fault.");
    126126        }
    127127
    128128        decode_istate(istate);
    129         panic("General protection fault\n");
     129        panic("General protection fault.");
    130130}
    131131
    132132static void ss_fault(int n __attribute__((unused)), istate_t *istate)
    133133{
    134         fault_if_from_uspace(istate, "Stack fault");
    135 
    136         decode_istate(istate);
    137         panic("Stack fault\n");
     134        fault_if_from_uspace(istate, "Stack fault.");
     135
     136        decode_istate(istate);
     137        panic("Stack fault.");
    138138}
    139139
     
    145145                : "=m" (mxcsr)
    146146        );
    147         fault_if_from_uspace(istate, "SIMD FP exception(19), MXCSR: %#zx",
     147        fault_if_from_uspace(istate, "SIMD FP exception(19), MXCSR: %#zx.",
    148148            (unative_t) mxcsr);
    149149
    150150        decode_istate(istate);
    151151        printf("MXCSR: %#lx\n", mxcsr);
    152         panic("SIMD FP exception(19)\n");
     152        panic("SIMD FP exception(19).");
    153153}
    154154
     
    158158        scheduler_fpu_lazy_request();
    159159#else
    160         fault_if_from_uspace(istate, "FPU fault");
    161         panic("FPU fault");
     160        fault_if_from_uspace(istate, "FPU fault.");
     161        panic("FPU fault.");
    162162#endif
    163163}
     
    234234                enable_irqs_function(irqmask);
    235235        else
    236                 panic("no enable_irqs_function\n");
     236                panic("No enable_irqs_function.");
    237237}
    238238
     
    242242                disable_irqs_function(irqmask);
    243243        else
    244                 panic("no disable_irqs_function\n");
     244                panic("No disable_irqs_function.");
    245245}
    246246
  • kernel/arch/ia32/src/mm/page.c

    rc571f42 rf651e80  
    8080{
    8181        if (last_frame + ALIGN_UP(size, PAGE_SIZE) > KA2PA(KERNEL_ADDRESS_SPACE_END_ARCH))
    82                 panic("Unable to map physical memory %p (%d bytes)", physaddr, size)
     82                panic("Unable to map physical memory %p (%d bytes).", physaddr, size)
    8383       
    8484        uintptr_t virtaddr = PA2KA(last_frame);
     
    102102               
    103103        if (istate->error_word & PFERR_CODE_RSVD)
    104                 panic("Reserved bit set in page directory.\n");
     104                panic("Reserved bit set in page directory.");
    105105
    106106        if (istate->error_word & PFERR_CODE_RW)
     
    110110       
    111111        if (as_page_fault(page, access, istate) == AS_PF_FAULT) {
    112                 fault_if_from_uspace(istate, "Page fault: %#x", page);
     112                fault_if_from_uspace(istate, "Page fault: %#x.", page);
    113113               
    114114                decode_istate(istate);
    115115                printf("page fault address: %#lx\n", page);
    116                 panic("page fault\n");
     116                panic("Page fault.");
    117117        }
    118118}
  • kernel/arch/ia32/src/pm.c

    rc571f42 rf651e80  
    199199                tss_p = (tss_t *) malloc(sizeof(tss_t), FRAME_ATOMIC);
    200200                if (!tss_p)
    201                         panic("could not allocate TSS\n");
     201                        panic("Cannot allocate TSS.");
    202202        }
    203203
  • kernel/arch/ia32/src/smp/smp.c

    rc571f42 rf651e80  
    7676            FRAME_ATOMIC | FRAME_KA);
    7777        if (!l_apic_address)
    78                 panic("cannot allocate address for l_apic\n");
     78                panic("Cannot allocate address for l_apic.");
    7979
    8080        io_apic_address = (uintptr_t) frame_alloc(ONE_FRAME,
    8181            FRAME_ATOMIC | FRAME_KA);
    8282        if (!io_apic_address)
    83                 panic("cannot allocate address for io_apic\n");
     83                panic("Cannot allocate address for io_apic.");
    8484
    8585        if (config.cpu_count > 1) {             
     
    158158                    sizeof(struct descriptor), FRAME_ATOMIC | FRAME_LOW_4_GiB);
    159159                if (!gdt_new)
    160                         panic("couldn't allocate memory for GDT\n");
     160                        panic("Cannot allocate memory for GDT.");
    161161
    162162                memcpy(gdt_new, gdt, GDT_ITEMS * sizeof(struct descriptor));
  • kernel/arch/ia32xen/src/interrupt.c

    rc571f42 rf651e80  
    8989                eoi_function();
    9090        else
    91                 panic("no eoi_function\n");
     91                panic("No eoi_function.");
    9292
    9393}
     
    9595static void null_interrupt(int n, istate_t *istate)
    9696{
    97         fault_if_from_uspace(istate, "Unserviced interrupt: %d", n);
    98 
    99         decode_istate(istate);
    100         panic("Unserviced interrupt: %d\n", n);
     97        fault_if_from_uspace(istate, "Unserviced interrupt: %d.", n);
     98
     99        decode_istate(istate);
     100        panic("Unserviced interrupt: %d.", n);
    101101}
    102102
     
    122122                        return;
    123123                }
    124                 fault_if_from_uspace(istate, "General protection fault");
     124                fault_if_from_uspace(istate, "General protection fault.");
    125125        }
    126126
    127127        decode_istate(istate);
    128         panic("General protection fault\n");
     128        panic("General protection fault.");
    129129}
    130130
    131131static void ss_fault(int n, istate_t *istate)
    132132{
    133         fault_if_from_uspace(istate, "Stack fault");
    134 
    135         decode_istate(istate);
    136         panic("Stack fault\n");
     133        fault_if_from_uspace(istate, "Stack fault.");
     134
     135        decode_istate(istate);
     136        panic("Stack fault.");
    137137}
    138138
     
    145145                :"=m"(mxcsr)
    146146        );
    147         fault_if_from_uspace(istate, "SIMD FP exception(19), MXCSR: %#zx",
     147        fault_if_from_uspace(istate, "SIMD FP exception(19), MXCSR: %#zx.",
    148148                             (unative_t)mxcsr);
    149149
    150150        decode_istate(istate);
    151151        printf("MXCSR: %#zx\n",(unative_t)(mxcsr));
    152         panic("SIMD FP exception(19)\n");
     152        panic("SIMD FP exception(19).");
    153153}
    154154
     
    158158        scheduler_fpu_lazy_request();
    159159#else
    160         fault_if_from_uspace(istate, "FPU fault");
    161         panic("FPU fault");
     160        fault_if_from_uspace(istate, "FPU fault.");
     161        panic("FPU fault.");
    162162#endif
    163163}
     
    234234                enable_irqs_function(irqmask);
    235235        else
    236                 panic("no enable_irqs_function\n");
     236                panic("No enable_irqs_function.");
    237237}
    238238
     
    242242                disable_irqs_function(irqmask);
    243243        else
    244                 panic("no disable_irqs_function\n");
     244                panic("No disable_irqs_function.");
    245245}
    246246
  • kernel/arch/ia32xen/src/mm/page.c

    rc571f42 rf651e80  
    6767       
    6868        if (istate->error_word & PFERR_CODE_RSVD)
    69                 panic("Reserved bit set in page directory.\n");
     69                panic("Reserved bit set in page directory.");
    7070       
    7171        if (istate->error_word & PFERR_CODE_RW)
     
    7575       
    7676        if (as_page_fault(page, access, istate) == AS_PF_FAULT) {
    77                 fault_if_from_uspace(istate, "Page fault: %#x", page);
     77                fault_if_from_uspace(istate, "Page fault: %#x.", page);
    7878               
    7979                decode_istate(istate);
    80                 printf("Page fault address: %#x\n", page);
    81                 panic("Page fault\n");
     80                printf("Page fault address: %#x.\n", page);
     81                panic("Page fault.");
    8282        }
    8383}
  • kernel/arch/ia32xen/src/pm.c

    rc571f42 rf651e80  
    169169                tss_p = (tss_t *) malloc(sizeof(tss_t), FRAME_ATOMIC);
    170170                if (!tss_p)
    171                         panic("could not allocate TSS\n");
     171                        panic("Cannot allocate TSS.");
    172172        }
    173173
  • kernel/arch/ia32xen/src/smp/smp.c

    rc571f42 rf651e80  
    7373        l_apic_address = (uintptr_t) frame_alloc(ONE_FRAME, FRAME_ATOMIC | FRAME_KA);
    7474        if (!l_apic_address)
    75                 panic("cannot allocate address for l_apic\n");
     75                panic("Cannot allocate address for l_apic.");
    7676
    7777        io_apic_address = (uintptr_t) frame_alloc(ONE_FRAME, FRAME_ATOMIC | FRAME_KA);
    7878        if (!io_apic_address)
    79                 panic("cannot allocate address for io_apic\n");
     79                panic("Cannot allocate address for io_apic.");
    8080
    8181        if (config.cpu_count > 1) {             
     
    144144                 */
    145145                if (!(gdt_new = (struct descriptor *) malloc(GDT_ITEMS * sizeof(struct descriptor), FRAME_ATOMIC)))
    146                         panic("couldn't allocate memory for GDT\n");
     146                        panic("Cannot allocate memory for GDT.");
    147147
    148148                memcpy(gdt_new, gdt, GDT_ITEMS * sizeof(struct descriptor));
  • kernel/arch/ia64/src/ia64.c

    rc571f42 rf651e80  
    180180        t = thread_create(kkbdpoll, NULL, TASK, 0, "kkbdpoll", true);
    181181        if (!t)
    182                 panic("cannot create kkbdpoll\n");
     182                panic("Cannot create kkbdpoll.");
    183183        thread_ready(t);
    184184#endif         
     
    195195        t = thread_create(i8042_kkbdpoll, NULL, TASK, 0, "kkbdpoll", true);
    196196        if (!t)
    197                 panic("cannot create kkbdpoll\n");
     197                panic("Cannot create kkbdpoll.");
    198198        thread_ready(t);
    199199#endif
  • kernel/arch/ia64/src/interrupt.c

    rc571f42 rf651e80  
    187187        }
    188188
    189         fault_if_from_uspace(istate, "General Exception (%s)", desc);
     189        fault_if_from_uspace(istate, "General Exception (%s).", desc);
    190190
    191191        dump_interrupted_context(istate);
    192         panic("General Exception (%s)\n", desc);
     192        panic("General Exception (%s).", desc);
    193193}
    194194
     
    198198        scheduler_fpu_lazy_request();   
    199199#else
    200         fault_if_from_uspace(istate, "Interruption: %#hx (%s)",
     200        fault_if_from_uspace(istate, "Interruption: %#hx (%s).",
    201201            (uint16_t) vector, vector_to_string(vector));
    202202        dump_interrupted_context(istate);
    203         panic("Interruption: %#hx (%s)\n", (uint16_t) vector,
     203        panic("Interruption: %#hx (%s).", (uint16_t) vector,
    204204            vector_to_string(vector));
    205205#endif
     
    229229void universal_handler(uint64_t vector, istate_t *istate)
    230230{
    231         fault_if_from_uspace(istate, "Interruption: %#hx (%s)",
     231        fault_if_from_uspace(istate, "Interruption: %#hx (%s).",
    232232            (uint16_t) vector, vector_to_string(vector));
    233233        dump_interrupted_context(istate);
    234         panic("Interruption: %#hx (%s)\n", (uint16_t) vector,
     234        panic("Interruption: %#hx (%s).", (uint16_t) vector,
    235235            vector_to_string(vector));
    236236}
     
    270270                        spinlock_unlock(&irq->lock);
    271271                } else {
    272                         panic("\nUnhandled Internal Timer Interrupt (%d)\n",
     272                        panic("Unhandled Internal Timer Interrupt (%d).",
    273273                            ivr.vector);
    274274                }
  • kernel/arch/ia64/src/mm/tlb.c

    rc571f42 rf651e80  
    473473                page_table_unlock(AS, true);
    474474                if (as_page_fault(va, PF_ACCESS_EXEC, istate) == AS_PF_FAULT) {
    475                         fault_if_from_uspace(istate,"Page fault at %p",va);
    476                         panic("%s: va=%p, rid=%d, iip=%p\n", __func__, va, rid,
     475                        fault_if_from_uspace(istate,"Page fault at %p.",va);
     476                        panic("%s: va=%p, rid=%d, iip=%p.", __func__, va, rid,
    477477                            istate->cr_iip);
    478478                }
     
    532532                        } else {
    533533                                fault_if_from_uspace(istate,
    534                                     "IO access fault at %p", va);
     534                                    "IO access fault at %p.", va);
    535535                        }
    536536                }
     
    584584                 */
    585585                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
    586                         fault_if_from_uspace(istate,"Page fault at %p",va);
    587                         panic("%s: va=%p, rid=%d, iip=%p\n", __func__, va, rid,
     586                        fault_if_from_uspace(istate,"Page fault at %p.",va);
     587                        panic("%s: va=%p, rid=%d, iip=%p.", __func__, va, rid,
    588588                            istate->cr_iip);
    589589                }
     
    600600void data_nested_tlb_fault(uint64_t vector, istate_t *istate)
    601601{
    602         panic("%s\n", __func__);
     602        panic("%s.", __func__);
    603603}
    604604
     
    631631        } else {
    632632                if (as_page_fault(va, PF_ACCESS_WRITE, istate) == AS_PF_FAULT) {
    633                         fault_if_from_uspace(istate,"Page fault at %p",va);
    634                         panic("%s: va=%p, rid=%d, iip=%p\n", __func__, va, rid,
     633                        fault_if_from_uspace(istate,"Page fault at %p.",va);
     634                        panic("%s: va=%p, rid=%d, iip=%p.", __func__, va, rid,
    635635                            istate->cr_iip);
    636636                }
     
    667667        } else {
    668668                if (as_page_fault(va, PF_ACCESS_EXEC, istate) == AS_PF_FAULT) {
    669                         fault_if_from_uspace(istate, "Page fault at %p", va);
    670                         panic("%s: va=%p, rid=%d, iip=%p\n", __func__, va, rid,
     669                        fault_if_from_uspace(istate, "Page fault at %p.", va);
     670                        panic("%s: va=%p, rid=%d, iip=%p.", __func__, va, rid,
    671671                            istate->cr_iip);
    672672                }
     
    703703        } else {
    704704                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
    705                         fault_if_from_uspace(istate, "Page fault at %p", va);
    706                         panic("%s: va=%p, rid=%d, iip=%p\n", __func__, va, rid,
     705                        fault_if_from_uspace(istate, "Page fault at %p.", va);
     706                        panic("%s: va=%p, rid=%d, iip=%p.", __func__, va, rid,
    707707                            istate->cr_iip);
    708708                }
     
    744744                page_table_unlock(AS, true);
    745745                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
    746                         fault_if_from_uspace(istate, "Page fault at %p", va);
    747                         panic("%s: va=%p, rid=%d\n", __func__, va, rid);
     746                        fault_if_from_uspace(istate, "Page fault at %p.", va);
     747                        panic("%s: va=%p, rid=%d.", __func__, va, rid);
    748748                }
    749749        }
  • kernel/arch/mips32/src/cache.c

    rc571f42 rf651e80  
    3939void cache_error(istate_t *istate)
    4040{
    41         panic("cache_error exception (epc=%p)\n", istate->epc);
     41        panic("cache_error exception (epc=%p).", istate->epc);
    4242}
    4343
  • kernel/arch/mips32/src/debugger.c

    rc571f42 rf651e80  
    317317        /* test branch delay slot */
    318318        if (cp0_cause_read() & 0x80000000)
    319                 panic("Breakpoint in branch delay slot not supported.\n");
     319                panic("Breakpoint in branch delay slot not supported.");
    320320
    321321        spinlock_lock(&bkpoint_lock);
  • kernel/arch/mips32/src/exception.c

    rc571f42 rf651e80  
    8989static void unhandled_exception(int n, istate_t *istate)
    9090{
    91         fault_if_from_uspace(istate, "Unhandled exception %s", exctable[n]);
     91        fault_if_from_uspace(istate, "Unhandled exception %s.", exctable[n]);
    9292       
    9393        print_regdump(istate);
    94         panic("Unhandled exception %s.\n", exctable[n]);
     94        panic("Unhandled exception %s.", exctable[n]);
    9595}
    9696
     
    133133                scheduler_fpu_lazy_request();
    134134        else {
    135                 fault_if_from_uspace(istate, "Unhandled Coprocessor Unusable Exception");
    136                 panic("Unhandled Coprocessor Unusable Exception.\n");
     135                fault_if_from_uspace(istate, "Unhandled Coprocessor Unusable Exception.");
     136                panic("Unhandled Coprocessor Unusable Exception.");
    137137        }
    138138}
     
    171171static void syscall_exception(int n, istate_t *istate)
    172172{
    173         panic("Syscall is handled through shortcut");
     173        panic("Syscall is handled through shortcut.");
    174174}
    175175
  • kernel/arch/mips32/src/mm/tlb.c

    rc571f42 rf651e80  
    116116                        return;
    117117                default:
    118                         panic("unexpected pfrc (%d)\n", pfrc);
     118                        panic("Unexpected pfrc (%d).", pfrc);
    119119                }
    120120        }
     
    200200                        return;
    201201                default:
    202                         panic("unexpected pfrc (%d)\n", pfrc);
     202                        panic("Unexpected pfrc (%d).", pfrc);
    203203                }
    204204        }
     
    283283                        return;
    284284                default:
    285                         panic("unexpected pfrc (%d)\n", pfrc);
     285                        panic("Unexpected pfrc (%d).", pfrc);
    286286                }
    287287        }
     
    331331                sym2 = s;
    332332
    333         fault_if_from_uspace(istate, "TLB Refill Exception on %p",
     333        fault_if_from_uspace(istate, "TLB Refill Exception on %p.",
    334334            cp0_badvaddr_read());
    335         panic("%x: TLB Refill Exception at %x(%s<-%s).\n", cp0_badvaddr_read(),
     335        panic("%x: TLB Refill Exception at %x(%s<-%s).", cp0_badvaddr_read(),
    336336            istate->epc, symbol, sym2);
    337337}
     
    345345        if (s)
    346346                symbol = s;
    347         fault_if_from_uspace(istate, "TLB Invalid Exception on %p",
     347        fault_if_from_uspace(istate, "TLB Invalid Exception on %p.",
    348348            cp0_badvaddr_read());
    349         panic("%x: TLB Invalid Exception at %x(%s).\n", cp0_badvaddr_read(),
     349        panic("%x: TLB Invalid Exception at %x(%s).", cp0_badvaddr_read(),
    350350            istate->epc, symbol);
    351351}
     
    358358        if (s)
    359359                symbol = s;
    360         fault_if_from_uspace(istate, "TLB Modified Exception on %p",
     360        fault_if_from_uspace(istate, "TLB Modified Exception on %p.",
    361361            cp0_badvaddr_read());
    362         panic("%x: TLB Modified Exception at %x(%s).\n", cp0_badvaddr_read(),
     362        panic("%x: TLB Modified Exception at %x(%s).", cp0_badvaddr_read(),
    363363            istate->epc, symbol);
    364364}
     
    434434                        break;
    435435                default:
    436                         panic("unexpected rc (%d)\n", rc);
     436                        panic("Unexpected rc (%d).", rc);
    437437                }
    438438               
  • kernel/arch/ppc32/src/mm/page.c

    rc571f42 rf651e80  
    5050        if (last_frame + ALIGN_UP(size, PAGE_SIZE) >
    5151            KA2PA(KERNEL_ADDRESS_SPACE_END_ARCH))
    52                 panic("Unable to map physical memory %p (%" PRIs " bytes)",
     52                panic("Unable to map physical memory %p (%" PRIs " bytes).",
    5353                    physaddr, size)
    5454       
  • kernel/arch/ppc32/src/mm/tlb.c

    rc571f42 rf651e80  
    101101                        return NULL;
    102102                default:
    103                         panic("unexpected rc (%d)\n", rc);
     103                        panic("Unexpected rc (%d).", rc);
    104104                }       
    105105        }
     
    120120
    121121        fault_if_from_uspace(istate,
    122             "%p: PHT Refill Exception at %p (%s<-%s)", badvaddr,
     122            "%p: PHT Refill Exception at %p (%s<-%s).", badvaddr,
    123123            istate->pc, symbol, sym2);
    124         panic("%p: PHT Refill Exception at %p (%s<-%s)\n", badvaddr,
     124        panic("%p: PHT Refill Exception at %p (%s<-%s).", badvaddr,
    125125            istate->pc, symbol, sym2);
    126126}
     
    315315                        return;
    316316                default:
    317                         panic("Unexpected pfrc (%d)\n", pfrc);
     317                        panic("Unexpected pfrc (%d).", pfrc);
    318318                }
    319319        }
  • kernel/arch/ppc32/src/ppc32.c

    rc571f42 rf651e80  
    9393                        break;
    9494                default:
    95                         panic("Unsupported bits per pixel");
     95                        panic("Unsupported bits per pixel.");
    9696                }
    9797                fb_properties_t prop = {
  • kernel/arch/ppc64/include/exception.h

    rc571f42 rf651e80  
    8888static inline int istate_from_uspace(istate_t *istate)
    8989{
    90         panic("istate_from_uspace not yet implemented");
     90        panic("istate_from_uspace not yet implemented.");
    9191        return 0;
    9292}
  • kernel/arch/ppc64/src/mm/page.c

    rc571f42 rf651e80  
    107107                                return NULL;
    108108                        default:
    109                                 panic("unexpected rc (%d)\n", rc);
     109                                panic("Unexpected rc (%d).", rc);
    110110                }       
    111111        }
     
    124124        if (s)
    125125                sym2 = s;
    126         panic("%p: PHT Refill Exception at %p (%s<-%s)\n", badvaddr, istate->pc, symbol, sym2);
     126        panic("%p: PHT Refill Exception at %p (%s<-%s).", badvaddr, istate->pc, symbol, sym2);
    127127}
    128128
     
    234234                                return;
    235235                        default:
    236                                 panic("Unexpected pfrc (%d)\n", pfrc);
     236                                panic("Unexpected pfrc (%d).", pfrc);
    237237                }
    238238        }
     
    289289{
    290290        if (last_frame + ALIGN_UP(size, PAGE_SIZE) > KA2PA(KERNEL_ADDRESS_SPACE_END_ARCH))
    291                 panic("Unable to map physical memory %p (%" PRIs " bytes)", physaddr, size)
     291                panic("Unable to map physical memory %p (%" PRIs " bytes).", physaddr, size)
    292292       
    293293        uintptr_t virtaddr = PA2KA(last_frame);
  • kernel/arch/ppc64/src/ppc64.c

    rc571f42 rf651e80  
    8686                        break;
    8787                default:
    88                         panic("Unsupported bits per pixel");
     88                        panic("Unsupported bits per pixel.");
    8989                }
    9090                fb_init(bootinfo.screen.addr, bootinfo.screen.width, bootinfo.screen.height, bootinfo.screen.scanline, visual);
  • kernel/arch/sparc64/src/console.c

    rc571f42 rf651e80  
    7878        prop = ofw_tree_getprop(aliases, "screen");
    7979        if (!prop)
    80                 panic("Can't find property \"screen\".\n");
     80                panic("Cannot find property 'screen'.");
    8181        if (!prop->value)
    82                 panic("Can't find screen alias.\n");
     82                panic("Cannot find screen alias.");
    8383        screen = ofw_tree_lookup(prop->value);
    8484        if (!screen)
    85                 panic("Can't find %s\n", prop->value);
     85                panic("Cannot find %s.", prop->value);
    8686
    8787        scr_init(screen);
     
    8989        prop = ofw_tree_getprop(aliases, "keyboard");
    9090        if (!prop)
    91                 panic("Can't find property \"keyboard\".\n");
     91                panic("Cannot find property 'keyboard'.");
    9292        if (!prop->value)
    93                 panic("Can't find keyboard alias.\n");
     93                panic("Cannot find keyboard alias.");
    9494        keyboard = ofw_tree_lookup(prop->value);
    9595        if (!keyboard)
    96                 panic("Can't find %s\n", prop->value);
     96                panic("Cannot find %s.", prop->value);
    9797
    9898        kbd_init(keyboard);
     
    116116        aliases = ofw_tree_lookup("/aliases");
    117117        if (!aliases)
    118                 panic("Can't find /aliases.\n");
     118                panic("Cannot find '/aliases'.");
    119119       
    120120        /* "def-cn" = "default console" */
  • kernel/arch/sparc64/src/drivers/fhc.c

    rc571f42 rf651e80  
    9797                break;
    9898        default:
    99                 panic("Unexpected INR (%d)\n", inr);
     99                panic("Unexpected INR (%d).", inr);
    100100                break;
    101101        }
     
    112112                break;
    113113        default:
    114                 panic("Unexpected INR (%d)\n", inr);
     114                panic("Unexpected INR (%d).", inr);
    115115                break;
    116116        }
  • kernel/arch/sparc64/src/drivers/kbd.c

    rc571f42 rf651e80  
    8888        prop = ofw_tree_getprop(node, "interrupts");
    8989        if ((!prop) || (!prop->value))
    90                 panic("Can't find \"interrupts\" property.\n");
     90                panic("Cannot find 'interrupt' property.");
    9191        interrupts = *((uint32_t *) prop->value);
    9292       
     
    9696        prop = ofw_tree_getprop(node, "reg");
    9797        if ((!prop) || (!prop->value))
    98                 panic("Can't find \"reg\" property.\n");
     98                panic("Cannot find 'reg' property.");
    9999       
    100100        uintptr_t pa;
     
    134134               
    135135        default:
    136                 panic("Unexpected keyboard type.\n");
     136                panic("Unexpected keyboard type.");
    137137        }
    138138       
  • kernel/arch/sparc64/src/drivers/scr.c

    rc571f42 rf651e80  
    105105        prop = ofw_tree_getprop(node, "reg");
    106106        if (!prop)
    107                 panic("Can't find \"reg\" property.\n");
     107                panic("Cannot find 'reg' property.");
    108108
    109109        switch (scr_type) {
     
    224224                break;
    225225        default:
    226                 panic("Unexpected type.\n");
     226                panic("Unexpected type.");
    227227        }
    228228
  • kernel/arch/sparc64/src/drivers/sgcn.c

    rc571f42 rf651e80  
    200200        chosen = ofw_tree_lookup("/chosen");
    201201        if (!chosen)
    202                 panic("Can't find /chosen.\n");
     202                panic("Cannot find '/chosen'.");
    203203
    204204        iosram_toc = ofw_tree_getprop(chosen, "iosram-toc");
    205205        if (!iosram_toc)
    206                 panic("Can't find property \"iosram-toc\".\n");
     206                panic("Cannot find property 'iosram-toc'.");
    207207        if (!iosram_toc->value)
    208                 panic("Can't find SRAM TOC.\n");
     208                panic("Cannot find SRAM TOC.");
    209209
    210210        sram_begin_physical = SBBC_START + SBBC_SRAM_OFFSET
     
    329329static void sgcn_irq_handler(irq_t *irq, void *arg, ...)
    330330{
    331         panic("Not yet implemented, SGCN works in polled mode.\n");
     331        panic("Not yet implemented, SGCN works in polled mode.");
    332332}
    333333
  • kernel/arch/sparc64/src/mm/tlb.c

    rc571f42 rf651e80  
    425425    const char *str)
    426426{
    427         fault_if_from_uspace(istate, "%s", str);
     427        fault_if_from_uspace(istate, "%s.", str);
    428428        dump_istate(istate);
    429         panic("%s\n", str);
     429        panic("%s.", str);
    430430}
    431431
     
    437437        va = tag.vpn << MMU_PAGE_WIDTH;
    438438        if (tag.context) {
    439                 fault_if_from_uspace(istate, "%s, Page=%p (ASID=%d)", str, va,
     439                fault_if_from_uspace(istate, "%s, Page=%p (ASID=%d).", str, va,
    440440                    tag.context);
    441441        }
    442442        dump_istate(istate);
    443         printf("Faulting page: %p, ASID=%d\n", va, tag.context);
    444         panic("%s\n", str);
     443        printf("Faulting page: %p, ASID=%d.\n", va, tag.context);
     444        panic("%s.", str);
    445445}
    446446
     
    453453
    454454        if (tag.context) {
    455                 fault_if_from_uspace(istate, "%s, Page=%p (ASID=%d)", str, va,
     455                fault_if_from_uspace(istate, "%s, Page=%p (ASID=%d).", str, va,
    456456                    tag.context);
    457457        }
    458458        printf("Faulting page: %p, ASID=%d\n", va, tag.context);
    459459        dump_istate(istate);
    460         panic("%s\n", str);
     460        panic("%s.", str);
    461461}
    462462
  • kernel/arch/sparc64/src/smp/ipi.c

    rc571f42 rf651e80  
    9999        status = asi_u64_read(ASI_INTR_DISPATCH_STATUS, 0);
    100100        if (status & INTR_DISPATCH_STATUS_BUSY)
    101                 panic("Interrupt Dispatch Status busy bit set\n");
     101                panic("Interrupt Dispatch Status busy bit set.");
    102102       
    103103        ASSERT(!(pstate_read() & PSTATE_IE_BIT));
     
    152152                break;
    153153        default:
    154                 panic("Unknown IPI (%d).\n", ipi);
     154                panic("Unknown IPI (%d).", ipi);
    155155                break;
    156156        }
  • kernel/arch/sparc64/src/sparc64.c

    rc571f42 rf651e80  
    111111                t = thread_create(kkbdpoll, NULL, TASK, 0, "kkbdpoll", true);
    112112                if (!t)
    113                         panic("cannot create kkbdpoll\n");
     113                        panic("Cannot create kkbdpoll.");
    114114                thread_ready(t);
    115115        }
  • kernel/arch/sparc64/src/trap/exception.c

    rc571f42 rf651e80  
    5454void instruction_access_exception(int n, istate_t *istate)
    5555{
    56         fault_if_from_uspace(istate, "%s", __func__);
    57         dump_istate(istate);
    58         panic("%s\n", __func__);
     56        fault_if_from_uspace(istate, "%s.", __func__);
     57        dump_istate(istate);
     58        panic("%s.", __func__);
    5959}
    6060
     
    6262void instruction_access_error(int n, istate_t *istate)
    6363{
    64         fault_if_from_uspace(istate, "%s", __func__);
    65         dump_istate(istate);
    66         panic("%s\n", __func__);
     64        fault_if_from_uspace(istate, "%s.", __func__);
     65        dump_istate(istate);
     66        panic("%s.", __func__);
    6767}
    6868
     
    7070void illegal_instruction(int n, istate_t *istate)
    7171{
    72         fault_if_from_uspace(istate, "%s", __func__);
    73         dump_istate(istate);
    74         panic("%s\n", __func__);
     72        fault_if_from_uspace(istate, "%s.", __func__);
     73        dump_istate(istate);
     74        panic("%s.", __func__);
    7575}
    7676
     
    7878void privileged_opcode(int n, istate_t *istate)
    7979{
    80         fault_if_from_uspace(istate, "%s", __func__);
    81         dump_istate(istate);
    82         panic("%s\n", __func__);
     80        fault_if_from_uspace(istate, "%s.", __func__);
     81        dump_istate(istate);
     82        panic("%s.", __func__);
    8383}
    8484
     
    8686void unimplemented_LDD(int n, istate_t *istate)
    8787{
    88         fault_if_from_uspace(istate, "%s", __func__);
    89         dump_istate(istate);
    90         panic("%s\n", __func__);
     88        fault_if_from_uspace(istate, "%s.", __func__);
     89        dump_istate(istate);
     90        panic("%s.", __func__);
    9191}
    9292
     
    9494void unimplemented_STD(int n, istate_t *istate)
    9595{
    96         fault_if_from_uspace(istate, "%s", __func__);
    97         dump_istate(istate);
    98         panic("%s\n", __func__);
     96        fault_if_from_uspace(istate, "%s.", __func__);
     97        dump_istate(istate);
     98        panic("%s.", __func__);
    9999}
    100100
     
    114114        scheduler_fpu_lazy_request();
    115115#else
    116         fault_if_from_uspace(istate, "%s", __func__);
    117         dump_istate(istate);
    118         panic("%s\n", __func__);
     116        fault_if_from_uspace(istate, "%s.", __func__);
     117        dump_istate(istate);
     118        panic("%s.", __func__);
    119119#endif
    120120}
     
    123123void fp_exception_ieee_754(int n, istate_t *istate)
    124124{
    125         fault_if_from_uspace(istate, "%s", __func__);
    126         dump_istate(istate);
    127         panic("%s\n", __func__);
     125        fault_if_from_uspace(istate, "%s.", __func__);
     126        dump_istate(istate);
     127        panic("%s.", __func__);
    128128}
    129129
     
    131131void fp_exception_other(int n, istate_t *istate)
    132132{
    133         fault_if_from_uspace(istate, "%s", __func__);
    134         dump_istate(istate);
    135         panic("%s\n", __func__);
     133        fault_if_from_uspace(istate, "%s.", __func__);
     134        dump_istate(istate);
     135        panic("%s.", __func__);
    136136}
    137137
     
    139139void tag_overflow(int n, istate_t *istate)
    140140{
    141         fault_if_from_uspace(istate, "%s", __func__);
    142         dump_istate(istate);
    143         panic("%s\n", __func__);
     141        fault_if_from_uspace(istate, "%s.", __func__);
     142        dump_istate(istate);
     143        panic("%s.", __func__);
    144144}
    145145
     
    147147void division_by_zero(int n, istate_t *istate)
    148148{
    149         fault_if_from_uspace(istate, "%s", __func__);
    150         dump_istate(istate);
    151         panic("%s\n", __func__);
     149        fault_if_from_uspace(istate, "%s.", __func__);
     150        dump_istate(istate);
     151        panic("%s.", __func__);
    152152}
    153153
     
    155155void data_access_exception(int n, istate_t *istate)
    156156{
    157         fault_if_from_uspace(istate, "%s", __func__);
     157        fault_if_from_uspace(istate, "%s.", __func__);
    158158        dump_istate(istate);
    159159        dump_sfsr_and_sfar();
    160         panic("%s\n", __func__);
     160        panic("%s.", __func__);
    161161}
    162162
     
    164164void data_access_error(int n, istate_t *istate)
    165165{
    166         fault_if_from_uspace(istate, "%s", __func__);
    167         dump_istate(istate);
    168         panic("%s\n", __func__);
     166        fault_if_from_uspace(istate, "%s.", __func__);
     167        dump_istate(istate);
     168        panic("%s.", __func__);
    169169}
    170170
     
    172172void mem_address_not_aligned(int n, istate_t *istate)
    173173{
    174         fault_if_from_uspace(istate, "%s", __func__);
    175         dump_istate(istate);
    176         panic("%s\n", __func__);
     174        fault_if_from_uspace(istate, "%s.", __func__);
     175        dump_istate(istate);
     176        panic("%s.", __func__);
    177177}
    178178
     
    180180void LDDF_mem_address_not_aligned(int n, istate_t *istate)
    181181{
    182         fault_if_from_uspace(istate, "%s", __func__);
    183         dump_istate(istate);
    184         panic("%s\n", __func__);
     182        fault_if_from_uspace(istate, "%s.", __func__);
     183        dump_istate(istate);
     184        panic("%s.", __func__);
    185185}
    186186
     
    188188void STDF_mem_address_not_aligned(int n, istate_t *istate)
    189189{
    190         fault_if_from_uspace(istate, "%s", __func__);
    191         dump_istate(istate);
    192         panic("%s\n", __func__);
     190        fault_if_from_uspace(istate, "%s.", __func__);
     191        dump_istate(istate);
     192        panic("%s.", __func__);
    193193}
    194194
     
    196196void privileged_action(int n, istate_t *istate)
    197197{
    198         fault_if_from_uspace(istate, "%s", __func__);
    199         dump_istate(istate);
    200         panic("%s\n", __func__);
     198        fault_if_from_uspace(istate, "%s.", __func__);
     199        dump_istate(istate);
     200        panic("%s.", __func__);
    201201}
    202202
     
    204204void LDQF_mem_address_not_aligned(int n, istate_t *istate)
    205205{
    206         fault_if_from_uspace(istate, "%s", __func__);
    207         dump_istate(istate);
    208         panic("%s\n", __func__);
     206        fault_if_from_uspace(istate, "%s.", __func__);
     207        dump_istate(istate);
     208        panic("%s.", __func__);
    209209}
    210210
     
    212212void STQF_mem_address_not_aligned(int n, istate_t *istate)
    213213{
    214         fault_if_from_uspace(istate, "%s", __func__);
    215         dump_istate(istate);
    216         panic("%s\n", __func__);
     214        fault_if_from_uspace(istate, "%s.", __func__);
     215        dump_istate(istate);
     216        panic("%s.", __func__);
    217217}
    218218
  • kernel/arch/sparc64/src/trap/interrupt.c

    rc571f42 rf651e80  
    7373        status = asi_u64_read(ASI_INTR_DISPATCH_STATUS, 0);
    7474        if (status & (!INTR_DISPATCH_STATUS_BUSY))
    75                 panic("Interrupt Dispatch Status busy bit not set\n");
     75                panic("Interrupt Dispatch Status busy bit not set.");
    7676
    7777        intrcv = asi_u64_read(ASI_INTR_RECEIVE, 0);
  • kernel/genarch/src/drivers/ega/ega.c

    rc571f42 rf651e80  
    7979        backbuf = (uint8_t *) malloc(SCREEN * 2, 0);
    8080        if (!backbuf)
    81                 panic("Unable to allocate backbuffer.\n");
     81                panic("Unable to allocate backbuffer.");
    8282       
    8383        videoram = (uint8_t *) hw_map(videoram_phys, SCREEN * 2);
  • kernel/genarch/src/fb/fb.c

    rc571f42 rf651e80  
    457457                break;
    458458        default:
    459                 panic("Unsupported visual.\n");
     459                panic("Unsupported visual.");
    460460        }
    461461       
     
    489489        backbuf = (uint8_t *) malloc(bbsize, 0);
    490490        if (!backbuf)
    491                 panic("Unable to allocate backbuffer.\n");
     491                panic("Unable to allocate backbuffer.");
    492492       
    493493        glyphs = (uint8_t *) malloc(glyphsize, 0);
    494494        if (!glyphs)
    495                 panic("Unable to allocate glyphs.\n");
     495                panic("Unable to allocate glyphs.");
    496496       
    497497        bgscan = malloc(bgscanbytes, 0);
    498498        if (!bgscan)
    499                 panic("Unable to allocate background pixel.\n");
     499                panic("Unable to allocate background pixel.");
    500500       
    501501        memsetb(backbuf, bbsize, 0);
  • kernel/genarch/src/ofw/fhc.c

    rc571f42 rf651e80  
    6868                        }
    6969                        if (strcmp(ofw_tree_node_name(node->parent), "central") != 0)
    70                                 panic("Unexpected parent node: %s.\n", ofw_tree_node_name(node->parent));
     70                                panic("Unexpected parent node: %s.", ofw_tree_node_name(node->parent));
    7171                       
    7272                        ofw_central_reg_t central_reg;
     
    8585{
    8686        if (node->parent->parent)
    87                 panic("Unexpected parent node: %s.\n", ofw_tree_node_name(node->parent));
     87                panic("Unexpected parent node: %s.", ofw_tree_node_name(node->parent));
    8888       
    8989        ofw_tree_property_t *prop;
  • kernel/genarch/src/ofw/ofw_tree.c

    rc571f42 rf651e80  
    8686        prop = ofw_tree_getprop(node, "name");
    8787        if (!prop)
    88                 panic("Node without name property.\n");
     88                panic("Node without name property.");
    8989               
    9090        if (prop->size < 2)
    91                 panic("Invalid name property.\n");
     91                panic("Invalid name property.");
    9292       
    9393        return prop->value;
  • kernel/genarch/src/ofw/pci.c

    rc571f42 rf651e80  
    102102        prop = ofw_tree_getprop(node, "assigned-addresses");
    103103        if (!prop)
    104                 panic("Can't find \"assigned-addresses\" property.\n");
     104                panic("Cannot find 'assigned-addresses' property.");
    105105       
    106106        assigned_addresses = prop->size / sizeof(ofw_pci_reg_t);
  • kernel/generic/include/debug.h

    rc571f42 rf651e80  
    5858#       define ASSERT(expr) \
    5959                if (!(expr)) { \
    60                         panic("assertion failed (%s), caller=%p\n", #expr, CALLER); \
     60                        panic("Assertion failed (%s), caller=%p.", #expr, CALLER); \
    6161                }
    6262#else
  • kernel/generic/include/panic.h

    rc571f42 rf651e80  
    3838#ifdef CONFIG_DEBUG
    3939#       define panic(format, ...) \
    40                 panic_printf("Kernel panic in %s() at %s:%u: " format, __func__, \
    41                 __FILE__, __LINE__, ##__VA_ARGS__);
     40                panic_printf("Kernel panic in %s() at %s:%u: " format "\n", \
     41                __func__, __FILE__, __LINE__, ##__VA_ARGS__);
    4242#else
    4343#       define panic(format, ...) \
    44                 panic_printf("Kernel panic: " format, ##__VA_ARGS__);
     44                panic_printf("Kernel panic: " format "\n", ##__VA_ARGS__);
    4545#endif
    4646
  • kernel/generic/src/adt/btree.c

    rc571f42 rf651e80  
    125125        if (!lnode) {
    126126                if (btree_search(t, key, &lnode)) {
    127                         panic("B-tree %p already contains key %" PRIu64 "\n", t, key);
     127                        panic("B-tree %p already contains key %" PRIu64 ".", t, key);
    128128                }
    129129        }
     
    225225        if (!lnode) {
    226226                if (!btree_search(t, key, &lnode)) {
    227                         panic("B-tree %p does not contain key %" PRIu64 "\n", t, key);
     227                        panic("B-tree %p does not contain key %" PRIu64 ".", t, key);
    228228                }
    229229        }
     
    525525                }
    526526        }
    527         panic("node %p does not contain key %" PRIu64 "\n", node, key);
     527        panic("Node %p does not contain key %" PRIu64 ".", node, key);
    528528}
    529529
     
    552552                }
    553553        }
    554         panic("node %p does not contain key %" PRIu64 "\n", node, key);
     554        panic("Node %p does not contain key %" PRIu64 ".", node, key);
    555555}
    556556
     
    694694                        return i - (int) (right != false);
    695695        }
    696         panic("node %p does not contain subtree %p\n", node, subtree);
     696        panic("Node %p does not contain subtree %p.", node, subtree);
    697697}
    698698
  • kernel/generic/src/adt/hash_table.c

    rc571f42 rf651e80  
    6262        h->entry = (link_t *) malloc(m * sizeof(link_t), 0);
    6363        if (!h->entry) {
    64                 panic("cannot allocate memory for hash table\n");
     64                panic("Cannot allocate memory for hash table.");
    6565        }
    6666        memsetb(h->entry, m * sizeof(link_t), 0);
  • kernel/generic/src/cpu/cpu.c

    rc571f42 rf651e80  
    6565                                        FRAME_ATOMIC);
    6666                if (!cpus)
    67                         panic("malloc/cpus");
     67                        panic("Cannot allocate CPU structures.");
    6868
    6969                /* initialize everything */
  • kernel/generic/src/interrupt/interrupt.c

    rc571f42 rf651e80  
    106106static void exc_undef(int n, istate_t *istate)
    107107{
    108         fault_if_from_uspace(istate, "Unhandled exception %d", n);
    109         panic("Unhandled exception %d", n);
     108        fault_if_from_uspace(istate, "Unhandled exception %d.", n);
     109        panic("Unhandled exception %d.", n);
    110110}
    111111
  • kernel/generic/src/main/kinit.c

    rc571f42 rf651e80  
    111111                        thread_ready(thread);
    112112                } else
    113                         panic("Unable to create kmp thread\n");
     113                        panic("Unable to create kmp thread.");
    114114                thread_join(thread);
    115115                thread_detach(thread);
  • kernel/generic/src/main/main.c

    rc571f42 rf651e80  
    270270        task_t *kernel = task_create(AS_KERNEL, "kernel");
    271271        if (!kernel)
    272                 panic("Can't create kernel task\n");
     272                panic("Cannot create kernel task.");
    273273       
    274274        /*
     
    278278                = thread_create(kinit, NULL, kernel, 0, "kinit", true);
    279279        if (!kinit_thread)
    280                 panic("Can't create kinit thread\n");
     280                panic("Cannot create kinit thread.");
    281281        LOG_EXEC(thread_ready(kinit_thread));
    282282       
  • kernel/generic/src/mm/as.c

    rc571f42 rf651e80  
    147147        AS_KERNEL = as_create(FLAG_AS_KERNEL);
    148148        if (!AS_KERNEL)
    149                 panic("Cannot create kernel address space\n");
     149                panic("Cannot create kernel address space.");
    150150       
    151151        /* Make sure the kernel address space
     
    445445                                        if (!used_space_remove(area, start_free,
    446446                                            c - i))
    447                                                 panic("Could not remove used "
    448                                                     "space.\n");
     447                                                panic("Cannot remove used "
     448                                                    "space.");
    449449                                } else {
    450450                                        /*
     
    453453                                         */
    454454                                        if (!used_space_remove(area, b, c))
    455                                                 panic("Could not remove used "
    456                                                     "space.\n");
     455                                                panic("Cannot remove used "
     456                                                    "space.");
    457457                                }
    458458                       
     
    16671667
    16681668        panic("Inconsistency detected while adding %" PRIc " pages of used "
    1669             "space at %p.\n", count, page);
     1669            "space at %p.", count, page);
    16701670}
    16711671
     
    18461846error:
    18471847        panic("Inconsistency detected while removing %" PRIc " pages of used "
    1848             "space from %p.\n", count, page);
     1848            "space from %p.", count, page);
    18491849}
    18501850
  • kernel/generic/src/mm/backend_anon.c

    rc571f42 rf651e80  
    153153        page_mapping_insert(AS, addr, frame, as_area_get_flags(area));
    154154        if (!used_space_insert(area, ALIGN_DOWN(addr, PAGE_SIZE), 1))
    155                 panic("Could not insert used space.\n");
     155                panic("Cannot insert used space.");
    156156               
    157157        return AS_PF_OK;
  • kernel/generic/src/mm/backend_elf.c

    rc571f42 rf651e80  
    130130                            as_area_get_flags(area));
    131131                        if (!used_space_insert(area, page, 1))
    132                                 panic("Could not insert used space.\n");
     132                                panic("Cannot insert used space.");
    133133                        mutex_unlock(&area->sh_info->lock);
    134134                        return AS_PF_OK;
     
    215215        page_mapping_insert(AS, addr, frame, as_area_get_flags(area));
    216216        if (!used_space_insert(area, page, 1))
    217                 panic("Could not insert used space.\n");
     217                panic("Cannot insert used space.");
    218218
    219219        return AS_PF_OK;
  • kernel/generic/src/mm/backend_phys.c

    rc571f42 rf651e80  
    7878            as_area_get_flags(area));
    7979        if (!used_space_insert(area, ALIGN_DOWN(addr, PAGE_SIZE), 1))
    80                 panic("Could not insert used space.\n");
     80                panic("Cannot insert used space.");
    8181
    8282        return AS_PF_OK;
  • kernel/generic/src/mm/tlb.c

    rc571f42 rf651e80  
    174174                        break;
    175175                default:
    176                         panic("unknown type (%d)\n", type);
     176                        panic("Unknown type (%d).", type);
    177177                        break;
    178178                }
  • kernel/generic/src/proc/scheduler.c

    rc571f42 rf651e80  
    452452                         * Entering state is unexpected.
    453453                         */
    454                         panic("tid%" PRIu64 ": unexpected state %s\n",
     454                        panic("tid%" PRIu64 ": unexpected state %s.",
    455455                            THREAD->tid, thread_states[THREAD->state]);
    456456                        break;
  • kernel/generic/src/proc/tasklet.c

    rc571f42 rf651e80  
    5252        tasklet_list = malloc(sizeof(tasklet_descriptor_t *) * config.cpu_count, 0);
    5353        if (!tasklet_list)
    54                 panic("Error initializing tasklets");
     54                panic("Error initializing tasklets.");
    5555       
    5656        for (i = 0; i < config.cpu_count; i++)
  • kernel/generic/src/synch/rwlock.c

    rc571f42 rf651e80  
    232232                        break;
    233233                case ESYNCH_OK_ATOMIC:
    234                         panic("_mutex_lock_timeout() == ESYNCH_OK_ATOMIC\n");
     234                        panic("_mutex_lock_timeout() == ESYNCH_OK_ATOMIC.");
    235235                        break;
    236236                default:
    237                         panic("invalid ESYNCH\n");
     237                        panic("Invalid ESYNCH.");
    238238                        break;
    239239                }
  • kernel/generic/src/sysinfo/sysinfo.c

    rc571f42 rf651e80  
    164164                }       
    165165        }
    166         panic("Not reached\n");
     166
     167        panic("Not reached.");
    167168        return NULL;
    168169}
  • kernel/generic/src/time/clock.c

    rc571f42 rf651e80  
    8080        faddr = frame_alloc(ONE_FRAME, FRAME_ATOMIC);
    8181        if (!faddr)
    82                 panic("Cannot allocate page for clock");
     82                panic("Cannot allocate page for clock.");
    8383       
    8484        uptime = (uptime_t *) PA2KA(faddr);
  • kernel/generic/src/time/timeout.c

    rc571f42 rf651e80  
    114114
    115115        if (t->cpu)
    116                 panic("t->cpu != 0");
     116                panic("Unexpected: t->cpu != 0.");
    117117
    118118        t->cpu = CPU;
Note: See TracChangeset for help on using the changeset viewer.