core.h

Go to the documentation of this file.

/*
** core.h for lseos in lseos-core/kernel
** 
** Copyright (c)2004 IONIS group, Vianney Rancurel - Paris
** Login   <vianney@epita.fr>
** 
** Started on  Fri Jan 23 15:55:08 2004 Vianney Rancurel
 ** Last update Fri Feb 18 18:06:19 2005 Olivier Dembour
*/
#ifndef __LSEOS_CORE_H__
#define __LSEOS_CORE_H__        1
#include <libc.h>
#include <conven/queue.h>
#include <conven/bpt.h>
#ifdef __USE_OLD_AREA_API__
# define __AREA_OLD_CODE__
#endif
#include <area.h>

struct          s_idt 
{
  paddr_t       pa;                     
  vaddr_t       va;                     
  int           limit;                  
};

struct          s_core_info
{
  struct s_idt  idt[MAX_CPUS];          
  vaddr_t       vgdt;                   
  paddr_t       pgdt;                   
  int32_t       gdt_limit;              
};

#define CR3_SELF        ((u_int)-1)     
#define CR3_SYSTEM      ((u_int)-2)     
struct          s_runqop
{
  int           op;                     
#define RUNQOP_RUN              1       
#define RUNQOP_ASRELE           2       
#define RUNQOP_TCBRELE          3       
  union
  {
    struct
    {
      pid_t     pid;                    
      u_int     sel;                    
    } run;

    struct
    {
      pid_t     pid;                    
    } tcbrele;

    struct
    {
      asid_t    asid;                   
    } asrele;

  } u;
};

#define ASID_MINE -1LL 
#define PRSV_ANY                ((paddr_t)-1)   
#define VRSV_ANY                ((paddr_t)-1)   
#define VRSV_ANYNOTFIRSTMEG     ((paddr_t)-2)   
//#define VRSV_ANYNOTNULL               ((paddr_t)-3)   
#define MODE_UNDEF              0       
#define VMODE_RSV               4       
#define VMODE_VMAP              5       
#define KMODE_RSV               8       
#define PMODE_RSV               16      
#define PMODE_SHARED_RW         17      
#define PMODE_SHARED_RO         18      
#define VMODEOPT_PERSISTENT_MAP (1u<<0) 
#define PMODEOPT_AGGREGATE      (1u<<0) 
#define PMODEOPT_PERSISTENT     (1u<<1) 
#define PMODEOPT_SYSTEM         (1u<<2) 
#define PMODEOPT_USER_READ      (1u<<3) 
#define PMODEOPT_USER_WRITE     (1u<<4) 
#define PMODEOPT_GROUP_READ     (1u<<5) 
#define PMODEOPT_GROUP_WRITE    (1u<<6) 
#define PMODEOPT_OTHER_READ     (1u<<7) 
#define PMODEOPT_OTHER_WRITE    (1u<<8) 
#define PMODEOPT_ALL_READ \
(PMODEOPT_USER_READ|PMODEOPT_GROUP_READ|PMODEOPT_OTHER_READ)
#define PMODEOPT_ALL_WRITE \
(PMODEOPT_USER_WRITE|PMODEOPT_GROUP_WRITE|PMODEOPT_OTHER_WRITE)

#define KTYPE_UNDEF             0       
#define KTYPE_REC               1       
#define KTYPE_ASPACE            2       
#define KTYPE_TCB               3       
#define KTYPE_MEM               4       
enum
  {
    SHARED_RW,                          
    SHARED_RO,                          
  };

#define VUNMAP_NOALLOC  (1<<0u)         
#define PRELE_DONTCLEAN         (1<<0u) 
#define PRELE_NOALLOC           (1<<1u) 
#define PRELE_NOASIDCHECK       (1<<2u) 
#define PRELE_FORCE             (1<<3u) 
#define PRELE_AGGREGATE         (1<<4u) 
#define KRELE_NOALLOC           (1<<0u) 
#define KRELE_NOASIDCHECK       (1<<1u) 
#define VRELE_NOALLOC           (1<<0u) 
#define ASREG_BPT               (1<<0u) 
struct          s_memdef
{
  asid_t        asid;                   
  u_int32_t     addr;                   
  u_int32_t     nb_pgs;                 
#define SPACE_SELF      ((asid_t)-1)    
#define SPACE_KERN      ((asid_t)-2)    
#define SPACE_PHYS      ((asid_t)-3)    
#define SPACE_SYS0      ((asid_t)-4)    
#define SPACE_SYS1      ((asid_t)-5)    
  u_int32_t     space;                  
  u_int32_t     mode;                   
  u_int32_t     modeopts;               
  u_int32_t     uid;                    
  u_int32_t     gid;                    
  u_int32_t     refcnt;                 
};
#define MEMDEF_RM_ONLY          (1u<<0) 
#define MEMDEF_VIRT_ONLY        (1u<<1) 
/* aspace flags */
#define ASF_RUNQ        (1<<0u)         
#define ASF_PROTECTED (1<<1u)           
#define AS_EXPORT \
  asid_t                        asid;   \
  pid_t                         pid;    \
  uid_t                         uid;    \
  u_int32_t                     flags;  \
  u_int32_t                     exec_pc;\
  u_int32_t                     exec_sp;\
  u_int32_t                     exec_fp;\
  int                           refcnt; 
