Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

These have moved to ../../arm/arm (disksubr*.c) or ../../arm/arm32 

(everything else).
This commit is contained in:
matt 2001-03-04 05:14:06 +00:00
parent 8655276e9a
commit fb62f0c378
9 changed files with 0 additions and 5082 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

472
sys/arch/arm32/arm32/db_interface.c
View File

@ -1,472 +0,0 @@
/* $NetBSD: db_interface.c,v 1.34 2001/01/22 13:56:57 jdolecek Exp $ */
/*
* Copyright (c) 1996 Scott K. Stevens
*
* Mach Operating System
* Copyright (c) 1991,1990 Carnegie Mellon University
* All Rights Reserved.
*
* Permission to use, copy, modify and distribute this software and its
* documentation is hereby granted, provided that both the copyright
* notice and this permission notice appear in all copies of the
* software, derivative works or modified versions, and any portions
* thereof, and that both notices appear in supporting documentation.
*
* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
*
* Carnegie Mellon requests users of this software to return to
*
* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
* School of Computer Science
* Carnegie Mellon University
* Pittsburgh PA 15213-3890
*
* any improvements or extensions that they make and grant Carnegie the
* rights to redistribute these changes.
*
* From: db_interface.c,v 2.4 1991/02/05 17:11:13 mrt (CMU)
*/
/*
* Interface to new debugger.
*/
#include "opt_ddb.h"
#include <sys/param.h>
#include <sys/proc.h>
#include <sys/reboot.h>
#include <sys/systm.h> /* just for boothowto */
#include <sys/exec.h>
#include <uvm/uvm_extern.h>
#include <machine/db_machdep.h>
#include <machine/katelib.h>
#include <machine/pte.h>
#include <machine/undefined.h>
#include <ddb/db_command.h>
#include <ddb/db_output.h>
#include <ddb/db_variables.h>
#include <ddb/db_sym.h>
#include <ddb/db_extern.h>
#include <ddb/db_interface.h>
#include <dev/cons.h>
static int nil;
int db_access_und_sp __P((const struct db_variable *, db_expr_t *, int));
int db_access_abt_sp __P((const struct db_variable *, db_expr_t *, int));
int db_access_irq_sp __P((const struct db_variable *, db_expr_t *, int));
u_int db_fetch_reg __P((int, db_regs_t *));
const struct db_variable db_regs[] = {
{ "spsr", (long *)&DDB_REGS->tf_spsr, FCN_NULL, },
{ "r0", (long *)&DDB_REGS->tf_r0, FCN_NULL, },
{ "r1", (long *)&DDB_REGS->tf_r1, FCN_NULL, },
{ "r2", (long *)&DDB_REGS->tf_r2, FCN_NULL, },
{ "r3", (long *)&DDB_REGS->tf_r3, FCN_NULL, },
{ "r4", (long *)&DDB_REGS->tf_r4, FCN_NULL, },
{ "r5", (long *)&DDB_REGS->tf_r5, FCN_NULL, },
{ "r6", (long *)&DDB_REGS->tf_r6, FCN_NULL, },
{ "r7", (long *)&DDB_REGS->tf_r7, FCN_NULL, },
{ "r8", (long *)&DDB_REGS->tf_r8, FCN_NULL, },
{ "r9", (long *)&DDB_REGS->tf_r9, FCN_NULL, },
{ "r10", (long *)&DDB_REGS->tf_r10, FCN_NULL, },
{ "r11", (long *)&DDB_REGS->tf_r11, FCN_NULL, },
{ "r12", (long *)&DDB_REGS->tf_r12, FCN_NULL, },
{ "usr_sp", (long *)&DDB_REGS->tf_usr_sp, FCN_NULL, },
{ "usr_lr", (long *)&DDB_REGS->tf_usr_lr, FCN_NULL, },
{ "svc_sp", (long *)&DDB_REGS->tf_svc_sp, FCN_NULL, },
{ "svc_lr", (long *)&DDB_REGS->tf_svc_lr, FCN_NULL, },
{ "pc", (long *)&DDB_REGS->tf_pc, FCN_NULL, },
{ "und_sp", (long *)&nil, db_access_und_sp, },
{ "abt_sp", (long *)&nil, db_access_abt_sp, },
{ "irq_sp", (long *)&nil, db_access_irq_sp, },
};
const struct db_variable * const db_eregs = db_regs + sizeof(db_regs)/sizeof(db_regs[0]);
extern label_t *db_recover;
int db_active = 0;
int db_access_und_sp(vp, valp, rw)
const struct db_variable *vp;
db_expr_t *valp;
int rw;
{
if (rw == DB_VAR_GET)
*valp = get_stackptr(PSR_UND32_MODE);
return(0);
}
int db_access_abt_sp(vp, valp, rw)
const struct db_variable *vp;
db_expr_t *valp;
int rw;
{
if (rw == DB_VAR_GET)
*valp = get_stackptr(PSR_ABT32_MODE);
return(0);
}
int db_access_irq_sp(vp, valp, rw)
const struct db_variable *vp;
db_expr_t *valp;
int rw;
{
if (rw == DB_VAR_GET)
*valp = get_stackptr(PSR_IRQ32_MODE);
return(0);
}
/*
* kdb_trap - field a TRACE or BPT trap
*/
int
kdb_trap(type, regs)
int type;
db_regs_t *regs;
{
int s;
switch (type) {
case T_BREAKPOINT: /* breakpoint */
case -1: /* keyboard interrupt */
break;
default:
db_printf("kernel: trap");
if (db_recover != 0) {
db_error("Faulted in DDB; continuing...\n");
/*NOTREACHED*/
}
}
/* Should switch to kdb`s own stack here. */
ddb_regs = *regs;
s = splhigh();
db_active++;
cnpollc(TRUE);
db_trap(type, 0/*code*/);
cnpollc(FALSE);
db_active--;
splx(s);
*regs = ddb_regs;
return (1);
}
/*
* Received keyboard interrupt sequence.
*/
void
kdb_kbd_trap(regs)
db_regs_t *regs;
{
if (db_active == 0 && (boothowto & RB_KDB)) {
printf("\n\nkernel: keyboard interrupt\n");
kdb_trap(-1, regs);
}
}
static int
db_validate_address(addr)
vm_offset_t addr;
{
pt_entry_t *ptep;
pd_entry_t *pdep;
struct proc *p = curproc;
/*
* If we have a valid pmap for curproc, use it's page directory
* otherwise use the kernel pmap's page directory.
*/
if (!p || !p->p_vmspace || !p->p_vmspace->vm_map.pmap)
pdep = kernel_pmap->pm_pdir;
else
pdep = p->p_vmspace->vm_map.pmap->pm_pdir;
/* Make sure the address we are reading is valid */
switch ((pdep[(addr >> 20) + 0] & L1_MASK)) {
case L1_SECTION:
break;
case L1_PAGE:
/* Check the L2 page table for validity */
ptep = vtopte(addr);
if ((*ptep & L2_MASK) != L2_INVAL)
break;
/* FALLTHROUGH */
default:
return 1;
}
return 0;
}
/*
* Read bytes from kernel address space for debugger.
*/
void
db_read_bytes(addr, size, data)
vm_offset_t addr;
int size;
char *data;
{
char *src;
src = (char *)addr;
while (--size >= 0) {
if (db_validate_address((u_int)src)) {
db_printf("address %p is invalid\n", src);
return;
}
*data++ = *src++;
}
}
static void
db_write_text(dst, ch)
unsigned char *dst;
int ch;
{
pt_entry_t *ptep, pteo;
vm_offset_t va;
va = (unsigned long)dst & (~PGOFSET);
ptep = vtopte(va);
if (db_validate_address((u_int)dst)) {
db_printf(" address %p not a valid page\n", dst);
return;
}
pteo = *ptep;
*ptep = pteo | PT_AP(AP_KRW);
cpu_tlb_flushD_SE(va);
*dst = (unsigned char)ch;
/* make sure the caches and memory are in sync */
cpu_cache_syncI_rng((u_int)dst, 4);
*ptep = pteo;
cpu_tlb_flushD_SE(va);
}
/*
* Write bytes to kernel address space for debugger.
*/
void
db_write_bytes(addr, size, data)
vm_offset_t addr;
int size;
char *data;
{
extern char etext[];
char *dst;
int loop;
dst = (char *)addr;
loop = size;
while (--loop >= 0) {
if ((dst >= (char *)KERNEL_TEXT_BASE) && (dst < etext))
db_write_text(dst, *data);
else {
if (db_validate_address((u_int)dst)) {
db_printf("address %p is invalid\n", dst);
return;
}
*dst = *data;
}
dst++, data++;
}
/* make sure the caches and memory are in sync */
cpu_cache_syncI_rng(addr, size);
/* In case the current page tables have been modified ... */
cpu_tlb_flushID();
}
void
cpu_Debugger()
{
asm(".word 0xe7ffffff");
}
void db_show_vmstat_cmd __P((db_expr_t addr, int have_addr, db_expr_t count, char *modif));
void db_show_intrchain_cmd __P((db_expr_t addr, int have_addr, db_expr_t count, char *modif));
void db_show_panic_cmd __P((db_expr_t addr, int have_addr, db_expr_t count, char *modif));
void db_show_frame_cmd __P((db_expr_t addr, int have_addr, db_expr_t count, char *modif));
#ifdef OFW
void db_of_boot_cmd __P((db_expr_t addr, int have_addr, db_expr_t count, char *modif));
void db_of_enter_cmd __P((db_expr_t addr, int have_addr, db_expr_t count, char *modif));
void db_of_exit_cmd __P((db_expr_t addr, int have_addr, db_expr_t count, char *modif));
#endif
const struct db_command db_machine_command_table[] = {
{ "frame", db_show_frame_cmd, 0, NULL },
{ "intrchain", db_show_intrchain_cmd, 0, NULL },
#ifdef OFW
{ "ofboot", db_of_boot_cmd, 0, NULL },
{ "ofenter", db_of_enter_cmd, 0, NULL },
{ "ofexit", db_of_exit_cmd, 0, NULL },
#endif
{ "panic", db_show_panic_cmd, 0, NULL },
{ "vmstat", db_show_vmstat_cmd, 0, NULL },
{ NULL, NULL, 0, NULL }
};
int
db_trapper(addr, inst, frame, fault_code)
u_int addr;
u_int inst;
trapframe_t *frame;
int fault_code;
{
if (fault_code == 0) {
frame->tf_pc -= INSN_SIZE;
if ((inst & ~INSN_COND_MASK) == (BKPT_INST & ~INSN_COND_MASK))
kdb_trap(T_BREAKPOINT, frame);
else
kdb_trap(-1, frame);
} else
return (1);
return (0);
}
extern u_int esym;
extern u_int end;
void
db_machine_init()
{
struct exec *kernexec = (struct exec *)KERNEL_TEXT_BASE;
int len;
/*
* The boot loader currently loads the kernel with the a.out
* header still attached.
*/
if (kernexec->a_syms == 0) {
printf("[No symbol table]\n");
} else {
#if !defined(SHARK) && !defined(OFWGENCFG)
esym = (int)&end + kernexec->a_syms + sizeof(int);
#else
/* cover the symbols themselves */
esym = (int)&end + kernexec->a_syms;
#endif
/*
* and the string table. (int containing size of string
* table is included in string table size).
*/
len = *((u_int *)esym);
esym += (len + (sizeof(u_int) - 1)) & ~(sizeof(u_int) - 1);
}
install_coproc_handler(0, db_trapper);
}
u_int
db_fetch_reg(reg, db_regs)
int reg;
db_regs_t *db_regs;
{
switch (reg) {
case 0:
return (db_regs->tf_r0);
case 1:
return (db_regs->tf_r1);
case 2:
return (db_regs->tf_r2);
case 3:
return (db_regs->tf_r3);
case 4:
return (db_regs->tf_r4);
case 5:
return (db_regs->tf_r5);
case 6:
return (db_regs->tf_r6);
case 7:
return (db_regs->tf_r7);
case 8:
return (db_regs->tf_r8);
case 9:
return (db_regs->tf_r9);
case 10:
return (db_regs->tf_r10);
case 11:
return (db_regs->tf_r11);
case 12:
return (db_regs->tf_r12);
case 13:
return (db_regs->tf_svc_sp);
case 14:
return (db_regs->tf_svc_lr);
case 15:
return (db_regs->tf_pc);
default:
panic("db_fetch_reg: botch");
}
}
u_int
branch_taken(insn, pc, db_regs)
u_int insn;
u_int pc;
db_regs_t *db_regs;
{
u_int addr, nregs;
switch ((insn >> 24) & 0xf) {
case 0xa: /* b ... */
case 0xb: /* bl ... */
addr = ((insn << 2) & 0x03ffffff);
if (addr & 0x02000000)
addr |= 0xfc000000;
return (pc + 8 + addr);
case 0x7: /* ldr pc, [pc, reg, lsl #2] */
addr = db_fetch_reg(insn & 0xf, db_regs);
addr = pc + 8 + (addr << 2);
db_read_bytes(addr, 4, (char *)&addr);
return (addr);
case 0x1: /* mov pc, reg */
addr = db_fetch_reg(insn & 0xf, db_regs);
return (addr);
case 0x8: /* ldmxx reg, {..., pc} */
case 0x9:
addr = db_fetch_reg((insn >> 16) & 0xf, db_regs);
nregs = (insn & 0x5555) + ((insn >> 1) & 0x5555);
nregs = (nregs & 0x3333) + ((nregs >> 2) & 0x3333);
nregs = (nregs + (nregs >> 4)) & 0x0f0f;
nregs = (nregs + (nregs >> 8)) & 0x001f;
switch ((insn >> 23) & 0x3) {
case 0x0: /* ldmda */
addr = addr - 0;
break;
case 0x1: /* ldmia */
addr = addr + 0 + ((nregs - 1) << 2);
break;
case 0x2: /* ldmdb */
addr = addr - 4;
break;
case 0x3: /* ldmib */
addr = addr + 4 + ((nregs - 1) << 2);
break;
}
db_read_bytes(addr, 4, (char *)&addr);
return (addr);
default:
panic("branch_taken: botch");
}
}

