arch/m68k-all/dos/bcpl_support.c

   1 /*
   2     Copyright © 2010, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: BCPL support
   6     Lang: english
   7 */
   8 #define DEBUG 0
   9 #include <aros/debug.h>
  10 #include <aros/asmcall.h>
  11
  12 #include <dos/dosextens.h>
  13 #include <dos/filehandler.h>
  14 #include <dos/dostags.h>
  15
  16 #include <proto/dos.h>
  17 #include <proto/exec.h>
  18
  19 #include "dos_intern.h"
  20 #include "bcpl.h"
  21
  22 /* Externs */
  23 extern void BCPL_dummy(void);
  24 #define BCPL(id, name)  extern void BCPL_##name(void);
  25 #include "bcpl.inc"
  26 #undef BCPL
  27
  28 #define BCPL_SlotCount  (BCPL_GlobVec_PosSize>>2)
  29
  30 /* Default Global Vector */
  31 #define BCPL(id, name) \
  32         [(BCPL_GlobVec_NegSize + id)>>2] = (ULONG)BCPL_##name,
  33
  34 const ULONG BCPL_GlobVec[(BCPL_GlobVec_NegSize + BCPL_GlobVec_PosSize) >> 2] = {
  35 #include "bcpl.inc"
  36 };
  37 #undef BCPL
  38
  39 #define BCPL_ENTRY(proc)        (((APTR *)(proc)->pr_GlobVec)[1])
  40 /*
  41  * Set up the process's initial global vector
  42  */
  43 ULONG BCPL_InstallSeg(BPTR seg, ULONG *globvec)
  44 {
  45     ULONG *segment;
  46     ULONG *table;
  47
  48     if (seg == BNULL) {
  49         D(bug("BCPL_InstallSeg: Empty segment\n"));
  50         return DOSTRUE;
  51     }
  52
  53     if (seg == (ULONG)-1) {
  54         ULONG slots = globvec[0];
  55         int i;
  56         if (slots > (BCPL_GlobVec_PosSize>>2))
  57             slots = (BCPL_GlobVec_PosSize>>2);
  58         D(bug("BCPL_InstallSeg: Inserting %d Faux system entries.\n", slots));
  59
  60         /* Copy over the negative entries from the default global vector */
  61         CopyMem(&BCPL_GlobVec[0], &globvec[-(BCPL_GlobVec_NegSize>>2)], BCPL_GlobVec_NegSize);
  62
  63         for (i = 2; i < slots; i++) {
  64             ULONG gv = BCPL_GlobVec[(BCPL_GlobVec_NegSize>>2) + i];
  65             if (gv == 0)
  66                 continue;
  67
  68             globvec[i] = gv;
  69         }
  70
  71         D(bug("BCPL_InstallSeg: Inserting DOSBase global\n"));
  72         globvec[GV_DOSBase >> 2] = (IPTR)OpenLibrary("dos.library",0);
  73
  74         return DOSTRUE;
  75     }
  76
  77     if (seg == (ULONG)-2) {
  78         return DOSTRUE;
  79     }
  80
  81     while (seg) {
  82         segment = BADDR(seg);
  83         seg = (BPTR)segment[0]; /* next segment */
  84
  85         if ((segment[-1] < segment[1])) {
  86             D(bug("BCPL_InstallSeg: segList @%p does not look like BCPL.\n", segment));
  87             continue;
  88         }
  89
  90         D(bug("BCPL_InstallSeg: SegList @%p\n", segment));
  91         table = &segment[segment[1]];
  92
  93         D(bug("\tFill in for %p:\n", segment));
  94
  95         for (; table[-1] != 0; table = &table[-2]) {
  96             D(bug("\t globvec[%d] = %p\n", table[-2], (APTR)&segment[1] + table[-1]));
  97             globvec[table[-2]] = (ULONG)((APTR)&segment[1] + table[-1]);
  98         }
  99     }
 100
 101     return DOSTRUE;
 102
 103 }
 104
 105 /* Create the global vector for a process
 106  */
 107 BOOL BCPL_AllocGlobVec(struct Process *me)
 108 {
 109     APTR globvec;
 110     int i;
 111     ULONG *seglist = BADDR(me->pr_SegList);
 112
 113     globvec = AllocMem(sizeof(BCPL_GlobVec), MEMF_ANY | MEMF_CLEAR);
 114     if (globvec == NULL)
 115         return FALSE;
 116
 117     globvec += BCPL_GlobVec_NegSize;
 118     ((ULONG *)globvec)[0] = BCPL_GlobVec_PosSize >> 2;
 119
 120     /* Install the segments into the Global Vector */
 121     for (i = 0; i < seglist[0]; i++) {
 122         BCPL_InstallSeg(seglist[i+1], globvec);
 123     }
 124
 125     me->pr_GlobVec = globvec;
 126
 127     return TRUE;
 128 }
 129
 130 void BCPL_FreeGlobVec(struct Process *me)
 131 {
 132     APTR globvec = me->pr_GlobVec;
 133     struct DosLibrary *DOSBase;
 134
 135     DOSBase = *(APTR *)(globvec + GV_DOSBase);
 136     D(bug("[BCPL_FreeGlobVec] Freed globvec %p\n", globvec));
 137
 138     globvec -= BCPL_GlobVec_NegSize;
 139     FreeMem(globvec, sizeof(BCPL_GlobVec));
 140
 141     me->pr_GlobVec = DOSBase->dl_GV;
 142 }
 143
 144 void BCPL_Fixup(struct Process *me)
 145 {
 146     BPTR *segment = BADDR(me->pr_SegList);
 147
 148     if (segment[2] == (BPTR)0x0000abcd) {
 149         D(bug("[BCPL_Fixup] Fixing up overlay\n"));
 150
 151         /* overlayed executable, fun..
 152          * 2 = id
 153          * 3 = filehandle (BPTR)
 154          * 4 = overlay table (APTR)
 155          * 5 = hunk table (BPTR)
 156          * 6 = global vector (APTR)
 157          */
 158         segment[6] = (ULONG)me->pr_GlobVec;
 159     }
 160 }
 161
 162 extern void BCPL_thunk(void);
 163
 164 /* Under AOS, BCPL handlers expect the OS to build
 165  * their GlobalVector, and to receive a pointer to their
 166  * startup packet in D1.
 167  *
 168  * Both filesystem handlers and CLI shells use this routine.
 169  *
 170  * The 'Shell' shell is C based, and does not go here.
 171  *
 172  * This wrapper is here to support that.
 173  */
 174 ULONG BCPL_RunHandler(void)
 175 {
 176     struct DosPacket *dp;
 177     struct Process *me = (struct Process *)FindTask(NULL);
 178     APTR oldReturnAddr;
 179     ULONG ret;
 180
 181     WaitPort(&me->pr_MsgPort);
 182     dp = (struct DosPacket *)(GetMsg(&me->pr_MsgPort)->mn_Node.ln_Name);
 183     D(bug("[RunHandlerBCPL] Startup packet = %p\n", dp));
 184
 185     if (!BCPL_AllocGlobVec(me)) {
 186         if (dp != NULL)
 187                 internal_ReplyPkt(dp, &me->pr_MsgPort, DOSFALSE, ERROR_NO_FREE_STORE);
 188         return ERROR_NO_FREE_STORE;
 189     }
 190
 191     D(bug("[RunHandlerBCPL] BCPL_ENTRY = %p\n", BCPL_ENTRY(me)));
 192
 193     oldReturnAddr = me->pr_ReturnAddr;
 194     ret = AROS_UFC8(ULONG, BCPL_thunk,
 195             AROS_UFCA(ULONG,  MKBADDR(dp), D1),
 196             AROS_UFCA(ULONG,  0, D2),
 197             AROS_UFCA(ULONG,  0, D3),
 198             AROS_UFCA(ULONG,  0, D4),
 199             AROS_UFCA(APTR, me->pr_Task.tc_SPLower, A1),
 200             AROS_UFCA(APTR, me->pr_GlobVec, A2),
 201             AROS_UFCA(APTR, &me->pr_ReturnAddr, A3),
 202             AROS_UFCA(LONG_FUNC, BCPL_ENTRY(me), A4));
 203     me->pr_ReturnAddr = oldReturnAddr;
 204
 205     BCPL_FreeGlobVec(me);
 206
 207     return ret;
 208 }
 209
 210 /* Create the necessary process wrappings for a BCPL
 211  * segment. Only needed by Workbench's C:Run, C:NewCLI,
 212  * C:NewShell, and a few other applications.
 213  */
 214 struct MsgPort *BCPL_CreateProcBCPL(struct DosLibrary *DOSBase, CONST_STRPTR name, BPTR *segarray, ULONG stacksize, LONG pri)
 215 {
 216     struct Process *proc, *me = (struct Process *)FindTask(NULL);
 217
 218     D(bug("[BCPL_CreateProcBCPL] Window=%p name=\"%s\", segArray=%p, stacksize=%u, pri=%d\n", me->pr_WindowPtr, name, segarray, stacksize, pri));
 219
 220     proc = CreateNewProcTags(
 221             NP_Name, name,
 222             NP_Entry, BCPL_RunHandler,
 223             NP_Input, BNULL,
 224             NP_Output, BNULL,
 225             NP_Error, BNULL,
 226             NP_CloseInput, FALSE,
 227             NP_CloseOutput, FALSE,
 228             NP_CloseError, FALSE,
 229             NP_StackSize, stacksize,
 230             NP_WindowPtr, me->pr_WindowPtr,
 231             NP_CurrentDir, 0,
 232             NP_Cli, TRUE,
 233             NP_HomeDir, 0,
 234             TAG_END);
 235
 236     /* Fix up the segarray before the first packet gets
 237      * to it.
 238      */
 239     if (proc) {
 240         BPTR *oldsegarray;
 241
 242         oldsegarray = BADDR(proc->pr_SegList);
 243         if (oldsegarray[0] < segarray[0]) {
 244             FreeVec(oldsegarray);
 245             oldsegarray = AllocVec(sizeof(BPTR)*(segarray[0]+1), MEMF_PUBLIC | MEMF_CLEAR);
 246             oldsegarray[0] = segarray[0];
 247             oldsegarray[1] = (BPTR)-1;
 248             oldsegarray[2] = (BPTR)-2;
 249         }
 250         CopyMem(&segarray[3], &oldsegarray[3], (oldsegarray[0]-2)*sizeof(BPTR));
 251
 252     }
 253
 254     return proc ? &proc->pr_MsgPort : NULL;
 255 }
 256
 257 void bcpl_command_name(void)
 258 {
 259     struct Process *me = (struct Process *)FindTask(NULL);
 260     struct CommandLineInterface *cli = BADDR(me->pr_CLI);
 261
 262     if (cli == NULL || cli->cli_Module == BNULL)
 263         bug("%s: ", me->pr_Task.tc_Node.ln_Name);
 264     else
 265         bug("%b: ", cli->cli_CommandName);
 266 }
 267