struct                          s_as_export
{
  AS_EXPORT;
};

typedef struct s_as_export t_as;

#ifdef __KERNEL__
RUNQ_HEAD(s_as_runq, s_as_full);
LIST_HEAD(s_as_list, s_as_full);

struct                          s_as_full
{
  AS_EXPORT;

#define AS_MAGIC 0xcafebabe               
  u_int32_t                     magic;

  LIST_ENTRY(s_as_full)         list_ht;
  RUNQ_ENTRY(s_as_full)         runq;   
  kaddr_t                       ka;     \
  paddr_t                       pa;     \
  paddr_t                       pgdir;  \
  
  t_area_set                    area_set;
};
#endif

#define ASOP_ATTACH             0       
#define ASOP_DETACH             1       
#define ASOP_NDATTACH           2       
struct rlimit 
{
  rlim_t  rlim_cur;                     
  rlim_t  rlim_max;                     
};

#define RLIMIT_CPU      0               
#define RLIMIT_FSIZE    1               
#define RLIMIT_DATA     2               
#define RLIMIT_STACK    3               
#define RLIMIT_CORE     4               
#define RLIMIT_RSS      5               
#define RLIMIT_MEMLOCK  6               
#define RLIMIT_NPROC    7               
#define RLIMIT_NOFILE   8               
#define RLIM_NLIMITS    9               
#define RLIM_INFINITY   (~((u_quad_t)1 << 63))  
#define RLIM_SAVED_MAX  RLIM_INFINITY   
#define RLIM_SAVED_CUR  RLIM_INFINITY   
#define F_OK            0               
#define X_OK            0x01            
#define W_OK            0x02            
#define R_OK            0x04            
#define SEEK_SET        0               
#define SEEK_CUR        1               
#define SEEK_END        2               
#define PT_TRACE_ME     0       
#define PT_READ_I       1       
#define PT_READ_D       2       
#define PT_WRITE_I      4       
#define PT_WRITE_D      5       
#define PT_CONTINUE     7       
#define PT_KILL         8       
#define PT_ATTACH       9       
#define PT_DETACH       10      
#define PT_IO           11      
/*
 * Argument structure for PT_IO.
 */
struct ptrace_io_desc 
{
  int     piod_op;      
  void    *piod_offs;   
  void    *piod_addr;   
  size_t  piod_len;     
};

struct                  s_iomap
{
#define IO_SETSIZE         65536
#define NBITS (sizeof (u_long) * NBBY)        /* bits per mask */
  u_long                masks[HOWMANY(IO_SETSIZE, NBITS)];
};

#define IO_CLR(n, p)    ((p)->masks[(n)/NBITS] &= ~(1 << ((n) % NBITS)))
#define IO_SET(n, p)    ((p)->masks[(n)/NBITS] |= (1 << ((n) % NBITS)))
#define IO_ISSET(n, p)  ((p)->masks[(n)/NBITS] & (1 << ((n) % NBITS)))

#define PRIORITY_DFLT   0

struct                  s_sigctx
{
  vaddr_t               eip;
  vaddr_t               esp;
  t_tss                 tss;            
  sigset_t              o_sigmask;      
  sigset_t              sigmask;        
  int                   restore;        
  int                   code;           
  u_int32_t             flags;          
#define SIGF_TRIGGERED  (1<<1u)         
#define SIGF_IGN        (1<<2u)         
#define SIGF_NODFL      (1<<3u)         
  u_int32_t             sa_flags;       
  vaddr_t               addr;           
};

