Skip to content
Snippets Groups Projects
Commit 571df509 authored by ram's avatar ram
Browse files

Solaris patches.

parent 2c6a7ce1
No related branches found
No related tags found
No related merge requests found
/*
* $Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/lisp/os.h,v 1.4 1994/07/05 16:11:22 hallgren Exp $
* $Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/lisp/os.h,v 1.5 1994/10/25 00:11:29 ram Exp $
*
* Common interface for os-dependent functions.
*
......@@ -31,6 +31,19 @@
#endif
#endif
#ifndef HANDLER_ARGS
#define HANDLER_ARGS int signal, int code, struct sigcontext *context
#endif
#ifndef CODE
#define CODE(code) code
#endif
#ifndef CTXT_SIGMASK
#define CTXT_SIGMASK(context) context->sc_mask
#endif
#ifndef SAVE_CONTEXT
#define SAVE_CONTEXT() do {} while(0)
#endif
#define OS_VM_PROT_ALL (OS_VM_PROT_READ|OS_VM_PROT_WRITE|OS_VM_PROT_EXECUTE)
extern os_vm_size_t os_vm_page_size;
......
/* $Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/lisp/parse.c,v 1.1.1.1 1994/10/24 19:49:55 ram Exp $ */
/* $Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/lisp/parse.c,v 1.2 1994/10/25 00:09:21 ram Exp $ */
#include <stdio.h>
#include <ctype.h>
#include <signal.h>
......
/*
* $Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/lisp/runprog.c,v 1.1.1.1 1994/10/24 19:50:05 ram Exp $
* $Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/lisp/runprog.c,v 1.2 1994/10/25 00:12:10 ram Exp $
*
* Support for run-program.
*
......
#include <stdio.h>
#ifdef SOLARIS
#include <sys/trap.h>
#else
#include <machine/trap.h>
#endif
#include "arch.h"
#include "lisp.h"
#include "internals.h"
#include "globals.h"
#include "validate.h"
#include "os.h"
#include "arch.h"
#include "lispregs.h"
#include "signal.h"
#include "interrupt.h"
char *arch_init()
{
return NULL;
return 0;
}
os_vm_address_t arch_get_bad_addr(int signal, int code,
struct sigcontext *context)
os_vm_address_t arch_get_bad_addr(HANDLER_ARGS)
{
unsigned long badinst;
int rs1;
......@@ -26,19 +29,19 @@ os_vm_address_t arch_get_bad_addr(int signal, int code,
/* Make sure it's not the pc thats bogus, and that it was lisp code */
/* that caused the fault. */
if ((context->sc_pc & 3) != 0 ||
((context->sc_pc < READ_ONLY_SPACE_START ||
context->sc_pc >= READ_ONLY_SPACE_START+READ_ONLY_SPACE_SIZE) &&
((lispobj *)context->sc_pc < current_dynamic_space &&
(lispobj *)context->sc_pc >=
if ((SC_PC(context) & 3) != 0 ||
((SC_PC(context) < READ_ONLY_SPACE_START ||
SC_PC(context) >= READ_ONLY_SPACE_START+READ_ONLY_SPACE_SIZE) &&
((lispobj *)SC_PC(context) < current_dynamic_space &&
(lispobj *)SC_PC(context) >=
current_dynamic_space + DYNAMIC_SPACE_SIZE)))
return NULL;
return 0;
badinst = *(unsigned long *)context->sc_pc;
badinst = *(unsigned long *)SC_PC(context);
if ((badinst >> 30) != 3)
/* All load/store instructions have op = 11 (binary) */
return NULL;
return 0;
rs1 = (badinst>>14)&0x1f;
......@@ -64,13 +67,13 @@ void arch_skip_instruction(context)
struct sigcontext *context;
{
/* Skip the offending instruction */
context->sc_pc = context->sc_npc;
context->sc_npc += 4;
SC_PC(context) = SC_NPC(context);
SC_NPC(context) += 4;
}
unsigned char *arch_internal_error_arguments(struct sigcontext *scp)
{
return (unsigned char *)(scp->sc_pc+4);
return (unsigned char *)(SC_PC(scp)+4);
}
boolean arch_pseudo_atomic_atomic(struct sigcontext *scp)
......@@ -97,99 +100,129 @@ void arch_remove_breakpoint(void *pc, unsigned long orig_inst)
}
static unsigned long *skipped_break_addr, displaced_after_inst;
#ifdef POSIX_SIGS
static sigset_t orig_sigmask;
#else
static int orig_sigmask;
#endif
void arch_do_displaced_inst(struct sigcontext *scp,
unsigned long orig_inst)
{
unsigned long *pc = (unsigned long *)scp->sc_pc;
unsigned long *npc = (unsigned long *)scp->sc_npc;
unsigned long *pc = (unsigned long *)SC_PC(scp);
unsigned long *npc = (unsigned long *)SC_NPC(scp);
#ifdef POSIX_SIGS
orig_sigmask = scp->uc_sigmask;
sigemptyset(&scp->uc_sigmask);
FILLBLOCKSET(&scp->uc_sigmask);
#else
orig_sigmask = scp->sc_mask;
scp->sc_mask = BLOCKABLE;
#endif
*pc = orig_inst;
skipped_break_addr = pc;
displaced_after_inst = *npc;
*npc = trap_AfterBreakpoint;
#ifdef SOLARIS
/* XXX never tested */
setcontext(scp);
#else
sigreturn(scp);
#endif
}
static void sigill_handler(signal, code, scp)
int signal, code;
struct sigcontext *scp;
static void sigill_handler(HANDLER_ARGS)
{
int badinst;
sigsetmask(scp->sc_mask);
SAVE_CONTEXT();
#ifdef POSIX_SIGS
sigprocmask(SIG_SETMASK, &context->uc_sigmask, 0);
#else
sigsetmask(context->sc_mask);
#endif
if (code == T_UNIMP_INSTR) {
#ifdef SOLARIS
if (CODE(code) == ILL_ILLOPC)
#else
if (CODE(code) == T_UNIMP_INSTR)
#endif
{
int trap;
trap = *(unsigned long *)(scp->sc_pc) & 0x3fffff;
trap = *(unsigned long *)(SC_PC(context)) & 0x3fffff;
switch (trap) {
case trap_PendingInterrupt:
arch_skip_instruction(scp);
interrupt_handle_pending(scp);
arch_skip_instruction(context);
interrupt_handle_pending(context);
break;
case trap_Halt:
fake_foreign_function_call(scp);
fake_foreign_function_call(context);
lose("%%primitive halt called; the party is over.\n");
case trap_Error:
case trap_Cerror:
interrupt_internal_error(signal, code, scp, trap == trap_Cerror);
interrupt_internal_error(signal, code, context, trap == trap_Cerror);
break;
case trap_Breakpoint:
handle_breakpoint(signal, code, scp);
handle_breakpoint(signal, code, context);
break;
case trap_FunctionEndBreakpoint:
scp->sc_pc=(int)handle_function_end_breakpoint(signal, code, scp);
scp->sc_npc=scp->sc_pc + 4;
SC_PC(context)=(int)handle_function_end_breakpoint(signal, code, context);
SC_NPC(context)=SC_PC(context) + 4;
break;
case trap_AfterBreakpoint:
*skipped_break_addr = trap_Breakpoint;
skipped_break_addr = NULL;
*(unsigned long *)scp->sc_pc = displaced_after_inst;
scp->sc_mask = orig_sigmask;
*(unsigned long *)SC_PC(context) = displaced_after_inst;
#ifdef POSIX_SIGS
context->uc_sigmask = orig_sigmask;
#else
context->sc_mask = orig_sigmask;
#endif
break;
default:
interrupt_handle_now(signal, code, scp);
interrupt_handle_now(signal, code, context);
break;
}
}
else if (code >= T_SOFTWARE_TRAP + 16 & code < T_SOFTWARE_TRAP + 32)
interrupt_internal_error(signal, code, scp, FALSE);
#ifdef SOLARIS
else if (CODE(code) == ILL_ILLTRP)
#else
else if (CODE(code) >= T_SOFTWARE_TRAP + 16 & CODE(code) < T_SOFTWARE_TRAP + 32)
#endif
interrupt_internal_error(signal, code, context, FALSE);
else
interrupt_handle_now(signal, code, scp);
interrupt_handle_now(signal, code, context);
}
static void sigemt_handler(signal, code, scp)
int signal, code;
struct sigcontext *scp;
static void sigemt_handler(HANDLER_ARGS)
{
unsigned long badinst;
boolean subtract, immed;
int rd, rs1, op1, rs2, op2, result;
badinst = *(unsigned long *)scp->sc_pc;
badinst = *(unsigned long *)SC_PC(context);
if ((badinst >> 30) != 2 || ((badinst >> 20) & 0x1f) != 0x11) {
/* It wasn't a tagged add. Pass the signal into lisp. */
interrupt_handle_now(signal, code, scp);
interrupt_handle_now(signal, code, context);
return;
}
/* Extract the parts of the inst. */
subtract = badinst & (1<<19);
rs1 = (badinst>>14) & 0x1f;
op1 = SC_REG(scp, rs1);
op1 = SC_REG(context, rs1);
/* If the first arg is $ALLOC then it is really a signal-pending note */
/* for the pseudo-atomic noise. */
......@@ -202,15 +235,15 @@ static void sigemt_handler(signal, code, scp)
result = op1 - op2;
else
result = op1 + op2;
SC_REG(scp, reg_ALLOC) = result & ~7;
arch_skip_instruction(scp);
interrupt_handle_pending(scp);
SC_REG(context, reg_ALLOC) = result & ~7;
arch_skip_instruction(context);
interrupt_handle_pending(context);
return;
}
if ((op1 & 3) != 0) {
/* The first arg wan't a fixnum. */
interrupt_internal_error(signal, code, scp, FALSE);
interrupt_internal_error(signal, code, context, FALSE);
return;
}
......@@ -221,12 +254,12 @@ static void sigemt_handler(signal, code, scp)
}
else {
rs2 = badinst & 0x1f;
op2 = SC_REG(scp, rs2);
op2 = SC_REG(context, rs2);
}
if ((op2 & 3) != 0) {
/* The second arg wan't a fixnum. */
interrupt_internal_error(signal, code, scp, FALSE);
interrupt_internal_error(signal, code, context, FALSE);
return;
}
......@@ -239,15 +272,15 @@ static void sigemt_handler(signal, code, scp)
result = (op1>>2) + (op2>>2);
current_dynamic_space_free_pointer =
(lispobj *) SC_REG(scp, reg_ALLOC);
(lispobj *) SC_REG(context, reg_ALLOC);
SC_REG(scp, rd) = alloc_number(result);
SC_REG(context, rd) = alloc_number(result);
SC_REG(scp, reg_ALLOC) =
SC_REG(context, reg_ALLOC) =
(unsigned long) current_dynamic_space_free_pointer;
}
arch_skip_instruction(scp);
arch_skip_instruction(context);
}
void arch_install_interrupt_handlers()
......
#ifdef SOLARIS
#define _ASM
#include <sys/asm_linkage.h>
#include <sys/psw.h>
#include <sys/trap.h>
#define _current_binding_stack_pointer current_binding_stack_pointer
#define _current_control_stack_pointer current_control_stack_pointer
#define _current_dynamic_space_free_pointer current_dynamic_space_free_pointer
#define _foreign_function_call_active foreign_function_call_active
#define _current_control_frame_pointer current_control_frame_pointer
#define _call_into_lisp call_into_lisp
#define _function_end_breakpoint_end function_end_breakpoint_end
#define _closure_tramp closure_tramp
#define _undefined_tramp undefined_tramp
#define _function_end_breakpoint_trap function_end_breakpoint_trap
#define _function_end_breakpoint_guts function_end_breakpoint_guts
#define _call_into_c call_into_c
#define _flush_icache flush_icache
#ifdef __STDC__
#define FUNCDEF(x) .type x, \#function
#else
#define FUNCDEF(x) .type x, #function
#endif
#else
#include <machine/asm_linkage.h>
#include <machine/psl.h>
#include <machine/trap.h>
#define FUNCDEF(x) /* nothing */
#define SET_SIZE(x) /* nothing */
#endif
#define LANGUAGE_ASSEMBLY
#include "lispregs.h"
......@@ -18,6 +45,7 @@
.seg "text"
.global _call_into_lisp
FUNCDEF(_call_into_lisp)
_call_into_lisp:
save %sp, -FRAMESIZE, %sp
......@@ -110,10 +138,12 @@ lra:
ld [%sp+FRAMESIZE-4], %i7
ret
restore %sp, FRAMESIZE, %sp
SET_SIZE(_call_into_lisp)
.global _call_into_c
FUNCDEF(_call_into_c)
_call_into_c:
/* Build a lisp stack frame */
mov reg_CFP, reg_OCFP
......@@ -182,9 +212,11 @@ _call_into_c:
ret
nop
SET_SIZE(_call_into_c)
.global _undefined_tramp
FUNCDEF(_undefined_tramp)
.align 8
.byte 0
_undefined_tramp:
......@@ -203,8 +235,10 @@ _undefined_tramp:
ld [reg_FDEFN+FDEFN_RAW_ADDR_OFFSET], reg_CODE
jmp reg_CODE+FUNCTION_CODE_OFFSET
nop
SET_SIZE(_undefined_tramp)
.global _closure_tramp
FUNCDEF(_closure_tramp)
.align 8
.byte 0
_closure_tramp:
......@@ -219,6 +253,7 @@ _closure_tramp:
ld [reg_LEXENV+CLOSURE_FUNCTION_OFFSET], reg_CODE
jmp reg_CODE+FUNCTION_CODE_OFFSET
nop
SET_SIZE(_closure_tramp)
......@@ -252,10 +287,21 @@ _function_end_breakpoint_trap:
.global _function_end_breakpoint_end
_function_end_breakpoint_end:
.global _flush_icache
FUNCDEF(_flush_icache)
_flush_icache:
iflush %i0 ! flush instruction cache
retl ! return from leaf routine
nop
SET_SIZE(_flush_icache)
#ifndef SOLARIS
/****************************************************************\
* State saving and restoring.
\****************************************************************/
.global _call_on_stack
_call_on_stack:
call %o0
......@@ -295,6 +341,7 @@ _restore_state:
mov %o0, %i0
/****************************************************************\
We need our own version of sigtramp.
......@@ -493,3 +540,13 @@ _sigreturn:
unimp 0 ! just in case it returns
/*NOTREACHED*/
#else /* SOLARIS */
.global save_context
FUNCDEF(save_context)
save_context:
ta ST_FLUSH_WINDOWS ! flush register windows
retl ! return from leaf routine
nop
SET_SIZE(save_context)
#endif
/* $Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/lisp/sparc-lispregs.h,v 1.2 1994/07/07 10:45:42 wlott Exp $ */
/* $Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/lisp/sparc-lispregs.h,v 1.3 1994/10/25 00:15:24 ram Exp $ */
#ifdef LANGUAGE_ASSEMBLY
#define GREG(num) %g ## num
#define OREG(num) %o ## num
#define LREG(num) %l ## num
#define IREG(num) %i ## num
#ifdef __STDC__
/* Standard C token concatenation */
#define CAT(a,b) a ## b
#else
/* Reisser CPP token concatenation */
#define CAT(a,b) a/**/b
#endif
/*
* Note: concatenation to non preprocessor symbols is not defined,
* SunPRO C 2.0.1 yields % g0, perfectly valid according to ANSI
*/
#define GREG(num) CAT(%g,num)
#define OREG(num) CAT(%o,num)
#define LREG(num) CAT(%l,num)
#define IREG(num) CAT(%i,num)
#else
......@@ -70,8 +86,25 @@
#ifndef LANGUAGE_ASSEMBLY
#ifdef SOLARIS
#include <ucontext.h>
extern int * solaris_register_address(struct ucontext *, int);
#define SC_REG(sc, reg) (*solaris_register_address(sc,reg))
/* short cuts */
#define SC_PC(sc) ((sc)->uc_mcontext.gregs[REG_PC])
#define SC_NPC(sc) ((sc)->uc_mcontext.gregs[REG_nPC])
#else
#define SC_REG(sc, n) (((int *)((sc)->sc_g1))[n])
#define SC_PC(sc) ((sc)->sc_pc)
#define SC_NPC(sc) ((sc)->sc_npc)
#endif /* SOLARIS */
#endif
#define READ_ONLY_SPACE_START (0x00200000)
#define READ_ONLY_SPACE_SIZE (0x0bdf8000)
#define READ_ONLY_SPACE_START (0x01000000)
#define READ_ONLY_SPACE_SIZE (0x03ff8000)
#define STATIC_SPACE_START (0x05000000)
#define STATIC_SPACE_SIZE (0x01ff8000)
#define STATIC_SPACE_START (0x0c000000)
#define STATIC_SPACE_SIZE (0x03ff8000)
#define DYNAMIC_0_SPACE_START (0x07000000)
#define DYNAMIC_1_SPACE_START (0x0b000000)
#define DYNAMIC_SPACE_SIZE (0x03ff8000)
#define DYNAMIC_0_SPACE_START (0x10000000)
#define DYNAMIC_1_SPACE_START (0x18000000)
#define DYNAMIC_SPACE_SIZE (0x07ff8000)
#define CONTROL_STACK_START (0x00900000)
#define CONTROL_STACK_SIZE (0x00078000)
#define CONTROL_STACK_START (0x00100000)
#define CONTROL_STACK_SIZE (0x00078000)
#define BINDING_STACK_START (0x00980000)
#define BINDING_STACK_SIZE (0x00078000)
#define BINDING_STACK_START (0x00180000)
#define BINDING_STACK_SIZE (0x00078000)
#define HOLES {0x0bff8000, 0x0fff8000, 0x17ff8000, 0x1fff8000}
#define HOLES {0x04ff8000, 0x06ff8000, 0x0aff8000, 0x1fff8000}
#define HOLE_SIZE 0x2000
/*
* $Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/lisp/sunos-os.c,v 1.2 1994/10/24 19:17:10 ram Exp $
* $Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/lisp/sunos-os.c,v 1.3 1994/10/25 00:19:13 ram Exp $
*
* OS-dependent routines. This file (along with os.h) exports an
* OS-independent interface to the operating system VM facilities.
......@@ -19,6 +19,22 @@
#include <signal.h>
#include <sys/file.h>
#ifdef SOLARIS
#include <unistd.h>
#include <errno.h>
#include <sys/param.h>
#define OS_PROTERR SEGV_ACCERR
#define OS_MAPERR SEGV_MAPERR
#define OS_HASERRNO(code) ((code)->si_errno != 0)
#define OS_ERRNO(code) ((code)->si_errno)
#else
#define OS_PROTERR SEGV_PROT
#define OS_MAPERR SEGV_NOMAP
#define OS_HASERRNO(code) (SEGV_CODE(code)==SEGV_OBJERR)
#define OS_ERRNO(code) SEGV_ERRNO(code)
extern int errno;
#endif /* SOLARIS */
#include "os.h"
/* block size must be larger than the system page size */
......@@ -42,6 +58,7 @@ extern char *getenv();
#define ADJ_OFFSET(off,adj) (((off)==OFFSET_NONE) ? OFFSET_NONE : ((off)+(adj)))
long os_vm_page_size=(-1);
static long os_real_page_size=(-1);
static struct segment {
os_vm_address_t start; /* note: start & length are expected to be on page */
......@@ -83,7 +100,12 @@ void os_init()
if(zero_fd<0)
os_init_bailout(ZEROFILE);
os_vm_page_size=getpagesize();
#ifdef SOLARIS
os_vm_page_size = os_real_page_size = sysconf(_SC_PAGESIZE);
#else
os_vm_page_size = os_real_page_size = getpagesize();
#endif
max_segments=INITIAL_MAX_SEGS;
segments=(struct segment *)malloc(sizeof(struct segment)*max_segments);
......@@ -238,6 +260,25 @@ os_vm_size_t len;
return FALSE;
}
#if 0 /* WAY to SLOW */
/* returns TRUE if the range from addr to addr+len is a valid mapping
* (that we don't know about) */
static boolean mem_in_use(addr,len)
os_vm_address_t addr;
os_vm_size_t len;
{
os_vm_address_t p;
for (p = addr; addr < addr + len; p += os_real_page_size) {
char c;
if (mincore((caddr_t)p, os_real_page_size, &c) == 0 || errno != ENOMEM)
return TRUE;
}
return FALSE;
}
#endif
#define seg_last_p(seg) (((seg)-segments)>=n_segments-1)
static void seg_destroy(seg)
......@@ -461,11 +502,11 @@ int is_readable;
addr=os_round_up_to_page(real);
if(addr!=real)
munmap(real,addr-real);
munmap((caddr_t)real,addr-real);
overflow=real_page_size_difference-(addr-real);
if(overflow!=0)
munmap(addr+len-real_page_size_difference,overflow);
munmap((caddr_t)(addr+len-real_page_size_difference),overflow);
real=addr;
}
......@@ -493,7 +534,7 @@ int is_readable;
seg=seg_create(real,len,protection,map_fd,offset);
if(seg==NULL){
munmap(real,len);
munmap((caddr_t)real,len);
return NULL;
}
}
......@@ -546,7 +587,7 @@ os_vm_size_t len;
seg_destroy(seg);
last_fault=0;
if(munmap(addr,len)!=0)
if(munmap((caddr_t)addr,len)!=0)
perror("os_invalidate: munmap");
}
}
......@@ -625,9 +666,7 @@ os_vm_address_t test;
/* ---------------------------------------------------------------- */
static boolean maybe_gc(sig, code, context)
int sig, code;
struct sigcontext *context;
static boolean maybe_gc(HANDLER_ARGS)
{
/*
* It's necessary to enable recursive SEGVs, since the handle is
......@@ -641,10 +680,16 @@ struct sigcontext *context;
if(already_trying)
return FALSE;
SAVE_CONTEXT();
#ifdef POSIX_SIGS
sigprocmask(SIG_SETMASK, &context->uc_sigmask,0);
#else
sigsetmask(context->sc_mask);
#endif
already_trying=TRUE;
did_gc=interrupt_maybe_gc(sig, code, context);
did_gc=interrupt_maybe_gc(signal, code, context);
already_trying=FALSE;
return did_gc;
......@@ -658,16 +703,23 @@ struct sigcontext *context;
*
* Running into the gc trigger page will also end up here...
*/
void segv_handler(sig, code, context, addr)
int sig, code;
struct sigcontext *context;
caddr_t addr;
#ifndef SOLARIS
void segv_handler(HANDLER_ARGS, caddr_t addr)
#else
void segv_handler(HANDLER_ARGS)
#endif /* SOLARIS */
{
if (code == SEGV_PROT) { /* allow writes to this chunk */
#ifdef SOLARIS
caddr_t addr = code->si_addr;
#endif
SAVE_CONTEXT();
if (CODE(code) == OS_PROTERR) { /* allow writes to this chunk */
struct segment *seg=seg_find(addr);
if(last_fault==addr){
if(seg!=NULL && maybe_gc(sig, code, context))
if((caddr_t)last_fault==addr){
if(seg!=NULL && maybe_gc(signal, code, context))
/* we just garbage collected */
return;
else{
......@@ -675,10 +727,10 @@ caddr_t addr;
fprintf(stderr,
"segv_handler: Real protection violation: 0x%08x\n",
addr);
interrupt_handle_now(sig,code,context);
interrupt_handle_now(signal,code,context);
}
}else
last_fault=addr;
last_fault=(os_vm_address_t) addr;
if(seg!=NULL){
int err;
......@@ -695,13 +747,13 @@ caddr_t addr;
#if 0
/* unmap it. probably redundant. */
if(munmap(block,length) == -1)
if(munmap((caddr_t)block,length) == -1)
perror("segv_handler: munmap");
#endif
/* and remap it with more permissions */
err=(int)
mmap(block,
mmap((caddr_t)block,
length,
seg->protection,
MAP_PRIVATE|MAP_FIXED,
......@@ -712,21 +764,21 @@ caddr_t addr;
if (err == -1) {
perror("segv_handler: mmap");
interrupt_handle_now(sig,code,context);
interrupt_handle_now(signal,code,context);
}
}
else{
fprintf(stderr, "segv_handler: 0x%08x not in any segment\n",addr);
interrupt_handle_now(sig,code,context);
interrupt_handle_now(signal,code,context);
}
}
/*
* note that we check for a gc-trigger hit even if it's not a PROT error
*/
else if(!maybe_gc(sig, code, context)){
else if(!maybe_gc(signal, code, context)){
static int nomap_count=0;
if(code==SEGV_NOMAP){
if(CODE(code)==OS_MAPERR){
if(nomap_count==0){
fprintf(stderr,
"segv_handler: No mapping fault: 0x%08x\n",addr);
......@@ -741,15 +793,14 @@ caddr_t addr;
"segv_handler: Recursive no mapping fault (stack overflow?)\n");
exit(-1);
}
}else if(SEGV_CODE(code)==SEGV_OBJERR){
extern int errno;
errno=SEGV_ERRNO(code);
} else if(OS_HASERRNO(code)) {
errno=OS_ERRNO(code);
perror("segv_handler: Object error");
}
interrupt_handle_now(sig,code,context);
interrupt_handle_now(signal,code,context);
if(code==SEGV_NOMAP)
if(CODE(code)==OS_MAPERR)
nomap_count--;
}
}
......@@ -758,3 +809,156 @@ void os_install_interrupt_handlers()
{
interrupt_install_low_level_handler(SIGSEGV,segv_handler);
}
#ifdef SOLARIS
/* function defintions for register lvalues */
int * solaris_register_address(struct ucontext *context, int reg)
{
if (reg == 0) {
static int zero;
zero = 0;
return &zero;
} else if (reg < 16) {
return &context->uc_mcontext.gregs[reg+3];
} else if (reg < 32) {
int *sp = (int*) context->uc_mcontext.gregs[REG_SP];
return &sp[reg-16];
} else
return 0;
}
/* function defintions for backward compatibilty and static linking */
#if 0
void * dlopen(const char * file, int flag) { return 0; }
void * dlsym(void *obj, const char *sym) { return 0; }
int dlclose(void *obj) { return 0; }
char * dlerror(void) { return "no dynamic linking"; }
#endif
/* For now we put in some porting functions */
int
getdtablesize(void)
{
return sysconf(_SC_OPEN_MAX);
}
char *
getwd(char *path)
{
return getcwd(path, MAXPATHLEN);
}
int
getpagesize(void)
{
return sysconf(_SC_PAGESIZE);
}
#include <sys/procfs.h>
/* Old rusage definition */
struct rusage {
struct timeval ru_utime; /* user time used */
struct timeval ru_stime; /* system time used */
long ru_maxrss;
#define ru_first ru_ixrss
long ru_ixrss; /* XXX: 0 */
long ru_idrss; /* XXX: sum of rm_asrss */
long ru_isrss; /* XXX: 0 */
long ru_minflt; /* any page faults not requiring I/O */
long ru_majflt; /* any page faults requiring I/O */
long ru_nswap; /* swaps */
long ru_inblock; /* block input operations */
long ru_oublock; /* block output operations */
long ru_msgsnd; /* messages sent */
long ru_msgrcv; /* messages received */
long ru_nsignals; /* signals received */
long ru_nvcsw; /* voluntary context switches */
long ru_nivcsw; /* involuntary " */
#define ru_last ru_nivcsw
};
int
getrusage(int who, struct rusage *rp)
{
memset(rp, 0, sizeof(struct rusage));
return 0;
}
int
setreuid()
{
fprintf(stderr,"setreuid unimplemented\n");
errno = ENOSYS;
return -1;
}
int
setregid()
{
fprintf(stderr,"setregid unimplemented\n");
errno = ENOSYS;
return -1;
}
int
gethostid()
{
fprintf(stderr,"gethostid unimplemented\n");
errno = ENOSYS;
return -1;
}
int
killpg(int pgrp, int sig)
{
if (pgrp < 0) {
errno = ESRCH;
return -1;
}
return kill(-pgrp, sig);
}
int
sigblock(int mask)
{
sigset_t old, new;
sigemptyset(&new);
new.__sigbits[0] = mask;
sigprocmask(SIG_BLOCK, &new, &old);
return old.__sigbits[0];
}
int
wait3(int *status, int options, struct rusage *rp)
{
if (rp)
memset(rp, 0, sizeof(struct rusage));
return waitpid(-1, status, options);
}
int
sigsetmask(int mask)
{
sigset_t old, new;
sigemptyset(&new);
new.__sigbits[0] = mask;
sigprocmask(SIG_SETMASK, &new, &old);
return old.__sigbits[0];
}
#endif /* SOLARIS */
/* Routines that must be linked into the core for lisp to work. */
/* $Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/lisp/undefineds.c,v 1.2 1993/08/18 22:14:34 wlott Exp $ */
/* $Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/lisp/undefineds.c,v 1.3 1994/10/25 00:20:38 ram Exp $ */
#ifdef sun
#ifndef MACH
#if !defined(SUNOS) && !defined(SOLARIS)
#define SUNOS
#endif
#endif
#endif
typedef int func();
......
/* $Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/lisp/vars.c,v 1.1.1.1 1994/10/24 19:53:01 ram Exp $ */
/* $Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/lisp/vars.c,v 1.2 1994/10/25 00:21:19 ram Exp $ */
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment