/[cmucl]/src/lisp/sunos-os.c
ViewVC logotype

Diff of /src/lisp/sunos-os.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.2 by ram, Mon Oct 24 19:17:10 1994 UTC revision 1.3 by ram, Tue Oct 25 00:19:13 1994 UTC
# Line 19  Line 19 
19  #include <signal.h>  #include <signal.h>
20  #include <sys/file.h>  #include <sys/file.h>
21    
22    #ifdef SOLARIS
23    #include <unistd.h>
24    #include <errno.h>
25    #include <sys/param.h>
26    #define OS_PROTERR              SEGV_ACCERR
27    #define OS_MAPERR               SEGV_MAPERR
28    #define OS_HASERRNO(code)       ((code)->si_errno != 0)
29    #define OS_ERRNO(code)          ((code)->si_errno)
30    #else
31    #define OS_PROTERR              SEGV_PROT
32    #define OS_MAPERR               SEGV_NOMAP
33    #define OS_HASERRNO(code)       (SEGV_CODE(code)==SEGV_OBJERR)
34    #define OS_ERRNO(code)          SEGV_ERRNO(code)
35    extern int errno;
36    #endif /* SOLARIS */
37    
38  #include "os.h"  #include "os.h"
39    
40  /* block size must be larger than the system page size */  /* block size must be larger than the system page size */
# Line 42  extern char *getenv(); Line 58  extern char *getenv();
58  #define ADJ_OFFSET(off,adj) (((off)==OFFSET_NONE) ? OFFSET_NONE : ((off)+(adj)))  #define ADJ_OFFSET(off,adj) (((off)==OFFSET_NONE) ? OFFSET_NONE : ((off)+(adj)))
59    
60  long os_vm_page_size=(-1);  long os_vm_page_size=(-1);
61    static long os_real_page_size=(-1);
62    
63  static struct segment {  static struct segment {
64      os_vm_address_t start;      /* note: start & length are expected to be on page */      os_vm_address_t start;      /* note: start & length are expected to be on page */
# Line 83  void os_init() Line 100  void os_init()
100      if(zero_fd<0)      if(zero_fd<0)
101          os_init_bailout(ZEROFILE);          os_init_bailout(ZEROFILE);
102    
103      os_vm_page_size=getpagesize();  
104    #ifdef SOLARIS
105        os_vm_page_size = os_real_page_size = sysconf(_SC_PAGESIZE);
106    #else
107        os_vm_page_size = os_real_page_size = getpagesize();
108    #endif
109    
110      max_segments=INITIAL_MAX_SEGS;      max_segments=INITIAL_MAX_SEGS;
111      segments=(struct segment *)malloc(sizeof(struct segment)*max_segments);      segments=(struct segment *)malloc(sizeof(struct segment)*max_segments);
# Line 238  os_vm_size_t len; Line 260  os_vm_size_t len;
260      return FALSE;      return FALSE;
261  }  }
262    
263    #if 0 /* WAY to SLOW */
264    /* returns TRUE if the range from addr to addr+len is a valid mapping
265     * (that we don't know about) */
266    static boolean mem_in_use(addr,len)
267    os_vm_address_t addr;
268    os_vm_size_t len;
269    {
270        os_vm_address_t p;
271    
272        for (p = addr; addr < addr + len; p += os_real_page_size) {
273            char c;
274    
275            if (mincore((caddr_t)p, os_real_page_size, &c) == 0 || errno != ENOMEM)
276                return TRUE;
277        }
278        return FALSE;
279    }
280    #endif
281    
282  #define seg_last_p(seg) (((seg)-segments)>=n_segments-1)  #define seg_last_p(seg) (((seg)-segments)>=n_segments-1)
283    
284  static void seg_destroy(seg)  static void seg_destroy(seg)
# Line 461  int is_readable; Line 502  int is_readable;
502    
503          addr=os_round_up_to_page(real);          addr=os_round_up_to_page(real);
504          if(addr!=real)          if(addr!=real)
505              munmap(real,addr-real);              munmap((caddr_t)real,addr-real);
506    
507          overflow=real_page_size_difference-(addr-real);          overflow=real_page_size_difference-(addr-real);
508          if(overflow!=0)          if(overflow!=0)
509              munmap(addr+len-real_page_size_difference,overflow);              munmap((caddr_t)(addr+len-real_page_size_difference),overflow);
510    
511          real=addr;          real=addr;
512      }      }
# Line 493  int is_readable; Line 534  int is_readable;
534              seg=seg_create(real,len,protection,map_fd,offset);              seg=seg_create(real,len,protection,map_fd,offset);
535    
536          if(seg==NULL){          if(seg==NULL){
537              munmap(real,len);              munmap((caddr_t)real,len);
538              return NULL;              return NULL;
539          }          }
540      }      }
# Line 546  os_vm_size_t len; Line 587  os_vm_size_t len;
587              seg_destroy(seg);              seg_destroy(seg);
588    
589          last_fault=0;          last_fault=0;
590          if(munmap(addr,len)!=0)          if(munmap((caddr_t)addr,len)!=0)
591              perror("os_invalidate: munmap");              perror("os_invalidate: munmap");
592      }      }
593  }  }
# Line 625  os_vm_address_t test; Line 666  os_vm_address_t test;
666    
667  /* ---------------------------------------------------------------- */  /* ---------------------------------------------------------------- */
668    
669  static boolean maybe_gc(sig, code, context)  static boolean maybe_gc(HANDLER_ARGS)
 int sig, code;  
 struct sigcontext *context;  