211
sys/arch/arm32/arm32/db_machdep.c
View File

@ -1,211 +0,0 @@
/* $NetBSD: db_machdep.c,v 1.16 2000/11/21 16:34:53 chs Exp $ */
/*
* Copyright (c) 1996 Mark Brinicombe
*
* Mach Operating System
* Copyright (c) 1991,1990 Carnegie Mellon University
* All Rights Reserved.
*
* Permission to use, copy, modify and distribute this software and its
* documentation is hereby granted, provided that both the copyright
* notice and this permission notice appear in all copies of the
* software, derivative works or modified versions, and any portions
* thereof, and that both notices appear in supporting documentation.
*
* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
*
* Carnegie Mellon requests users of this software to return to
*
* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
* School of Computer Science
* Carnegie Mellon University
* Pittsburgh PA 15213-3890
*
* any improvements or extensions that they make and grant Carnegie the
* rights to redistribute these changes.
*/
#include <sys/param.h>
#include <sys/proc.h>
#include <sys/vnode.h>
#include <sys/systm.h>
#include <machine/db_machdep.h>
#include <ddb/db_access.h>
#include <ddb/db_sym.h>
#include <ddb/db_output.h>
#include <machine/irqhandler.h>
#ifdef OFW
#include <dev/ofw/openfirm.h>
#endif
void
db_show_vmstat_cmd(addr, have_addr, count, modif)
db_expr_t addr;
int have_addr;
db_expr_t count;
char *modif;
{
db_printf("Current UVM status:\n");
db_printf(" pagesize=%d (0x%x), pagemask=0x%x, pageshift=%d\n",
uvmexp.pagesize, uvmexp.pagesize, uvmexp.pagemask,
uvmexp.pageshift);
db_printf(" %d VM pages: %d active, %d inactive, %d wired, %d free\n",
uvmexp.npages, uvmexp.active, uvmexp.inactive, uvmexp.wired,
uvmexp.free);
db_printf(" freemin=%d, free-target=%d, inactive-target=%d, "
"wired-max=%d\n", uvmexp.freemin, uvmexp.freetarg, uvmexp.inactarg,
uvmexp.wiredmax);
db_printf(" faults=%d, traps=%d, intrs=%d, ctxswitch=%d\n",
uvmexp.faults, uvmexp.traps, uvmexp.intrs, uvmexp.swtch);
db_printf(" softint=%d, syscalls=%d, swapins=%d, swapouts=%d\n",
uvmexp.softs, uvmexp.syscalls, uvmexp.swapins, uvmexp.swapouts);
db_printf(" fault counts:\n");
db_printf(" noram=%d, noanon=%d, pgwait=%d, pgrele=%d\n",
uvmexp.fltnoram, uvmexp.fltnoanon, uvmexp.fltpgwait,
uvmexp.fltpgrele);
db_printf(" ok relocks(total)=%d(%d), anget(retrys)=%d(%d), "
"amapcopy=%d\n", uvmexp.fltrelckok, uvmexp.fltrelck,
uvmexp.fltanget, uvmexp.fltanretry, uvmexp.fltamcopy);
db_printf(" neighbor anon/obj pg=%d/%d, gets(lock/unlock)=%d/%d\n",
uvmexp.fltnamap, uvmexp.fltnomap, uvmexp.fltlget, uvmexp.fltget);
db_printf(" cases: anon=%d, anoncow=%d, obj=%d, prcopy=%d, przero=%d\n",
uvmexp.flt_anon, uvmexp.flt_acow, uvmexp.flt_obj, uvmexp.flt_prcopy,
uvmexp.flt_przero);
db_printf(" daemon and swap counts:\n");
db_printf(" woke=%d, revs=%d, scans=%d, swout=%d\n", uvmexp.pdwoke,
uvmexp.pdrevs, uvmexp.pdscans, uvmexp.pdswout);
db_printf(" busy=%d, freed=%d, reactivate=%d, deactivate=%d\n",
uvmexp.pdbusy, uvmexp.pdfreed, uvmexp.pdreact, uvmexp.pddeact);
db_printf(" pageouts=%d, pending=%d, nswget=%d\n", uvmexp.pdpageouts,
uvmexp.pdpending, uvmexp.nswget);
db_printf(" nswapdev=%d, nanon=%d, nfreeanon=%d\n", uvmexp.nswapdev,
uvmexp.nanon, uvmexp.nfreeanon);
db_printf(" kernel pointers:\n");
db_printf(" objs(kmem/mb)=%p/%p\n", uvmexp.kmem_object,
uvmexp.mb_object);
}
void
db_show_intrchain_cmd(addr, have_addr, count, modif)
db_expr_t addr;
int have_addr;
db_expr_t count;
char *modif;
{
int loop;
irqhandler_t *ptr;
char *name;
db_expr_t offset;
for (loop = 0; loop < NIRQS; ++loop) {
ptr = irqhandlers[loop];
if (ptr) {
db_printf("IRQ %d\n", loop);
while (ptr) {
db_printf(" %-13s %d ", ptr->ih_name, ptr->ih_level);
db_find_sym_and_offset((u_int)ptr->ih_func, &name, &offset);
if (name == NULL)
name = "?";
db_printf("%s(", name);
db_printsym((u_int)ptr->ih_func, DB_STGY_PROC,
db_printf);
db_printf(") %08x\n", (u_int)ptr->ih_arg);
ptr = ptr->ih_next;
}
}
}
}
void
db_show_panic_cmd(addr, have_addr, count, modif)
db_expr_t addr;
int have_addr;
db_expr_t count;
char *modif;
{
int s;
s = splhigh();
db_printf("Panic string: %s\n", panicstr);
(void)splx(s);
}
void
db_show_frame_cmd(addr, have_addr, count, modif)
db_expr_t addr;
int have_addr;
db_expr_t count;
char *modif;
{
struct trapframe *frame;
if (!have_addr) {
db_printf("frame address must be specified\n");
return;
}
frame = (struct trapframe *)addr;
db_printf("frame address = %08x ", (u_int)frame);
db_printf("spsr=%08x\n", frame->tf_spsr);
db_printf("r0 =%08x r1 =%08x r2 =%08x r3 =%08x\n",
frame->tf_r0, frame->tf_r1, frame->tf_r2, frame->tf_r3);
db_printf("r4 =%08x r5 =%08x r6 =%08x r7 =%08x\n",
frame->tf_r4, frame->tf_r5, frame->tf_r6, frame->tf_r7);
db_printf("r8 =%08x r9 =%08x r10=%08x r11=%08x\n",
frame->tf_r8, frame->tf_r9, frame->tf_r10, frame->tf_r11);
db_printf("r12=%08x r13=%08x r14=%08x r15=%08x\n",
frame->tf_r12, frame->tf_usr_sp, frame->tf_usr_lr, frame->tf_pc);
db_printf("slr=%08x\n", frame->tf_svc_lr);
}
#ifdef OFW
void
db_of_boot_cmd(addr, have_addr, count, modif)
db_expr_t addr;
int have_addr;
db_expr_t count;
char *modif;
{
OF_boot("");
}
void
db_of_enter_cmd(addr, have_addr, count, modif)
db_expr_t addr;
int have_addr;
db_expr_t count;
char *modif;
{
OF_enter();
}
void
db_of_exit_cmd(addr, have_addr, count, modif)
db_expr_t addr;
int have_addr;
db_expr_t count;
char *modif;
{
OF_exit();
}
#endif /* OFW */

