compiler/clib/arosc_init.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <exec/types.h>
   7 #include <exec/resident.h>
   8 #include <exec/memory.h>
   9 #include <proto/exec.h>
  10 #include <proto/dos.h>
  11 #include <aros/libcall.h>
  12 #include <aros/asmcall.h>
  13 #include <aros/symbolsets.h>
  14 #if defined(__GNUC__) || defined(__INTEL_COMPILER)
  15 #   include "arosc_gcc.h"
  16 #endif
  17
  18 #include <stddef.h>
  19 #include <ctype.h>
  20 #include <sys/stat.h>
  21 #include <setjmp.h>
  22
  23 #define DEBUG 0
  24 #include <aros/debug.h>
  25
  26 #include "etask.h"
  27 #include "__arosc_privdata.h"
  28 #include "arosc_init.h"
  29
  30 THIS_PROGRAM_HANDLES_SYMBOLSETS
  31
  32 extern const char name[];
  33 extern const char version[];
  34 extern const APTR inittabl[4];
  35 extern void *const arosc_functable[];
  36 extern const struct inittable datatable;
  37 extern struct aroscbase *AROS_SLIB_ENTRY(init,arosc)();
  38 AROS_LD1(struct aroscbase *, open, AROS_LDA(ULONG, version, D0), struct aroscbase *, aroscbase, 1, arosc);
  39 AROS_LD0(BPTR, close, struct aroscbase *, aroscbase, 2, arosc);
  40 AROS_LD0(BPTR, expunge, struct aroscbase *, aroscbase, 3, arosc);
  41 AROS_LD0I(int, null, struct aroscbase *, aroscbase, 4, arosc);
  42 extern const char arosc_end;
  43
  44 struct ExecBase  *SysBase;
  45 struct aroscbase *aroscbase;
  46
  47 extern struct DosLibrary *DOSBase;
  48
  49
  50 int entry(void)
  51 {
  52     /* If the library was executed by accident return error code. */
  53     return -1;
  54 }
  55
  56 const struct Resident resident=
  57 {
  58     RTC_MATCHWORD,
  59     (struct Resident *)&resident,
  60     (APTR)&arosc_end,
  61     RTF_AUTOINIT,
  62     41,
  63     NT_LIBRARY,
  64     0,
  65     (char *)name,
  66     (char *)&version[6],
  67     (ULONG *)inittabl
  68 };
  69
  70 const char name[]="arosc.library";
  71
  72 const char version[]="$VER: arosc.library 41.1 (" __DATE__ ")\n\015";
  73
  74 const APTR inittabl[4]=
  75 {
  76     (APTR)sizeof(struct aroscbase),
  77     (APTR)arosc_functable,
  78     NULL,
  79     &AROS_SLIB_ENTRY(init,arosc)
  80 };
  81
  82 DECLARESET(INIT);
  83 DECLARESET(EXIT);
  84
  85 AROS_UFH3(struct aroscbase *, AROS_SLIB_ENTRY(init,arosc),
  86  AROS_UFHA(struct aroscbase *, __aroscbase, D0),
  87  AROS_UFHA(BPTR,               segList,   A0),
  88  AROS_UFHA(struct ExecBase *,  __SysBase,   A6)
  89 )
  90 {
  91     AROS_USERFUNC_INIT
  92
  93     /* This function is single-threaded by exec by calling Forbid. */
  94
  95     /* Store arguments */
  96     aroscbase = __aroscbase;
  97     SysBase   = __SysBase;
  98
  99     aroscbase->seglist=segList;
 100
 101     if (!set_open_libraries())
 102     {
 103         set_close_libraries();
 104
 105         return NULL;
 106     }
 107
 108     /* You would return NULL here if the init failed. */
 109     return aroscbase;
 110     AROS_USERFUNC_EXIT
 111 }
 112
 113
 114 AROS_LH1(struct aroscbase *, open,
 115  AROS_LHA(ULONG, version, D0),
 116            struct aroscbase *, aroscbase, 1, arosc)
 117 {
 118     AROS_LIBFUNC_INIT
 119     /*
 120         This function is single-threaded by exec by calling Forbid.
 121         If you break the Forbid() another task may enter this function
 122         at the same time. Take care.
 123     */
 124
 125     /* Keep compiler happy */
 126     version=0;
 127
 128     if (!arosc_internalinit())
 129     {
 130         arosc_internalexit();
 131         return NULL;
 132     }
 133
 134     /* I have one more opener. */
 135     aroscbase->library.lib_OpenCnt++;
 136     aroscbase->library.lib_Flags &= ~LIBF_DELEXP;
 137
 138     /* You would return NULL if the open failed. */
 139     return aroscbase;
 140
 141     AROS_LIBFUNC_EXIT
 142 }
 143
 144 AROS_LH0(BPTR, close, struct aroscbase *, aroscbase, 2, arosc)
 145 {
 146     AROS_LIBFUNC_INIT
 147     /*
 148         This function is single-threaded by exec by calling Forbid.
 149         If you break the Forbid() another task may enter this function
 150         at the same time. Take care.
 151     */
 152
 153     /* I have one fewer opener. */
 154     if(!--aroscbase->library.lib_OpenCnt)
 155     {
 156         /* Delayed expunge pending? */
 157         if(aroscbase->library.lib_Flags&LIBF_DELEXP)
 158             /* Then expunge the library */
 159             return expunge();
 160     }
 161
 162     arosc_internalexit();
 163
 164     return 0;
 165     AROS_LIBFUNC_EXIT
 166 }
 167
 168 AROS_LH0(BPTR, expunge, struct aroscbase *, aroscbase, 3, arosc)
 169 {
 170     AROS_LIBFUNC_INIT
 171
 172     BPTR ret;
 173     /*
 174         This function is single-threaded by exec by calling Forbid.
 175         Never break the Forbid() or strange things might happen.
 176     */
 177
 178     /* Test for openers. */
 179     if(aroscbase->library.lib_OpenCnt)
 180     {
 181         /* Set the delayed expunge flag and return. */
 182         aroscbase->library.lib_Flags|=LIBF_DELEXP;
 183         return 0;
 184     }
 185
 186     /* Get rid of the library. Remove it from the list. */
 187     Remove(&aroscbase->library.lib_Node);
 188
 189     /* Get returncode here - FreeMem() will destroy the field. */
 190     ret=aroscbase->seglist;
 191
 192     set_close_libraries();
 193
 194     /* Free the memory. */
 195     FreeMem((char *)aroscbase-aroscbase->library.lib_NegSize,
 196             aroscbase->library.lib_NegSize+aroscbase->library.lib_PosSize);
 197
 198     return ret;
 199     AROS_LIBFUNC_EXIT
 200 }
 201 AROS_LH0I(int, null, struct aroscbase *, aroscbase, 4, arosc)
 202 {
 203     AROS_LIBFUNC_INIT
 204     return 0;
 205     AROS_LIBFUNC_EXIT
 206 }
 207
 208 int arosc_internalinit(void)
 209 {
 210     struct arosc_privdata *oldprivdata, *privdata;
 211     struct Process *me = (struct Process *)FindTask(NULL);
 212     int res = TRUE;
 213
 214     privdata = oldprivdata = GetIntETask(me)->iet_acpd;
 215
 216     D(bug("\nEntering arosc_internalinit(): me->name = %s\n", me->pr_Task.tc_Node.ln_Name));
 217     D(bug("arosc_internalinit(): oldprivdata = %p\n", oldprivdata));
 218     if
 219     (
 220         !oldprivdata ||
 221         (!oldprivdata->acpd_spawned && oldprivdata->acpd_process_returnaddr != me->pr_ReturnAddr)
 222     )
 223     {
 224         D(bug("arosc_internalinit(): AllocMem()\n"));
 225         privdata = AllocMem(sizeof *privdata, MEMF_CLEAR|MEMF_ANY);
 226
 227         if (!privdata)
 228         {
 229             SetIoErr(ERROR_NO_FREE_STORE);
 230             return FALSE;
 231         }
 232
 233         D(bug("arosc_internalinit(): newprivdata = %p\n", privdata));
 234         privdata->acpd_oldprivdata = oldprivdata;
 235         privdata->acpd_process_returnaddr = me->pr_ReturnAddr;
 236
 237         GetIntETask(me)->iet_acpd = privdata;
 238
 239         res = set_call_funcs(SETNAME(INIT), 1, 1);
 240     }
 241
 242     D(bug("arosc_internalinit(): acpd_usercount++\n"));
 243     privdata->acpd_usercount++;
 244
 245     return res;
 246 }
 247
 248 int arosc_internalexit(void)
 249 {
 250     struct arosc_privdata *privdata = GetIntETask(FindTask(NULL))->iet_acpd;
 251
 252     D(bug("arosc_internalexit(): --acpd_usercount\n"));
 253
 254     #warning FIXME: privdata should NEVER be NULL here
 255     ASSERT_VALID_PTR(privdata);
 256     if (privdata && --privdata->acpd_usercount == 0)
 257     {
 258         set_call_funcs(SETNAME(EXIT), -1, 0);
 259
 260         /*restore the old value */
 261         GetIntETask(FindTask(NULL))->iet_acpd = privdata->acpd_oldprivdata;
 262
 263         D(bug("arosc_internalexit(): FreeMem()\n"));
 264         FreeMem(privdata, sizeof(*privdata));
 265     }
 266
 267     D(bug("Exiting arosc_internalexit(): me->name = %s\n\n", FindTask(NULL)->tc_Node.ln_Name));
 268     return 0;
 269 }
 270
 271 DEFINESET(INIT);
 272 DEFINESET(EXIT);