670  {  {
671      /*      /*
672       * It's necessary to enable recursive SEGVs, since the handle is       * It's necessary to enable recursive SEGVs, since the handle is
# Line 641  struct sigcontext *context; Line 680  struct sigcontext *context;
680      if(already_trying)      if(already_trying)
681          return FALSE;          return FALSE;
682    
683        SAVE_CONTEXT();
684    
685    #ifdef POSIX_SIGS
686        sigprocmask(SIG_SETMASK, &context->uc_sigmask,0);
687    #else
688      sigsetmask(context->sc_mask);      sigsetmask(context->sc_mask);
689    #endif
690    
691      already_trying=TRUE;      already_trying=TRUE;
692      did_gc=interrupt_maybe_gc(sig, code, context);      did_gc=interrupt_maybe_gc(signal, code, context);
693      already_trying=FALSE;      already_trying=FALSE;
694    
695      return did_gc;      return did_gc;
# Line 658  struct sigcontext *context; Line 703  struct sigcontext *context;
703   *   *
704   * Running into the gc trigger page will also end up here...   * Running into the gc trigger page will also end up here...
705   */   */
706  void segv_handler(sig, code, context, addr)  #ifndef SOLARIS
707  int sig, code;  void segv_handler(HANDLER_ARGS, caddr_t addr)
708  struct sigcontext *context;  #else
709  caddr_t addr;  void segv_handler(HANDLER_ARGS)
710    #endif /* SOLARIS */
711  {  {
712      if (code == SEGV_PROT) {    /* allow writes to this chunk */  #ifdef SOLARIS
713        caddr_t addr = code->si_addr;
714    #endif
715    
716        SAVE_CONTEXT();
717    
718        if (CODE(code) == OS_PROTERR) {     /* allow writes to this chunk */
719          struct segment *seg=seg_find(addr);          struct segment *seg=seg_find(addr);
720    
721          if(last_fault==addr){          if((caddr_t)last_fault==addr){
722              if(seg!=NULL && maybe_gc(sig, code, context))              if(seg!=NULL && maybe_gc(signal, code, context))
723                  /* we just garbage collected */                  /* we just garbage collected */
724                  return;                  return;
725              else{              else{
# Line 675  caddr_t addr; Line 727  caddr_t addr;
727                  fprintf(stderr,                  fprintf(stderr,
728                          "segv_handler: Real protection violation: 0x%08x\n",                          "segv_handler: Real protection violation: 0x%08x\n",
729                          addr);                          addr);
730                  interrupt_handle_now(sig,code,context);                  interrupt_handle_now(signal,code,context);
731              }              }
732          }else          }else
733              last_fault=addr;              last_fault=(os_vm_address_t) addr;
734    
735          if(seg!=NULL){          if(seg!=NULL){
736              int err;              int err;
# Line 695  caddr_t addr; Line 747  caddr_t addr;
747    
748  #if 0  #if 0
749              /* unmap it.  probably redundant. */              /* unmap it.  probably redundant. */
750              if(munmap(block,length) == -1)              if(munmap((caddr_t)block,length) == -1)
751                  perror("segv_handler: munmap");                  perror("segv_handler: munmap");
752  #endif  #endif
753    
754              /* and remap it with more permissions */              /* and remap it with more permissions */
755              err=(int)              err=(int)
756                  mmap(block,                  mmap((caddr_t)block,
757                       length,                       length,
758                       seg->protection,                       seg->protection,
759                       MAP_PRIVATE|MAP_FIXED,                       MAP_PRIVATE|MAP_FIXED,
# Line 712  caddr_t addr; Line 764  caddr_t addr;
764    
765              if (err == -1) {              if (err == -1) {
766                  perror("segv_handler: mmap");                  perror("segv_handler: mmap");
767                  interrupt_handle_now(sig,code,context);                  interrupt_handle_now(signal,code,context);
768              }              }
769          }          }
770          else{          else{
771              fprintf(stderr, "segv_handler: 0x%08x not in any segment\n",addr);              fprintf(stderr, "segv_handler: 0x%08x not in any segment\n",addr);
772              interrupt_handle_now(sig,code,context);              interrupt_handle_now(signal,code,context);
773          }          }
774      }      }
775      /*      /*
776       * note that we check for a gc-trigger hit even if it's not a PROT error       * note that we check for a gc-trigger hit even if it's not a PROT error
777       */       */
778      else if(!maybe_gc(sig, code, context)){      else if(!maybe_gc(signal, code, context)){
779          static int nomap_count=0;          static int nomap_count=0;
780    
781          if(code==SEGV_NOMAP){          if(CODE(code)==OS_MAPERR){
782              if(nomap_count==0){              if(nomap_count==0){
783                  fprintf(stderr,                  fprintf(stderr,
784                          "segv_handler: No mapping fault: 0x%08x\n",addr);                          "segv_handler: No mapping fault: 0x%08x\n",addr);
# Line 741  caddr_t addr; Line 793  caddr_t addr;
793                          "segv_handler: Recursive no mapping fault (stack overflow?)\n");                          "segv_handler: Recursive no mapping fault (stack overflow?)\n");
794                  exit(-1);                  exit(-1);
795              }              }
796          }else if(SEGV_CODE(code)==SEGV_OBJERR){          } else if(OS_HASERRNO(code)) {
797              extern int errno;              errno=OS_ERRNO(code);
             errno=SEGV_ERRNO(code);  
798              perror("segv_handler: Object error");              perror("segv_handler: Object error");
799          }          }
800    
801          interrupt_handle_now(sig,code,context);          interrupt_handle_now(signal,code,context);
802    
803          if(code==SEGV_NOMAP)          if(CODE(code)==OS_MAPERR)
804              nomap_count--;              nomap_count--;
805      }      }
806  }  }
# Line 758  void os_install_interrupt_handlers() Line 809  void os_install_interrupt_handlers()
809  {  {
810      interrupt_install_low_level_handler(SIGSEGV,segv_handler);      interrupt_install_low_level_handler(SIGSEGV,segv_handler);
811  }  }
812    
813    
814    #ifdef SOLARIS
815    
816    
817    /* function defintions for register lvalues */
818    
819    int * solaris_register_address(struct ucontext *context, int reg)
820    {
821        if (reg == 0) {
822            static int zero;
823    
824            zero = 0;
825    
826            return &zero;
827        } else if (reg < 16) {
828            return &context->uc_mcontext.gregs[reg+3];
829        } else if (reg < 32) {
830            int *sp = (int*) context->uc_mcontext.gregs[REG_SP];
831            return &sp[reg-16];
832        } else
833            return 0;
834    }
835    /* function defintions for backward compatibilty and static linking */
836    
837    #if 0
838    void *  dlopen(const char * file, int flag) { return 0; }
839    void *  dlsym(void *obj, const char *sym) { return 0; }
840    int     dlclose(void *obj) { return 0; }
841    char *  dlerror(void) { return "no dynamic linking"; }
842    #endif
843    
844    /* For now we put in some porting functions */
845    
846    int
847    getdtablesize(void)
848    {
849        return sysconf(_SC_OPEN_MAX);
850    }
851    
852    char *
853    getwd(char *path)
854    {
855        return getcwd(path, MAXPATHLEN);
856    }
857    
858    int
859    getpagesize(void)
860    {
861        return sysconf(_SC_PAGESIZE);
862    }
863    
864    
865    #include <sys/procfs.h>
866    /* Old rusage definition */
867    struct  rusage {
868            struct timeval ru_utime;        /* user time used */
869            struct timeval ru_stime;        /* system time used */
870            long    ru_maxrss;
871    #define ru_first        ru_ixrss
872            long    ru_ixrss;               /* XXX: 0 */
873            long    ru_idrss;               /* XXX: sum of rm_asrss */
874            long    ru_isrss;               /* XXX: 0 */
875            long    ru_minflt;              /* any page faults not requiring I/O */
876            long    ru_majflt;              /* any page faults requiring I/O */
877            long    ru_nswap;               /* swaps */
878            long    ru_inblock;             /* block input operations */
879            long    ru_oublock;             /* block output operations */
880            long    ru_msgsnd;              /* messages sent */
881            long    ru_msgrcv;              /* messages received */
882            long    ru_nsignals;            /* signals received */
883            long    ru_nvcsw;               /* voluntary context switches */
884            long    ru_nivcsw;              /* involuntary " */
885    #define ru_last         ru_nivcsw
886    };
887    
888    
889    int
890    getrusage(int who, struct rusage *rp)
891    {
892        memset(rp, 0, sizeof(struct rusage));
893        return 0;
894    }
895    
896    int
897    setreuid()
898    {
899        fprintf(stderr,"setreuid unimplemented\n");
900        errno = ENOSYS;
901        return -1;
902    }
903    
904    int
905    setregid()
906    {
907        fprintf(stderr,"setregid unimplemented\n");
908        errno = ENOSYS;
909        return -1;
910    }
911    
912    int
913    gethostid()
914    {
915        fprintf(stderr,"gethostid unimplemented\n");
916        errno = ENOSYS;
917        return -1;
918    }
919    
920    int
921    killpg(int pgrp, int sig)
922    {
923        if (pgrp < 0) {
924            errno = ESRCH;
925            return -1;
926        }
927        return kill(-pgrp, sig);
928    }
929    
930    int
931    sigblock(int mask)
932    {
933        sigset_t old, new;
934    
935        sigemptyset(&new);
936        new.__sigbits[0] = mask;
937    
938        sigprocmask(SIG_BLOCK, &new, &old);
939    
940        return old.__sigbits[0];
941    }
942    
943    int
944    wait3(int *status, int options, struct rusage *rp)
945    {
946        if (rp)
947            memset(rp, 0, sizeof(struct rusage));
948        return waitpid(-1, status, options);
949    }
950    
951    int
952    sigsetmask(int mask)
953    {
954        sigset_t old, new;
955    
956        sigemptyset(&new);
957        new.__sigbits[0] = mask;
958    
959        sigprocmask(SIG_SETMASK, &new, &old);
960    
961        return old.__sigbits[0];
962    
963    }
964    #endif /* SOLARIS */

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.3

  ViewVC Help
Powered by ViewVC 1.1.5