149
sys/arch/arm32/arm32/db_trace.c
View File

@ -1,149 +0,0 @@
/* $NetBSD: db_trace.c,v 1.14 2001/02/25 21:31:14 bjh21 Exp $ */
/*
* Copyright (c) 1996 Scott K. Stevens
*
* Mach Operating System
* Copyright (c) 1991,1990 Carnegie Mellon University
* All Rights Reserved.
*
* Permission to use, copy, modify and distribute this software and its
* documentation is hereby granted, provided that both the copyright
* notice and this permission notice appear in all copies of the
* software, derivative works or modified versions, and any portions
* thereof, and that both notices appear in supporting documentation.
*
* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
*
* Carnegie Mellon requests users of this software to return to
*
* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
* School of Computer Science
* Carnegie Mellon University
* Pittsburgh PA 15213-3890
*
* any improvements or extensions that they make and grant Carnegie the
* rights to redistribute these changes.
*/
#include <sys/param.h>
#include <sys/proc.h>
#include <sys/user.h>
#include <machine/db_machdep.h>
#include <ddb/db_access.h>
#include <ddb/db_sym.h>
#include <ddb/db_output.h>
#define INKERNEL(va) (((vm_offset_t)(va)) >= VM_MIN_KERNEL_ADDRESS)
void
db_stack_trace_print(addr, have_addr, count, modif, pr)
db_expr_t addr;
int have_addr;
db_expr_t count;
char *modif;
void (*pr) __P((const char *, ...));
{
struct frame *frame, *lastframe;
char c, *cp = modif;
boolean_t kernel_only = TRUE;
boolean_t trace_thread = FALSE;
while ((c = *cp++) != 0) {
if (c == 'u')
kernel_only = FALSE;
if (c == 't')
trace_thread = TRUE;
}
/*
* The frame pointer points to the top word of the stack frame so we
* need to adjust it by sizeof(struct frame) - sizeof(u_int))
* to get the address of the start of the frame structure.
*/
if (!have_addr)
frame = (struct frame *)(DDB_REGS->tf_r11
- (sizeof(struct frame) - sizeof(u_int)));
else {
if (trace_thread) {
struct proc *p;
struct user *u;
(*pr)("trace: pid %d ", (int)addr);
p = pfind(addr);
if (p == NULL) {
(*pr)("not found\n");
return;
}
if (!(p->p_flag & P_INMEM)) {
(*pr)("swapped out\n");
return;
}
u = p->p_addr;
frame = (struct frame *) (u->u_pcb.pcb_r11
- (sizeof(struct frame) - sizeof(u_int)));
(*pr)("at %p\n", frame);
} else
frame = (struct frame *)(addr - (sizeof(struct frame)
- sizeof(u_int)));
}
lastframe = NULL;
while (count--) {
db_expr_t offset;
char *name;
db_addr_t pc;
/* (*pr)("fp=%08x: fp=%08x sp=%08x lr=%08x pc=%08x\n",
(u_int)frame, frame->fr_fp, frame->fr_sp, frame->fr_lr,
frame->fr_pc);*/
pc = frame->fr_pc;
/* Adjust the PC so the same address is printed no matter what CPU */
if (cputype == CPU_ID_SA110 || cputype == CPU_ID_ARM810)
pc += 4;
if (!INKERNEL(pc))
break;
db_find_sym_and_offset(pc, &name, &offset);
if (name == NULL)
name = "?";
(*pr)("%s(", name);
db_printsym(pc, DB_STGY_PROC, pr);
(*pr)(")");
(*pr)("\n");
/*
* Switch to next frame up
*/
lastframe = frame;
frame = (struct frame *)(frame->fr_fp - (sizeof(struct frame)
- sizeof(u_int)));
if (frame == NULL)
break;
if (INKERNEL((int)frame)) {
/* staying in kernel */
if (frame <= lastframe) {
(*pr)("Bad frame pointer: %p\n", frame);
break;
}
} else if (INKERNEL((int)lastframe)) {
/* switch from user to kernel */
if (kernel_only)
break; /* kernel stack only */
} else {
/* in user */
if (frame <= lastframe) {
(*pr)("Bad user frame pointer: %p\n",
frame);
break;
}
}
}
}