struct                  s_usig
{
  int                   sig;            
  sigset_t              pausemask;      
  sigset_t              sigmask;        
  sigset_t              sigpending;     
  struct s_sigctx       sigctxs[SIGMAX];
#define SIGCTX(Usig, Sig) ((Usig)->sigctxs[(Sig)-1])
};

struct                  s_ucred
{
  uid_t                 uid;            
  gid_t                 gid;            
  uid_t                 ruid;           
  gid_t                 rgid;           
#define NGROUPS 16
  gid_t                 groups[NGROUPS];
};

struct                  s_ustat
{
  u_int64_t             elect;          
};

#define MAXTCBNAME      15

/* cpu values */
#define OFF_CPU         -1              
#define UNDEF_CPU       -2              
/* cpu_spec specificators */
#define CPU_ANY -1                      
/* tcb statuses */
#define TCBS_IDLE       0               
#define TCBS_RUN        1               
#define TCBS_SLEEP      2               
#define TCBS_STOP       3               
#define TCBS_ZOMBIE     4               
#define TCBS_DEAD       5               
/* tcb classes */
#define TCBC_UNDEF      0
#define TCBC_SCHED      1
#define TCBC_SERVICE    2
#define TCBC_REALTIME   3
#define TCBC_KERNEL     4

/* tcb flags */
#define TCBF_ONPROC     (1<<0u)         
#define TCBF_TRACED     (1<<1u)         
#define TCBF_SIGNALABLE (1<<2u)         
#define TCBF_RUNQ       (1<<3u)         
#define TCBF_IOMAP      (1<<4u)         
#define TCBF_PAUSEMASK  (1<<5u)         
#define TCBF_WAITINFO   (1<<6u)         
#define TCBF_PTRACED    (1<<7u)         
#define TCBF_WAITDONE   (1<<8u) 
#define TCBF_COLLECTDONE (1<<9u)        
#define TCB_EXPORT \
  t_tss                 tss;            \
  u_int                 sel;            \
  pid_t                 pid;            \
  pid_t                 ppid;           \
  pid_t                 pgid;           \
  asid_t                asid;           \
  char                  name[MAXTCBNAME + 1];\
  int                   priority;       \
  int                   cpu;            \
  int                   cpu_spec;       \
  u_int32_t             status;         \
  u_int32_t             class;          \
  u_int32_t             flags;          \
  u_int32_t             wstatus;        \
  u_int                 sq_gate;        \
  struct s_ucred        ucred;          \
  struct s_ustat        ustat;          
struct                  s_tcb_export    
{
  TCB_EXPORT;
};

typedef struct s_tcb_export t_tcb;

#ifdef __KERNEL__
RUNQ_HEAD(s_tcb_runq, s_tcb_full);
LIST_HEAD(s_tcb_list, s_tcb_full);

struct                  s_tcb_full      
{
  TCB_EXPORT;

#define TCB_MAGIC       0x42434445
  int                   magic;          \

  LIST_ENTRY(s_tcb_full) list;          
  LIST_ENTRY(s_tcb_full) list_ht;       
  RUNQ_ENTRY(s_tcb_full) runq;          
  int                   sizepg;         
#define TCBSIG_SIZEPG(IomapPresent) \
(ROUNDUP(ROUNDUP(sizeof (struct s_tcb_full), 4) + \
 ((IomapPresent)? sizeof (struct s_iomap) : 0) +\
 sizeof (struct s_usig), PAGESIZE)/PAGESIZE)

#define TCBNOSIG_SIZEPG(IomapPresent) \
(ROUNDUP(ROUNDUP(sizeof (struct s_tcb_full), 4) + \
 ((IomapPresent)? sizeof (struct s_iomap) : 0), PAGESIZE)/PAGESIZE)

  paddr_t               pa;             
  kaddr_t               ka;             
  union savefpu         fpu;            
  struct s_usig         *usig;          
  /*
   * iomap immediately follows (if any)
   */
};