438
sys/arch/arm32/arm32/disksubr.c
View File

@ -1,438 +0,0 @@
/* $NetBSD: disksubr.c,v 1.14 2000/11/20 08:24:11 chs Exp $ */
/*
* Copyright (c) 1998 Christopher G. Demetriou. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by Christopher G. Demetriou
* for the NetBSD Project.
* 4. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* Copyright (c) 1982, 1986, 1988 Regents of the University of California.
* Copyright (c) 1995 Mark Brinicombe
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* from: @(#)ufs_disksubr.c 7.16 (Berkeley) 5/4/91
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/dkbad.h>
#include <sys/disklabel.h>
#include <sys/syslog.h>
#include <sys/device.h>
#include <sys/disk.h>
/*
* Attempt to read a disk label from a device
* using the indicated stategy routine.
* The label must be partly set up before this:
* secpercyl, secsize and anything required for a block i/o read
* operation in the driver's strategy/start routines
* must be filled in before calling us.
*
* If dos partition table requested, attempt to load it and
* find disklabel inside a DOS partition. Also, if bad block
* table needed, attempt to extract it as well. Return buffer
* for use in signalling errors if requested.
*
* Returns null on success and an error string on failure.
*/
char *
readdisklabel(dev, strat, lp, osdep)
dev_t dev;
void (*strat)();
struct disklabel *lp;
struct cpu_disklabel *osdep;
{
struct buf *bp;
struct disklabel *dlp;
char *msg = NULL;
int cyl, netbsdpartoff, i;
/* printf("Reading disclabel for %04x\n", dev);*/
/* minimal requirements for archtypal disk label */
if (lp->d_secsize == 0)
lp->d_secsize = DEV_BSIZE;
if (lp->d_secperunit == 0)
lp->d_secperunit = 0x1fffffff;
lp->d_npartitions = MAXPARTITIONS;
for (i = 0; i < MAXPARTITIONS; i++) {
if (i == RAW_PART) continue;
lp->d_partitions[i].p_offset = 0;
lp->d_partitions[i].p_fstype = FS_UNUSED;
lp->d_partitions[i].p_size = 0;
}
if (lp->d_partitions[RAW_PART].p_size == 0) {
lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED;
lp->d_partitions[RAW_PART].p_offset = 0;
lp->d_partitions[RAW_PART].p_size = 0x1fffffff;
}
/* obtain buffer to probe drive with */
bp = geteblk((int)lp->d_secsize);
/* request no partition relocation by driver on I/O operations */
bp->b_dev = dev;
/* do netbsd partitions in the process of getting disklabel? */
netbsdpartoff = 0;
cyl = LABELSECTOR / lp->d_secpercyl;
if (osdep) {
if (filecore_label_read(dev, strat,lp, osdep, &msg, &cyl,
&netbsdpartoff) ||
mbr_label_read(dev, strat, lp, osdep, &msg, &cyl,
&netbsdpartoff)) {
if (msg != NULL)
goto done;
} else {
/*
* We didn't find anything we like; NetBSD native.
* netbsdpartoff and cyl should be unchanged.
*/
KASSERT(netbsdpartoff == 0);
KASSERT(cyl == (LABELSECTOR / lp->d_secpercyl));
}
}
/* next, dig out disk label */
/* printf("Reading disklabel addr=%08x\n", netbsdpartoff * DEV_BSIZE);*/
bp->b_blkno = netbsdpartoff + LABELSECTOR;
bp->b_cylinder = bp->b_blkno / lp->d_secpercyl;
bp->b_bcount = lp->d_secsize;
bp->b_flags |= B_READ;
(*strat)(bp);
/* if successful, locate disk label within block and validate */
if (biowait(bp)) {
msg = "disk label I/O error";
goto done;
}
for (dlp = (struct disklabel *)bp->b_data;
dlp <= (struct disklabel *)(bp->b_data + lp->d_secsize - sizeof(*dlp));
dlp = (struct disklabel *)((char *)dlp + sizeof(long))) {
if (dlp->d_magic != DISKMAGIC || dlp->d_magic2 != DISKMAGIC) {
if (msg == NULL)
msg = "no disk label";
} else if (dlp->d_npartitions > MAXPARTITIONS ||
dkcksum(dlp) != 0)
msg = "disk label corrupted";
else {
*lp = *dlp;
msg = NULL;
break;
}
}
if (msg)
goto done;
/* obtain bad sector table if requested and present */
if (osdep && (lp->d_flags & D_BADSECT)) {
struct dkbad *bdp = &osdep->bad;
struct dkbad *db;
i = 0;
do {
/* read a bad sector table */
bp->b_flags &= ~(B_DONE);
bp->b_flags |= B_READ;
bp->b_blkno = lp->d_secperunit - lp->d_nsectors + i;
if (lp->d_secsize > DEV_BSIZE)
bp->b_blkno *= lp->d_secsize / DEV_BSIZE;
else
bp->b_blkno /= DEV_BSIZE / lp->d_secsize;
bp->b_bcount = lp->d_secsize;
bp->b_cylinder = lp->d_ncylinders - 1;
(*strat)(bp);
/* if successful, validate, otherwise try another */
if (biowait(bp)) {
msg = "bad sector table I/O error";
} else {
db = (struct dkbad *)(bp->b_data);
#define DKBAD_MAGIC 0x4321
if (db->bt_mbz == 0
&& db->bt_flag == DKBAD_MAGIC) {
msg = NULL;
*bdp = *db;
break;
} else
msg = "bad sector table corrupted";
}
} while ((bp->b_flags & B_ERROR) && (i += 2) < 10 &&
i < lp->d_nsectors);
}
done:
brelse(bp);
return (msg);
}
/*
* Check new disk label for sensibility
* before setting it.
*/
int
setdisklabel(olp, nlp, openmask, osdep)
struct disklabel *olp;
struct disklabel *nlp;
u_long openmask;
struct cpu_disklabel *osdep;
{
int i;
struct partition *opp, *npp;
/* sanity clause */
if (nlp->d_secpercyl == 0 || nlp->d_secsize == 0
|| (nlp->d_secsize % DEV_BSIZE) != 0)
return(EINVAL);
/* special case to allow disklabel to be invalidated */
if (nlp->d_magic == 0xffffffff) {
*olp = *nlp;
return (0);
}
if (nlp->d_magic != DISKMAGIC || nlp->d_magic2 != DISKMAGIC
|| dkcksum(nlp) != 0)
return (EINVAL);
/* XXX missing check if other acorn/dos partitions will be overwritten */
while (openmask != 0) {
i = ffs(openmask) - 1;
openmask &= ~(1 << i);
if (nlp->d_npartitions <= i)
return (EBUSY);
opp = &olp->d_partitions[i];
npp = &nlp->d_partitions[i];
if (npp->p_offset != opp->p_offset || npp->p_size < opp->p_size)
return (EBUSY);
/*
* Copy internally-set partition information
* if new label doesn't include it. XXX
*/
if (npp->p_fstype == FS_UNUSED && opp->p_fstype != FS_UNUSED) {
npp->p_fstype = opp->p_fstype;
npp->p_fsize = opp->p_fsize;
npp->p_frag = opp->p_frag;
npp->p_cpg = opp->p_cpg;
}
}
nlp->d_checksum = 0;
nlp->d_checksum = dkcksum(nlp);
*olp = *nlp;
return (0);
}
/*
* Write disk label back to device after modification.
*/
int
writedisklabel(dev, strat, lp, osdep)
dev_t dev;
void (*strat)();
struct disklabel *lp;
struct cpu_disklabel *osdep;
{
struct buf *bp;
struct disklabel *dlp;
int cyl, netbsdpartoff;
int error = 0, rv;
/* get a buffer and initialize it */
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
/* do netbsd partitions in the process of getting disklabel? */
netbsdpartoff = 0;
cyl = LABELSECTOR / lp->d_secpercyl;
if (osdep) {
if ((rv = filecore_label_locate(dev, strat,lp, osdep, &cyl,
&netbsdpartoff)) != 0||
(rv = mbr_label_locate(dev, strat, lp, osdep, &cyl,
&netbsdpartoff)) != 0) {
if (rv < 0) {
error = -rv;
goto done;
}
} else {
/*
* We didn't find anything we like; NetBSD native.
* netbsdpartoff and cyl should be unchanged.
*/
KASSERT(netbsdpartoff == 0);
KASSERT(cyl == (LABELSECTOR / lp->d_secpercyl));
}
}
/* writelabel: */
/* printf("writedisklabel: Reading disklabel addr=%08x\n",
netbsdpartoff * DEV_BSIZE);*/
/* next, dig out disk label */
bp->b_blkno = netbsdpartoff + LABELSECTOR;
bp->b_cylinder = cyl;
bp->b_bcount = lp->d_secsize;
bp->b_flags |= B_READ;
(*strat)(bp);
/* if successful, locate disk label within block and validate */
if ((error = biowait(bp)))
goto done;
for (dlp = (struct disklabel *)bp->b_data;
dlp <= (struct disklabel *)(bp->b_data + lp->d_secsize - sizeof(*dlp));
dlp = (struct disklabel *)((char *)dlp + sizeof(long))) {
if (dlp->d_magic == DISKMAGIC && dlp->d_magic2 == DISKMAGIC &&
dkcksum(dlp) == 0) {
*dlp = *lp;
bp->b_flags &= ~(B_READ|B_DONE);
bp->b_flags |= B_WRITE;
(*strat)(bp);
error = biowait(bp);
goto done;
}
}
error = ESRCH;
done:
brelse(bp);
return (error);
}
/*
* Determine the size of the transfer, and make sure it is
* within the boundaries of the partition. Adjust transfer
* if needed, and signal errors or early completion.
*/
int
bounds_check_with_label(bp, lp, wlabel)
struct buf *bp;
struct disklabel *lp;
int wlabel;
{
struct partition *p = lp->d_partitions + DISKPART(bp->b_dev);
int labelsector = lp->d_partitions[0].p_offset + LABELSECTOR;
int sz;
sz = howmany(bp->b_bcount, lp->d_secsize);
if (bp->b_blkno + sz > p->p_size) {
sz = p->p_size - bp->b_blkno;
if (sz == 0) {
/* If exactly at end of disk, return EOF. */
bp->b_resid = bp->b_bcount;
goto done;
}
if (sz < 0) {
/* If past end of disk, return EINVAL. */
bp->b_error = EINVAL;
goto bad;
}
/* Otherwise, truncate request. */
bp->b_bcount = sz << DEV_BSHIFT;
}
/* Overwriting disk label? */
if (bp->b_blkno + p->p_offset <= labelsector &&
#if LABELSECTOR != 0
bp->b_blkno + p->p_offset + sz > labelsector &&
#endif
(bp->b_flags & B_READ) == 0 && !wlabel) {
bp->b_error = EROFS;
goto bad;
}
/* calculate cylinder for disksort to order transfers with */
bp->b_cylinder = (bp->b_blkno + p->p_offset) /
(lp->d_secsize / DEV_BSIZE) / lp->d_secpercyl;
return (1);
bad:
bp->b_flags |= B_ERROR;
done:
return (0);
}
/* End of disksubr.c */

356
sys/arch/arm32/arm32/disksubr_acorn.c
View File

@ -1,356 +0,0 @@
/* $NetBSD: disksubr_acorn.c,v 1.4 2000/11/20 08:24:11 chs Exp $ */
/*
* Copyright (c) 1998 Christopher G. Demetriou. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by Christopher G. Demetriou
* for the NetBSD Project.
* 4. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* Copyright (c) 1982, 1986, 1988 Regents of the University of California.
* Copyright (c) 1995 Mark Brinicombe
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* from: @(#)ufs_disksubr.c 7.16 (Berkeley) 5/4/91
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/disklabel.h>
/*
* static int filecore_checksum(u_char *bootblock)
*
* Calculates the filecore boot block checksum. This is used to validate
* a filecore boot block on the disk. If a boot block is validated then
* it is used to locate the partition table. If the boot block is not
* validated, it is assumed that the whole disk is NetBSD.
*
* The basic algorithm is:
*
* for (each byte in block, excluding checksum) {
* sum += byte;
* if (sum > 255)
* sum -= 255;
* }
*
* That's equivalent to summing all of the bytes in the block
* (excluding the checksum byte, of course), then calculating the
* checksum as "cksum = sum - ((sum - 1) / 255) * 255)". That
* expression may or may not yield a faster checksum function,
* but it's easier to reason about.
*
* Note that if you have a block filled with bytes of a single
* value "X" (regardless of that value!) and calculate the cksum
* of the block (excluding the checksum byte), you will _always_
* end up with a checksum of X. (Do the math; that can be derived
* from the checksum calculation function!) That means that
* blocks which contain bytes which all have the same value will
* always checksum properly. That's a _very_ unlikely occurence
* (probably impossible, actually) for a valid filecore boot block,
* so we treat such blocks as invalid.
*/
static int
filecore_checksum(bootblock)
u_char *bootblock;
{
u_char byte0, accum_diff;
u_int sum;
int i;
sum = 0;
accum_diff = 0;
byte0 = bootblock[0];
/*
* Sum the contents of the block, keeping track of whether
* or not all bytes are the same. If 'accum_diff' ends up
* being zero, all of the bytes are, in fact, the same.
*/
for (i = 0; i < 511; ++i) {
sum += bootblock[i];
accum_diff |= bootblock[i] ^ byte0;
}
/*
* Check to see if the checksum byte is the same as the
* rest of the bytes, too. (Note that if all of the bytes
* are the same except the checksum, a checksum compare
* won't succeed, but that's not our problem.)
*/
accum_diff |= bootblock[i] ^ byte0;
/* All bytes in block are the same; call it invalid. */
if (accum_diff == 0)
return (-1);
return (sum - ((sum - 1) / 255) * 255);
}
int
filecore_label_read(dev, strat, lp, osdep, msgp, cylp, netbsd_label_offp)
dev_t dev;
void (*strat) __P((struct buf *));
struct disklabel *lp;
struct cpu_disklabel *osdep;
char **msgp;
int *cylp, *netbsd_label_offp;
{
struct filecore_bootblock *bb;
int heads;
int sectors;
int rv = 1;
int cyl, netbsdpartoff;
struct buf *bp;
#ifdef __GNUC__
netbsdpartoff = 0; /* XXX -Wuninitialized */
#endif
/* get a buffer and initialize it */
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
/* read the Acorn filecore boot block */
bp->b_blkno = FILECORE_BOOT_SECTOR;
bp->b_bcount = lp->d_secsize;
bp->b_flags |= B_READ;
bp->b_cylinder = bp->b_blkno / lp->d_secpercyl;
(*strat)(bp);
/*
* if successful, validate boot block and
* locate partition table
*/
if (biowait(bp)) {
*msgp = "filecore boot block I/O error";
goto out;
}
bb = (struct filecore_bootblock *)bp->b_data;
/* Validate boot block */
if (bb->checksum != filecore_checksum((u_char *)bb)) {
/*
* Invalid boot block so lets assume the
* entire disc is NetBSD
*/
rv = 0;
goto out;
}
/* Get some information from the boot block */
cyl = bb->partition_cyl_low + (bb->partition_cyl_high << 8);
heads = bb->heads;
sectors = bb->secspertrack;
/* Do we have a NETBSD partition table ? */
if (bb->partition_type == PARTITION_FORMAT_RISCBSD) {
/* printf("heads = %d nsectors = %d\n", heads, sectors);*/
netbsdpartoff = cyl * heads * sectors;
} else if (bb->partition_type == PARTITION_FORMAT_RISCIX) {
struct riscix_partition_table *rpt;
int loop;
/*
* We have a RISCiX partition table :-( groan
*
* Read the RISCiX partition table and see if
* there is a NetBSD partition
*/
bp->b_blkno = cyl * heads * sectors;
/* printf("Found RiscIX partition table @ %08x\n",
bp->b_blkno);*/
bp->b_cylinder = bp->b_blkno / lp->d_secpercyl;
bp->b_bcount = lp->d_secsize;
bp->b_flags &= ~(B_DONE);
bp->b_flags |= B_READ;
(*strat)(bp);
/*
* if successful, locate disk label within block
* and validate
*/
if (biowait(bp)) {
*msgp = "disk label I/O error";
goto out;
}
rpt = (struct riscix_partition_table *)bp->b_data;
/* for (loop = 0; loop < NRISCIX_PARTITIONS; ++loop)
printf("p%d: %16s %08x %08x %08x\n", loop,
rpt->partitions[loop].rp_name,
rpt->partitions[loop].rp_start,
rpt->partitions[loop].rp_length,
rpt->partitions[loop].rp_type);
*/
for (loop = 0; loop < NRISCIX_PARTITIONS; ++loop) {
if (strcmp(rpt->partitions[loop].rp_name,
"RiscBSD") == 0 ||
strcmp(rpt->partitions[loop].rp_name,
"NetBSD") == 0 ||
strcmp(rpt->partitions[loop].rp_name,
"Empty:") == 0) {
netbsdpartoff =
rpt->partitions[loop].rp_start;
break;
}
}
if (loop == NRISCIX_PARTITIONS) {
*msgp = "NetBSD partition identifier string not found.";
goto out;
}
} else {
*msgp = "Invalid partition format";
goto out;
}
*cylp = cyl;
*netbsd_label_offp = netbsdpartoff;
*msgp = NULL;
out:
brelse(bp);
return (rv);
}
int
filecore_label_locate(dev, strat, lp, osdep, cylp, netbsd_label_offp)
dev_t dev;
void (*strat) __P((struct buf *));
struct disklabel *lp;
struct cpu_disklabel *osdep;
int *cylp, *netbsd_label_offp;
{
struct filecore_bootblock *bb;
int heads;
int sectors;
int rv;
int cyl, netbsdpartoff;
struct buf *bp;
/* get a buffer and initialize it */
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
/* read the filecore boot block */
/* printf("writedisklabel: Reading boot block\n");*/
bp->b_blkno = FILECORE_BOOT_SECTOR;
bp->b_bcount = lp->d_secsize;
bp->b_flags |= B_READ;
bp->b_cylinder = bp->b_blkno / lp->d_secpercyl;
(*strat)(bp);
/*
* if successful, validate boot block and locate
* partition table
*/
if ((rv = biowait(bp)) != 0) {
rv = -rv;
goto out;
}
bb = (struct filecore_bootblock *)bp->b_data;
rv = 1;
/* Validate boot block */
if (bb->checksum != filecore_checksum((u_char *)bb)) {
/*
* Invalid boot block so lets assume the
* entire disc is NetBSD
*/
/* printf("writedisklabel: Invalid filecore boot block (incorrect checksum)\n");*/
rv = 0;
goto out;
}
/* Do we have a NetBSD partition ? */
if (bb->partition_type != PARTITION_FORMAT_RISCBSD) {
printf("writedisklabel: Invalid partition format\n");
rv = -1;
goto out;
}
cyl = bb->partition_cyl_low + (bb->partition_cyl_high << 8);
heads = bb->heads;
sectors = bb->secspertrack;
/*printf("heads = %d nsectors = %d\n", heads, sectors);*/
netbsdpartoff = cyl * heads * sectors;
*cylp = cyl;
*netbsd_label_offp = netbsdpartoff;
out:
brelse(bp);
return (rv);
}