# define TCB_INIT(Tcb, Pid, Sel) \
        (Tcb)->tss.link = 0; \
        (Tcb)->tss.es = (Tcb)->tss.ss = \
        (Tcb)->tss.ds = (Tcb)->tss.fs = \
        (Tcb)->tss.gs = \
                GSEL((ISRING(Sel) == 0 ? GDATA_IDXSEL : GUDATA_IDXSEL), \
                (ISRING(Sel) == 0 ? RING0 : RING3)); \
        (Tcb)->tss.cs = \
                GSEL((ISRING(Sel) == 0 ? GCODE_IDXSEL : GUCODE_IDXSEL), \
                 (ISRING(Sel) == 0 ? RING0 : RING3)); \
        (Tcb)->tss.cr3 = 0; \
        (Tcb)->tss.eip = 0; \
        (Tcb)->tss.ebp = 0; \
        (Tcb)->tss.esp = 0; \
        (Tcb)->tss.eflags = 0; \
        (Tcb)->tss.ldts = 0; \
        (Tcb)->tss.debugtrap = 0; \
        (Tcb)->tss.iomapbase = ROUNDUP(sizeof (struct s_tcb_full), 4); \
        (Tcb)->tss.ss0 = 0; \
        (Tcb)->tss.esp0 = 0; \
        (Tcb)->tss.ss1 = 0; \
        (Tcb)->tss.esp1 = 0; \
        (Tcb)->tss.ss2 = 0; \
        (Tcb)->tss.esp2 = 0; \
        strncpy((Tcb)->name, "", MAXTCBNAME); \
        (Tcb)->magic = TCB_MAGIC; \
        (Tcb)->sizepg = 1; \
        (Tcb)->pa = (paddr_t)-1; \
        (Tcb)->sel = (Sel); \
        (Tcb)->pid = (Pid); \
        (Tcb)->ppid = 0LL; \
        (Tcb)->pgid = 1LL; /* could not be 0 */ \
        (Tcb)->asid = NO_ASID; \
        (Tcb)->cpu_spec = 0; \
        (Tcb)->cpu = UNDEF_CPU; \
        (Tcb)->ucred.uid = (Tcb)->ucred.gid = 0; \
        bzero(&(Tcb)->ustat, sizeof ((Tcb)->ustat)); \
        (Tcb)->status = TCBS_IDLE; \
        (Tcb)->class = TCBC_UNDEF; \
        (Tcb)->flags = 0u; \
        (Tcb)->wstatus = 0; \
        (Tcb)->usig = NULL;
#endif

/*
 * special ids
 */
#define BSTRAP_PID      ((pid_t)0LL)
#define KERNEL_PID      ((pid_t)1LL)
#define KERNEL_ASID     ((asid_t)0LL)
#define NO_ASID         ((asid_t)-1LL)

struct                  s_procdef
{
  u_int32_t             flags;          
#define PROCDEF_ONGDT (1<<0u)           
  struct s_tcb_export   tcb;            
  union descriptor      desc;           
};

/*
 * Macros to test the exit status returned by wait
 * and extract the relevant values.
 */
#define _W_INT(w)       (*(int *)(void *)&(w))  /* convert union wait to int */
#define WCOREFLAG       0200
#define _WSTATUS(x)     (_W_INT(x) & 0177)
#define _WSTOPPED       0177            /* _WSTATUS if process is stopped */
#define WIFSTOPPED(x)   (_WSTATUS(x) == _WSTOPPED)
#define WSTOPSIG(x)     ((int)(((unsigned int)_W_INT(x)) >> 8) & 0xff)
#define WIFSIGNALED(x)  (_WSTATUS(x) != _WSTOPPED && _WSTATUS(x) != 0)
#define WTERMSIG(x)     (_WSTATUS(x))
#define WIFEXITED(x)    (_WSTATUS(x) == 0)
#define WEXITSTATUS(x)  ((int)(((unsigned int)_W_INT(x)) >> 8) & 0xff)
#define WCOREDUMP(x)    (_W_INT(x) & WCOREFLAG)
#define W_EXITCODE(ret, sig)    ((ret) << 8 | (sig))
#define W_STOPCODE(sig)         ((sig) << 8 | _WSTOPPED)

/*
 * Option bits for the third argument of wait4.  WNOHANG causes the
 * wait to not hang if there are no stopped or terminated processes, rather
 * returning an error indication in this case (pid==0).  WUNTRACED
 * indicates that the caller should receive status about untraced children
 * which stop due to signals.  If children are stopped and a wait without
 * this option is done, it is as though they were still running... nothing
 * about them is returned.
 */
#define WNOHANG         0x00000001      /* don't hang in wait */
#define WUNTRACED       0x00000002      /* tell about stopped,
                                           untraced children */
#define WALTSIG         0x00000004      /* wait for processes that exit
                                           with an alternate signal (i.e.
                                           not SIGCHLD) */
#define WALLSIG         0x00000008      /* wait for processes that exit
                                           with any signal, i.e. SIGCHLD
                                           and alternates */