276
sys/arch/arm32/arm32/disksubr_mbr.c
View File

@ -1,276 +0,0 @@
/* $NetBSD: disksubr_mbr.c,v 1.5 2000/11/20 08:24:12 chs Exp $ */
/*
* Copyright (c) 1998 Christopher G. Demetriou. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by Christopher G. Demetriou
* for the NetBSD Project.
* 4. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* Copyright (c) 1982, 1986, 1988 Regents of the University of California.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* @(#)ufs_disksubr.c 7.16 (Berkeley) 5/4/91
*/
/*
* From i386 disklabel.c rev 1.29, with cleanups and modifications to
* make it easier to use on the arm32 and to use as MI code (not quite
* clean enough, yet).
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/disklabel.h>
#include "opt_mbr.h"
#define MBRSIGOFS 0x1fe
static char mbrsig[2] = {0x55, 0xaa};
int fat_types[] = {
MBR_PTYPE_FAT12, MBR_PTYPE_FAT16S,
MBR_PTYPE_FAT16B, MBR_PTYPE_FAT32,
MBR_PTYPE_FAT32L, MBR_PTYPE_FAT16L,
-1
};
int
mbr_label_read(dev, strat, lp, osdep, msgp, cylp, netbsd_label_offp)
dev_t dev;
void (*strat) __P((struct buf *));
struct disklabel *lp;
struct cpu_disklabel *osdep;
char **msgp;
int *cylp, *netbsd_label_offp;
{
struct mbr_partition *mbrp;
struct partition *pp;
int cyl, mbrpartoff, i, *ip;
struct buf *bp;
int rv = 1;
/* get a buffer and initialize it */
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
/* In case nothing sets them */
mbrpartoff = 0;
cyl = LABELSECTOR / lp->d_secpercyl;
mbrp = osdep->mbrparts;
/* read master boot record */
bp->b_blkno = MBR_BBSECTOR;
bp->b_bcount = lp->d_secsize;
bp->b_flags |= B_READ;
bp->b_cylinder = MBR_BBSECTOR / lp->d_secpercyl;
(*strat)(bp);
/* if successful, wander through dos partition table */
if (biowait(bp)) {
*msgp = "dos partition I/O error";
goto out;
} else {
struct mbr_partition *ourmbrp = NULL;
/* XXX "there has to be a better check than this." */
if (bcmp(bp->b_data + MBRSIGOFS, mbrsig, sizeof(mbrsig))) {
rv = 0;
goto out;
}
/* XXX how do we check veracity/bounds of this? */
bcopy(bp->b_data + MBR_PARTOFF, mbrp,
NMBRPART * sizeof(*mbrp));
/* look for NetBSD partition */
ourmbrp = NULL;
for (i = 0; !ourmbrp && i < NMBRPART; i++) {
if (mbrp[i].mbrp_typ == MBR_PTYPE_NETBSD)
ourmbrp = &mbrp[i];
}
#ifdef COMPAT_386BSD_MBRPART
/* didn't find it -- look for 386BSD partition */
for (i = 0; !ourmbrp && i < NMBRPART; i++) {
if (mbrp[i].mbrp_typ == MBR_PTYPE_386BSD) {
printf("WARNING: old BSD partition ID!\n");
ourmbrp = &mbrp[i];
break;
}
}
#endif
for (i = 0; i < NMBRPART; i++, mbrp++) {
strncpy(lp->d_packname, "fictitious-MBR",
sizeof lp->d_packname);
/* Install in partition e, f, g, or h. */
pp = &lp->d_partitions['e' - 'a' + i];
pp->p_offset = mbrp->mbrp_start;
pp->p_size = mbrp->mbrp_size;
for (ip = fat_types; *ip != -1; ip++) {
if (mbrp->mbrp_typ == *ip)
pp->p_fstype = FS_MSDOS;
}
if (mbrp->mbrp_typ == MBR_PTYPE_LNXEXT2)
pp->p_fstype = FS_EX2FS;
/* is this ours? */
if (mbrp == ourmbrp) {
/* need sector address for SCSI/IDE,
cylinder for ESDI/ST506/RLL */
mbrpartoff = mbrp->mbrp_start;
cyl = MBR_PCYL(mbrp->mbrp_scyl, mbrp->mbrp_ssect);
#ifdef __i386__ /* XXX? */
/* update disklabel with details */
lp->d_partitions[2].p_size =
mbrp->mbrp_size;
lp->d_partitions[2].p_offset =
mbrp->mbrp_start;
lp->d_ntracks = mbrp->mbrp_ehd + 1;
lp->d_nsectors = MBR_PSECT(mbrp->mbrp_esect);
lp->d_secpercyl =
lp->d_ntracks * lp->d_nsectors;
#endif
}
}
lp->d_npartitions = 'e' - 'a' + i;
}
*cylp = cyl;
*netbsd_label_offp = mbrpartoff;
*msgp = NULL;
out:
brelse(bp);
return (rv);
}
int
mbr_label_locate(dev, strat, lp, osdep, cylp, netbsd_label_offp)
dev_t dev;
void (*strat) __P((struct buf *));
struct disklabel *lp;
struct cpu_disklabel *osdep;
int *cylp, *netbsd_label_offp;
{
struct mbr_partition *mbrp;
int cyl, mbrpartoff, i;
struct mbr_partition *ourmbrp = NULL;
struct buf *bp;
int rv = 1;
/* get a buffer and initialize it */
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
/* do MBR partitions in the process of getting disklabel? */
mbrpartoff = 0;
cyl = LABELSECTOR / lp->d_secpercyl;
mbrp = osdep->mbrparts;
/* read master boot record */
bp->b_blkno = MBR_BBSECTOR;
bp->b_bcount = lp->d_secsize;
bp->b_flags |= B_READ;
bp->b_cylinder = MBR_BBSECTOR / lp->d_secpercyl;
(*strat)(bp);
if ((rv = biowait(bp)) != 0) {
rv = -rv;
goto out;
}
if (bcmp(bp->b_data + MBRSIGOFS, mbrsig, sizeof(mbrsig))) {
rv = 0;
goto out;
}
/* XXX how do we check veracity/bounds of this? */
bcopy(bp->b_data + MBR_PARTOFF, mbrp, NMBRPART * sizeof(*mbrp));
/* look for NetBSD partition */
ourmbrp = NULL;
for (i = 0; !ourmbrp && i < NMBRPART; i++) {
if (mbrp[i].mbrp_typ == MBR_PTYPE_NETBSD)
ourmbrp = &mbrp[i];
}
#ifdef COMPAT_386BSD_MBRPART
/* didn't find it -- look for 386BSD partition */
for (i = 0; !ourmbrp && i < NMBRPART; i++) {
if (mbrp[i].mbrp_typ == MBR_PTYPE_386BSD) {
printf("WARNING: old BSD partition ID!\n");
ourmbrp = &mbrp[i];
}
}
#endif
if (!ourmbrp) {
rv = 0; /* XXX allow easy clobber? */
goto out;
}
/* need sector address for SCSI/IDE, cylinder for ESDI/ST506/RLL */
mbrpartoff = ourmbrp->mbrp_start;
cyl = MBR_PCYL(ourmbrp->mbrp_scyl, ourmbrp->mbrp_ssect);
*cylp = cyl;
*netbsd_label_offp = mbrpartoff;
out:
brelse(bp);
return (rv);
}

2771
sys/arch/arm32/arm32/pmap.c
View File

File diff suppressed because it is too large Load Diff

114
sys/arch/arm32/arm32/sys_machdep.c
View File

@ -1,114 +0,0 @@
/* $NetBSD: sys_machdep.c,v 1.12 2000/06/29 08:52:58 mrg Exp $ */
/*
* Copyright (c) 1995-1997 Mark Brinicombe.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by Mark Brinicombe
* 4. The name of the company nor the name of the author may be used to
* endorse or promote products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* RiscBSD kernel project
*
* sys_machdep.c
*
* Machine dependant syscalls
*
* Created : 10/01/96
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/mbuf.h>
#include <sys/mount.h>
#include <uvm/uvm_extern.h>
#include <sys/sysctl.h>
#include <sys/syscallargs.h>
#include <machine/sysarch.h>
static int
arm32_sync_icache(p, args, retval)
struct proc *p;
char *args;
register_t *retval;
{
struct arm32_sync_icache_args ua;
int error;
if ((error = copyin(args, &ua, sizeof(ua))) != 0)
return (error);
cpu_cache_syncI_rng(ua.addr, ua.len);
*retval = 0;
return(0);
}
static int
arm32_drain_writebuf(p, args, retval)
struct proc *p;
char *args;
register_t *retval;
{
/* No args. */
cpu_drain_writebuf();
*retval = 0;
return(0);
}
int
sys_sysarch(p, v, retval)
struct proc *p;
void *v;
register_t *retval;
{
struct sys_sysarch_args /* {
syscallarg(int) op;
syscallarg(void *) parms;
} */ *uap = v;
int error = 0;
switch(SCARG(uap, op)) {
case ARM32_SYNC_ICACHE :
error = arm32_sync_icache(p, SCARG(uap, parms), retval);
break;
case ARM32_DRAIN_WRITEBUF :
error = arm32_drain_writebuf(p, SCARG(uap, parms), retval);
break;
default:
error = EINVAL;
break;
}
return (error);
}
/* End of sys_machdep.c */