/*
 * Structure of the information in the status word returned by wait4.
 * If w_stopval==WSTOPPED, then the second structure describes
 * the information returned, else the first.
 */
union wait 
{
  int   w_status;               /* used in syscall */
  /*
   * Terminated process status.
   */
  struct
  {
#if BYTE_ORDER == LITTLE_ENDIAN
    unsigned int        w_Termsig:7,    /* termination signal */
                        w_Coredump:1,   /* core dump indicator */
                        w_Retcode:8,    /* exit code if w_termsig==0 */
                        w_Filler:16;    /* upper bits filler */
#endif
#if BYTE_ORDER == BIG_ENDIAN
    unsigned int        w_Filler:16,    /* upper bits filler */
                        w_Retcode:8,    /* exit code if w_termsig==0 */
                        w_Coredump:1,   /* core dump indicator */
                        w_Termsig:7;    /* termination signal */
#endif
  } w_T;
  /*
   * Stopped process status.  Returned
   * only for traced children unless requested
   * with the WUNTRACED option bit.
   */
  struct 
  {
#if BYTE_ORDER == LITTLE_ENDIAN
    unsigned int        w_Stopval:8,    /* == W_STOPPED if stopped */
                        w_Stopsig:8,    /* signal that stopped us */
                        w_Filler:16;    /* upper bits filler */
#endif
#if BYTE_ORDER == BIG_ENDIAN
    unsigned int        w_Filler:16,    /* upper bits filler */
                        w_Stopsig:8,    /* signal that stopped us */
                        w_Stopval:8;    /* == W_STOPPED if stopped */
#endif
  } w_S;
};
#define w_termsig       w_T.w_Termsig
#define w_coredump      w_T.w_Coredump
#define w_retcode       w_T.w_Retcode
#define w_stopval       w_S.w_Stopval
#define w_stopsig       w_S.w_Stopsig

#define WSTOPPED        _WSTOPPED

struct rusage 
{
  int           dummy;
};

#define SET_SYS_RETURN(Tcb, Val, Errno, Suberrno) \
do {\
 (Tcb)->tss.eax = (Val);\
 (Tcb)->tss.ebx = (Errno);\
 (Tcb)->tss.ecx = (Suberrno);\
} while (/*CONSTCOND*/0) 

#define SYS_RETURN(Tcb, Val, Errno, Suberrno) \
do {\
  SET_SYS_RETURN((Tcb), (Val), (Errno), (Suberrno));\
  return ;\
} while (/*CONSTCOND*/0)

#define SYS_ARG1(Tcb)   ((Tcb)->tss.ebx)
#define SYS_ARG2(Tcb)   ((Tcb)->tss.ecx)
#define SYS_ARG3(Tcb)   ((Tcb)->tss.edx)
#define SYS_ARG4(Tcb)   ((Tcb)->tss.esi)
#define SYS_ARG5(Tcb)   ((Tcb)->tss.edi)

#include <core/main.h>
#include <core/suberrno.h>
#include <core/coresrv.h>
#include <core/core_tcb.h>
#include <core/core_mem.h>
#include <core/core_sig.h>
#include <core/core_cred.h>
#include <core/trap.h>
#include <core/pgflt.h>
#include <core/dblflt.h>
#include <core/stray.h>
#include <core/breakpoint.h>
#include <core/npx.h>
#include <core/syscall.h>
#include <core/syscallargs.h>
#include <core/vm86.h>

#ifdef __LSEOS_RELEASE_SPECIFIC__
static __inline
int     __sfulltcb2(pid_t pid, struct s_tcb_full *tcb_returned)
{
  int   retval;

  CORE_SYSCALL5(retval, SYSCORE___SFULLTCB2,
                QUAD_HIGH(pid), QUAD_LOW(pid),
                (int)tcb_returned, 
                0, 0);

  return (retval);
}

static __inline
int     __sfulllink(struct s_tcb_full *tcb_returned)
{
  int   retval;

  CORE_SYSCALL5(retval, SYSCORE___SFULLLINK,
                (int)tcb_returned, 
                0, 0, 0, 0);

  return (retval);
}

static __inline
int     __sfullas(asid_t asid, struct s_as_full *aspace_returned)
{
  int   retval;

  CORE_SYSCALL5(retval, SYSCORE___SFULLAS,
                QUAD_HIGH(asid), QUAD_LOW(asid),
                (int)aspace_returned, 
                0, 0);

  return (retval);
}
#endif

#endif

---