295
sys/arch/arm32/arm32/syscall.c
View File

@ -1,295 +0,0 @@
/* $NetBSD: syscall.c,v 1.39 2001/02/28 18:15:44 bjh21 Exp $ */
/*-
* Copyright (c) 2000 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Charles M. Hannum.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the NetBSD
* Foundation, Inc. and its contributors.
* 4. Neither the name of The NetBSD Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*
* Copyright (c) 1994-1998 Mark Brinicombe.
* Copyright (c) 1994 Brini.
* All rights reserved.
*
* This code is derived from software written for Brini by Mark Brinicombe
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by Mark Brinicombe
* for the NetBSD Project.
* 4. The name of the company nor the name of the author may be used to
* endorse or promote products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* syscall entry handling
*
* Created : 09/11/94
*/
#include "opt_ktrace.h"
#include "opt_syscall_debug.h"
#include <sys/param.h>
#include <sys/errno.h>
#include <sys/signalvar.h>
#include <sys/systm.h>
#include <sys/reboot.h>
#include <sys/syscall.h>
#include <sys/user.h>
#ifdef KTRACE
#include <sys/ktrace.h>
#endif
#include <uvm/uvm_extern.h>
#include <machine/cpu.h>
#include <machine/frame.h>
#include <machine/katelib.h>
#include <machine/pcb.h>
u_int arm700bugcount = 0;
/*
* syscall(frame):
*
* System call request from POSIX system call gate interface to kernel.
*/
void
syscall(frame, code)
trapframe_t *frame;
int code;
{
caddr_t stackargs;
const struct sysent *callp;
struct proc *p;
int error;
u_int argsize;
int *args, copyargs[8], rval[2];
int regparams;
/*
* Enable interrupts if they were enabled before the exception.
* Since all syscalls *should* come from user mode it will always
* be safe to enable them, but check anyway.
*/
if (!(frame->tf_spsr & I32_bit))
enable_interrupts(I32_bit);
#ifdef DEBUG
if ((GetCPSR() & PSR_MODE) != PSR_SVC32_MODE)
panic("syscall: not in SVC32 mode");
#endif /* DEBUG */
uvmexp.syscalls++;
p = curproc;
p->p_addr->u_pcb.pcb_tf = frame;
#ifdef CPU_ARM7
/*
* This code is only needed if we are including support for the ARM7
* core. Other CPUs do not need it but it does not hurt.
*/
/*
* ARM700/ARM710 match sticks and sellotape job ...
*
* I know this affects GPS/VLSI ARM700/ARM710 + various ARM7500.
*
* On occasion data aborts are mishandled and end up calling
* the swi vector.
*
* If the instruction that caused the exception is not a SWI
* then we hit the bug.
*/
if ((ReadWord(frame->tf_pc - INSN_SIZE) & 0x0f000000) != 0x0f000000) {
frame->tf_pc -= INSN_SIZE;
++arm700bugcount;
userret(p);
return;
}
#endif /* CPU_ARM7 */
/*
* Support for architecture dependant SWIs
*/
if (code & 0x00f00000) {
/*
* Support for the Architecture defined SWI's in case the
* processor does not support them.
*/
switch (code) {
case 0x00f00000 : /* IMB */
case 0x00f00001 : /* IMB_range */
/*
* Do nothing as there is no prefetch unit that needs
* flushing
*/
break;
default:
/* Undefined so illegal instruction */
trapsignal(p, SIGILL, ReadWord(frame->tf_pc - INSN_SIZE));
break;
}
userret(p);
return;
}
stackargs = (caddr_t)&frame->tf_r0;
regparams = 4 * sizeof(int);
callp = p->p_emul->e_sysent;
switch (code) {
case SYS_syscall:
/* Don't have to look in user space, we have it in the trapframe */
/* code = fuword(stackargs);*/
code = ReadWord(stackargs);
stackargs += sizeof(int);
regparams -= sizeof(int);
break;
case SYS___syscall:
if (callp != sysent)
break;
/* Since this will be a register we look in the trapframe not user land */
/* code = fuword(stackargs + _QUAD_LOWWORD * sizeof(int));*/
code = ReadWord(stackargs + _QUAD_LOWWORD * sizeof(int));
stackargs += sizeof(quad_t);
regparams -= sizeof(quad_t);
break;
default:
/* do nothing by default */
break;
}
code &= (SYS_NSYSENT - 1);
callp += code;
argsize = callp->sy_argsize;
if (argsize <= regparams)
args = (int *)stackargs;
else {
args = copyargs;
bcopy(stackargs, (caddr_t)args, regparams);
error = copyin((caddr_t)frame->tf_usr_sp,
(caddr_t)args + regparams, argsize - regparams);
if (error)
goto bad;
}
#ifdef SYSCALL_DEBUG
scdebug_call(p, code, callp->sy_narg, args);
#endif
#ifdef KTRACE
if (KTRPOINT(p, KTR_SYSCALL))
ktrsyscall(p, code, argsize, args);
#endif
rval[0] = 0;
rval[1] = 0;
error = (*callp->sy_call)(p, args, rval);
switch (error) {
case 0:
frame->tf_r0 = rval[0];
frame->tf_r1 = rval[1];
frame->tf_spsr &= ~PSR_C_bit; /* carry bit */
break;
case ERESTART:
/*
* Reconstruct the pc to point at the swi.
*/
frame->tf_pc -= INSN_SIZE;
break;
case EJUSTRETURN:
/* nothing to do */
break;
default:
bad:
frame->tf_r0 = error;
frame->tf_spsr |= PSR_C_bit; /* carry bit */
break;
}
#ifdef SYSCALL_DEBUG
scdebug_ret(p, code, error, rval);
#endif
userret(p);
#ifdef KTRACE
if (KTRPOINT(p, KTR_SYSRET))
ktrsysret(p, code, error, rval[0]);
#endif
}
void
child_return(arg)
void *arg;
{
struct proc *p = arg;
struct trapframe *frame = p->p_addr->u_pcb.pcb_tf;
frame->tf_r0 = 0;
frame->tf_spsr &= ~PSR_C_bit; /* carry bit */
userret(p);
#ifdef KTRACE
if (KTRPOINT(p, KTR_SYSRET))
ktrsysret(p, SYS_fork, 0, 0);
#endif
}
/* End of syscall.c */