rom/dos/internalloadseg_aos.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: english
   7 */
   8
   9 #include <exec/execbase.h>
  10 #include <exec/memory.h>
  11 #include <dos/dosasl.h>
  12 #include <dos/doshunks.h>
  13 #include <dos/dosextens.h>
  14 #include <proto/exec.h>
  15 #include <proto/dos.h>
  16 #include <proto/arossupport.h>
  17 #include <aros/asmcall.h>
  18 #include <aros/debug.h>
  19 #include <aros/macros.h>
  20
  21 #include "dos_intern.h"
  22 #include "internalloadseg.h"
  23 #include "include/loadseg.h"
  24
  25 #include <proto/dos.h>
  26
  27 #define GETHUNKPTR(x) ((UBYTE*)(BADDR(hunktab[x]) + sizeof(BPTR)))
  28
  29 /* Seek forward by count ULONGs.
  30  * Returns 0 on success, 1 on failure.
  31  */
  32 static int seek_forward(BPTR fd, ULONG count, SIPTR *funcarray, struct DosLibrary *DOSBase)
  33 {
  34     int err = 0;
  35     ULONG tmp;
  36
  37     /* For AOS compatibility, we can't use DOS/Seek() here,
  38      * as AOS callers to InternalLoadSeg will not pass
  39      * in a Seek element of the funcarray, and the read
  40      * callback of funcarray may be for reading in-memory
  41      * instead of pointing to DOS/Read.
  42      *
  43      * Luckily, reading HUNKs is linear, so we can just
  44      * read ahead.
  45      */
  46     while (count && !(err = read_block(fd, &tmp, sizeof(tmp), funcarray, DOSBase)))
  47         count--;
  48
  49     return err;
  50 }
  51
  52 static BOOL allowed_hunk(BPTR seglist);
  53
  54 BPTR InternalLoadSeg_AOS(BPTR fh,
  55                          BPTR table,
  56                          SIPTR * funcarray,
  57                          LONG  * stacksize,
  58                          struct DosLibrary * DOSBase)
  59 {
  60   #define ERROR(a)    { *error=a; goto end; }
  61
  62
  63   BPTR *hunktab = BADDR(table);
  64   BPTR firsthunk = BNULL, prevhunk = BNULL;
  65   ULONG hunktype, count, first, last, curhunk, lasthunk, numhunks;
  66   LONG t;
  67   UBYTE name_buf[255];
  68   register int i;
  69   BPTR last_p = 0;
  70   UBYTE *overlaytable = NULL;
  71   ULONG tmp, req;
  72   SIPTR dummy;
  73 #if DEBUG
  74   static STRPTR segtypes[] = { "CODE", "DATA", "BSS", };
  75 #endif
  76
  77   SIPTR *error = &dummy;
  78
  79   if (DOSBase) {
  80     struct Process *me = (struct Process *)FindTask(NULL);
  81     ASSERT_VALID_PROCESS(me);
  82
  83     error =&me->pr_Result2;
  84   }
  85
  86   curhunk = lasthunk = 0; /* keep GCC quiet */
  87   /* start point is HUNK_HEADER + 4 */
  88   while (1)
  89   {
  90     if (read_block(fh, &count, sizeof(count), funcarray, DOSBase))
  91       goto end;
  92     if (count == 0L)
  93       break;
  94     count = AROS_BE2LONG(count);
  95     count *= 4;
  96     if (read_block(fh, name_buf, count, funcarray, DOSBase))
  97       goto end;
  98     D(bug("\tlibname: \"%.*s\"\n", count, name_buf));
  99   }
 100   if (read_block(fh, &numhunks, sizeof(numhunks), funcarray, DOSBase))
 101     goto end;
 102
 103   numhunks = AROS_BE2LONG(numhunks);
 104
 105   D(bug("\tHunk count: %ld\n", numhunks));
 106
 107   if (!hunktab) {
 108     hunktab = ilsAllocVec(sizeof(BPTR) * (numhunks + 1 + 1), MEMF_CLEAR);
 109     if (hunktab == NULL)
 110       ERROR(ERROR_NO_FREE_STORE);
 111   }
 112
 113   if (read_block(fh, &first, sizeof(first), funcarray, DOSBase))
 114     goto end;
 115
 116   first = AROS_BE2LONG(first);
 117
 118   D(bug("\tFirst hunk: %ld\n", first));
 119   curhunk = first;
 120   if (read_block(fh, &last, sizeof(last), funcarray, DOSBase))
 121     goto end;
 122
 123   last = AROS_BE2LONG(last);
 124
 125   D(bug("\tLast hunk: %ld\n", last));
 126
 127   for (i = first; i <= numhunks; i++) {
 128     UBYTE *hunkptr;
 129     ULONG hunksize;
 130
 131     if (i > last) {
 132       hunktab[i] = BNULL;
 133       continue;
 134     }
 135
 136     if (read_block(fh, &count, sizeof(count), funcarray, DOSBase))
 137       goto end;
 138
 139     count = AROS_BE2LONG(count);
 140     tmp = count & (HUNKF_FAST | HUNKF_CHIP);
 141     count &= 0xFFFFFF;
 142     D(bug("\tHunk %d size: 0x%06lx bytes in ", i, count*4));
 143     req = MEMF_CLEAR | MEMF_PUBLIC;
 144     if (tmp == (HUNKF_FAST | HUNKF_CHIP)) {
 145       if (read_block(fh, &req, sizeof(req), funcarray, DOSBase))
 146         goto end;
 147       req = AROS_BE2LONG(req);
 148       D(bug("FLAGS=%08x", req));
 149     } else if (tmp == HUNKF_FAST) {
 150       D(bug("FAST"));
 151       req |= MEMF_FAST;
 152     } else if (tmp == HUNKF_CHIP) {
 153       D(bug("CHIP"));
 154       req |= MEMF_CHIP;
 155     }
 156     D(bug(" memory"));
 157
 158     /*
 159      * We need space for the code, the length of this hunk and
 160      * for a pointer to the next hunk.
 161      * Note also MEMF_31BIT flag appended to memory requirements.
 162      * This is important on 64-bit machines where AmigaDOS hunk
 163      * files need to be loaded into low memory (<2GB). This is needed
 164      * for correct interpretation of pointers in these files.
 165      * Yes, they can't be executed in such environments, but they still can
 166      * be read as data files. This allows to use Amiga bitmap fonts on AROS.
 167      */
 168     hunksize = count * 4 + sizeof(ULONG) + sizeof(BPTR);
 169     hunkptr = ilsAllocVec(hunksize, req | MEMF_31BIT);
 170     if (!hunkptr)
 171       ERROR(ERROR_NO_FREE_STORE);
 172     hunktab[i] = MKBADDR(hunkptr);
 173     D(bug(" @%p\n", hunkptr));
 174     if (!firsthunk)
 175       firsthunk = hunktab[i];
 176       /* Link hunks
 177          if this is not the first hunk that is loaded, then connect
 178          it to the previous one (pointer to the field where the
 179          pointer to the next hunk is located)
 180        */
 181     if (prevhunk)
 182       ((BPTR *)(BADDR(prevhunk)))[0] = hunktab[i];
 183     prevhunk = hunktab[i];
 184   }
 185
 186   while(!read_block(fh, &hunktype, sizeof(hunktype), funcarray, DOSBase))
 187   {
 188     hunktype = AROS_BE2LONG(hunktype);
 189     D(bug("Hunk Type: %d\n", hunktype & 0xFFFFFF));
 190
 191     switch(hunktype & 0xFFFFFF)
 192     {
 193       case HUNK_SYMBOL:
 194         /* The SYMBOL_HUNK looks like this:
 195              ---------------------
 196              | n = size of       |  This
 197              |   symbol in longs |  may
 198              |-------------------|  be
 199              | n longwords = name|  repeated
 200              | of symbol         |  any
 201              |-------------------|  number
 202              | value (1 long)    |  of times
 203              --------------------|
 204              | 0 = end of HUNK_  |
 205              |       SYMBOL      |
 206              --------------------   */
 207
 208         D(bug("HUNK_SYMBOL (skipping)\n"));
 209           while(!read_block(fh, &count, sizeof(count), funcarray, DOSBase) && count)
 210           {
 211             count = AROS_BE2LONG(count) ;
 212
 213             if (seek_forward(fh, count+1, funcarray, DOSBase))
 214               goto end;
 215           }
 216       break;
 217
 218       case HUNK_UNIT:
 219
 220         if (read_block(fh, &count, sizeof(count), funcarray, DOSBase))
 221           goto end;
 222
 223         count = AROS_BE2LONG(count) ;
 224
 225         count *= 4;
 226         if (read_block(fh, name_buf, count, funcarray, DOSBase))
 227           goto end;
 228         D(bug("HUNK_UNIT: \"%.*s\"\n", count, name_buf));
 229         break;
 230
 231       case HUNK_CODE:
 232       case HUNK_DATA:
 233       case HUNK_BSS:
 234
 235         if (read_block(fh, &count, sizeof(count), funcarray, DOSBase))
 236           goto end;
 237
 238           count = AROS_BE2LONG(count);
 239
 240           D(bug("HUNK_%s(%d): Length: 0x%06lx bytes in ",
 241           segtypes[(hunktype & 0xFFFFFF)-HUNK_CODE], curhunk, count*4));
 242
 243         if ((hunktype & 0xFFFFFF) != HUNK_BSS && count)
 244         {
 245           if (read_block(fh, GETHUNKPTR(curhunk), count*4, funcarray, DOSBase))
 246             goto end;
 247
 248         }
 249
 250         lasthunk = curhunk;
 251         ++curhunk;
 252       break;
 253
 254       case HUNK_RELOC32:
 255       case HUNK_RELRELOC32:
 256         D(bug("HUNK_RELOC32:\n"));
 257         while (1)
 258         {
 259           ULONG *addr;
 260           ULONG offset;
 261
 262           if (read_block(fh, &count, sizeof(count), funcarray, DOSBase))
 263             goto end;
 264           if (count == 0L)
 265             break;
 266
 267           count = AROS_BE2LONG(count);
 268
 269           i = count;
 270           if (read_block(fh, &count, sizeof(count), funcarray, DOSBase))
 271             goto end;
 272
 273           count = AROS_BE2LONG(count);
 274
 275           D(bug("\tHunk #%ld:\n", count));
 276           while (i > 0)
 277           {
 278             if (read_block(fh, &offset, sizeof(offset), funcarray, DOSBase))
 279               goto end;
 280
 281             offset = AROS_BE2LONG(offset);
 282
 283             //D(bug("\t\t0x%06lx\n", offset));
 284             addr = (ULONG *)(GETHUNKPTR(lasthunk) + offset);
 285
 286             /* See the above MEMF_31 explanation for why this
 287              * works on AROS 64-bit.
 288              */
 289             if ((hunktype & 0xFFFFFF) == HUNK_RELRELOC32)
 290               *addr = (ULONG)(AROS_BE2LONG(*addr) + (IPTR)(GETHUNKPTR(count) - GETHUNKPTR(curhunk)));
 291             else
 292               *addr = (ULONG)(AROS_BE2LONG(*addr) + (IPTR)GETHUNKPTR(count));
 293
 294             --i;
 295           }
 296         }
 297       break;
 298
 299       case HUNK_DREL32: /* For compatibility with V37 */
 300       case HUNK_RELOC32SHORT:
 301         {
 302           ULONG Wordcount = 0;
 303           ULONG offset;
 304
 305           while (1)
 306           {
 307             ULONG *addr;
 308             UWORD word;
 309
 310             Wordcount++;
 311
 312             if (read_block(fh, &word, sizeof(word), funcarray, DOSBase))
 313               goto end;
 314             if (word == 0L)
 315               break;
 316
 317             word = AROS_BE2LONG(word);
 318
 319             i = word;
 320             Wordcount++;
 321             if (read_block(fh, &word, sizeof(word), funcarray, DOSBase))
 322               goto end;
 323
 324             word = AROS_BE2WORD(word);
 325
 326             count = word;
 327             D(bug("\tHunk #%ld @%p: %ld relocations\n", count, GETHUNKPTR(lasthunk), i));
 328             while (i > 0)
 329             {
 330               Wordcount++;
 331               /* read a 16bit number (2 bytes) */
 332               if (read_block(fh, &word, sizeof(word), funcarray, DOSBase))
 333                 goto end;
 334
 335               /* offset now contains the byte offset in it`s 16 highest bits.
 336                  These 16 highest bits have to become the 16 lowest bits so
 337                  we get the word we need.  */
 338               offset = AROS_BE2WORD(word);
 339
 340               D(bug("\t\t0x%06lx += 0x%lx\n", offset, GETHUNKPTR(count)));
 341               addr = (ULONG *)(GETHUNKPTR(lasthunk) + offset);
 342
 343               /* See the above MEMF_31 explanation for why this
 344                * works on AROS 64-bit.
 345                */
 346               *addr = (ULONG)(AROS_BE2LONG(*addr) + (IPTR)GETHUNKPTR(count));
 347
 348               --i;
 349             } /* while (i > 0)*/
 350           } /* while (1) */
 351
 352           /* if the amount of words read was odd, then skip the following
 353            16-bit word   */
 354           if (0x1 == (Wordcount & 0x1)) {
 355             UWORD word;
 356             read_block(fh, &word, sizeof(word), funcarray, DOSBase);
 357           }
 358         }
 359       break;
 360
 361       case HUNK_END:
 362       {
 363         D(bug("HUNK_END\n"));
 364         /* DOSBase == NULL: Called from RDB filesystem loader which does not
 365          * know filesystem's original size. Exit if last HUNK_END. This can't
 366          * be done normally because it would break overlayed executables.
 367          */
 368         if (!DOSBase && curhunk > last)
 369             goto done;
 370       }
 371       break;
 372
 373       case HUNK_RELOC16:
 374         bug("HUNK_RELOC16 not implemented\n");
 375         ERROR(ERROR_BAD_HUNK);
 376
 377       case HUNK_RELOC8:
 378         bug("HUNK_RELOC8 not implemented\n");
 379         ERROR(ERROR_BAD_HUNK);
 380
 381       case HUNK_NAME:
 382         bug("HUNK_NAME not implemented\n");
 383         ERROR(ERROR_BAD_HUNK);
 384
 385       case HUNK_EXT:
 386         bug("HUNK_EXT not implemented\n");
 387         ERROR(ERROR_BAD_HUNK);
 388
 389       case HUNK_DEBUG:
 390         if (read_block(fh, &count, sizeof(count), funcarray, DOSBase))
 391           goto end;
 392
 393         count = AROS_BE2LONG(count);
 394
 395         D(bug("HUNK_DEBUG (%x Bytes)\n",count));
 396         if (seek_forward(fh, count, funcarray, DOSBase))
 397           goto end;
 398         break;
 399
 400       case HUNK_OVERLAY:
 401       {
 402         D(bug("HUNK_OVERLAY:\n"));
 403         if (table) /* overlay inside overlay? */
 404           ERROR(ERROR_BAD_HUNK);
 405         if (read_block(fh, &count, sizeof(count), funcarray, DOSBase))
 406           goto end;
 407         count = AROS_BE2LONG(count);
 408         D(bug("Overlay table size: %d\n", count));
 409
 410         /* See above for MEMF_31BIT explanation */
 411         count = count * 4 + sizeof(ULONG) + sizeof(ULONG);
 412         overlaytable = ilsAllocVec(count, MEMF_CLEAR | MEMF_31BIT);
 413         if (overlaytable == NULL)
 414           ERROR(ERROR_NO_FREE_STORE);
 415         if (read_block(fh, overlaytable, count - sizeof(ULONG), funcarray, DOSBase))
 416             goto end;
 417         goto done;
 418       }
 419
 420       case HUNK_BREAK:
 421         D(bug("HUNK_BREAK\n"));
 422         if (!table)
 423           ERROR(ERROR_BAD_HUNK);
 424         goto done;
 425
 426       default:
 427         if (hunktype & HUNKF_ADVISORY) {
 428           D(bug("Unknown hunk 0x%06lx with advisory flag skipped\n", hunktype & 0xFFFFFF));
 429           if (read_block(fh, &count, sizeof(count), funcarray, DOSBase))
 430             goto end;
 431           count = AROS_BE2LONG(count);
 432           if (seek_forward(fh, count * 4, funcarray, DOSBase))
 433             goto end;
 434         } else {
 435           bug("Hunk type 0x%06lx not implemented\n", hunktype & 0xFFFFFF);
 436           ERROR(ERROR_BAD_HUNK);
 437         }
 438     } /* switch */
 439   } /* while */
 440 done:
 441   if (firsthunk && !allowed_hunk(firsthunk))
 442   {
 443       ERROR(ERROR_NOT_EXECUTABLE);
 444       goto end;
 445   }
 446
 447   if (hunktab)
 448   {
 449     ULONG hunksize;
 450
 451 #ifdef __mc68000
 452     /*
 453      * On non-m68k systems, hunk files are not executable.
 454      * And even if AROS ever gets m68k emulator, they are still data files.
 455      * So we flush caches only on m68k.
 456      */
 457     if (SysBase->LibNode.lib_Version >= 36)
 458     {
 459         /* Clear caches */
 460         for (t = first; t < numhunks && t <= last; t++)
 461         {
 462             hunksize = *((ULONG*)BADDR(hunktab[t]) - 1);
 463             if (hunksize)
 464                 CacheClearE(BADDR(hunktab[t]), hunksize, CACRF_ClearI | CACRF_ClearD);
 465         }
 466     }
 467 #endif
 468
 469     if (table)
 470       return firsthunk;
 471
 472     hunksize = *((ULONG*)BADDR(hunktab[0]) - 1);
 473     if (last > first && hunksize >= 32 / 4)
 474     {
 475       /* NOTE: HUNK_OVERLAY is not required for overlay mode. */
 476       ULONG *h = (ULONG*)(BADDR(hunktab[first]));
 477
 478       if (h[2] == 0x0000abcd)
 479       {
 480 #if __WORDSIZE != 32
 481         D(bug("overlay not supported!\n"));
 482         ERROR(ERROR_BAD_HUNK);
 483 #else
 484         /* overlay executable */
 485         h[3] = (ULONG)fh;
 486         h[4] = (ULONG)overlaytable;
 487         h[5] = (ULONG)MKBADDR(hunktab);
 488         D(bug("overlay loaded!\n"));
 489         return (BPTR)(-(LONG)MKBADDR(h));
 490 #endif
 491       }
 492     }
 493
 494     if (overlaytable) {
 495       ilsFreeVec(overlaytable);
 496       ERROR(ERROR_BAD_HUNK);
 497     }
 498
 499     last_p = firsthunk;
 500
 501     register_hunk(fh, firsthunk, NULL, DOSBase);
 502
 503     ilsFreeVec(hunktab);
 504     hunktab = NULL;
 505   }
 506
 507 end:
 508   if (hunktab != NULL)
 509   {
 510     for (t = 0 /* first */; t < numhunks /* last */; t++)
 511       ilsFreeVec(BADDR(hunktab[t]));
 512     ilsFreeVec(hunktab);
 513   }
 514   return last_p;
 515 } /* InternalLoadSeg */
 516
 517 #ifdef __mc68000
 518 static AROS_UFH4(LONG, ReadFunc,
 519         AROS_UFHA(BPTR, file,   D1),
 520         AROS_UFHA(APTR, buffer, D2),
 521         AROS_UFHA(LONG, length, D3),
 522         AROS_UFHA(struct DosLibrary *, DOSBase, A6)
 523 )
 524 {
 525     AROS_USERFUNC_INIT
 526
 527     return FRead(file, buffer, 1, length);
 528
 529     AROS_USERFUNC_EXIT
 530 }
 531
 532 static AROS_UFH3(APTR, AllocFunc,
 533         AROS_UFHA(ULONG, length, D0),
 534         AROS_UFHA(ULONG, flags,  D1),
 535         AROS_UFHA(struct ExecBase *, SysBase, A6)
 536 )
 537 {
 538     AROS_USERFUNC_INIT
 539
 540     return AllocMem(length, flags);
 541
 542     AROS_USERFUNC_EXIT
 543 }
 544
 545 static AROS_UFH3(void, FreeFunc,
 546         AROS_UFHA(APTR, buffer, A1),
 547         AROS_UFHA(ULONG, length, D0),
 548         AROS_UFHA(struct ExecBase *, SysBase, A6)
 549 )
 550 {
 551     AROS_USERFUNC_INIT
 552
 553     FreeMem(buffer, length);
 554
 555     AROS_USERFUNC_EXIT
 556 }
 557
 558 AROS_UFH4(BPTR, LoadSeg_Overlay,
 559     AROS_UFHA(UBYTE*, name, D1),
 560     AROS_UFHA(BPTR, hunktable, D2),
 561     AROS_UFHA(BPTR, fh, D3),
 562     AROS_UFHA(struct DosLibrary *, DosBase, A6))
 563 {
 564     AROS_USERFUNC_INIT
 565
 566     void (*FunctionArray[3])();
 567     ULONG hunktype;
 568
 569     FunctionArray[0] = (APTR)ReadFunc;
 570     FunctionArray[1] = (APTR)AllocFunc;
 571     FunctionArray[2] = (APTR)FreeFunc;
 572
 573     D(bug("LoadSeg_Overlay. table=%x fh=%x\n", hunktable, fh));
 574     if (read_block(fh, &hunktype, sizeof(hunktype), (SIPTR*)FunctionArray, DosBase))
 575         return BNULL;
 576     hunktype = AROS_BE2LONG(hunktype);
 577     if (hunktype != HUNK_HEADER)
 578         return BNULL;
 579     return InternalLoadSeg_AOS(fh, hunktable, (SIPTR*)FunctionArray, NULL, DosBase);
 580
 581     AROS_USERFUNC_EXIT
 582 }
 583
 584 #endif
 585
 586 static BOOL allowed_hunk(BPTR seglist)
 587 {
 588 #ifdef __mc68000
 589     return TRUE;
 590 #else
 591     /* deadwood: This is a not-so-great solution to the problem of crashes/reboots
 592      * when users accidentally try running m68k hunk executables.
 593      * I think the better solution would be to load the hunk (or non-native elf)
 594      * but stop it from executing or redirect to emulator by mechanism similar
 595      * to OS4 GetSegListInfo() and struct PseudoSegList. This way also runtime
 596      * generated seglists would be handled properly.
 597      */
 598     UBYTE * ptr = (UBYTE *)BADDR(seglist);
 599
 600     /* Allow bitmap fonts */
 601     if (ptr[22] == 0x0f && ptr[23] == 0x80)
 602         return TRUE;
 603
 604     return FALSE;
 605 #endif
 606 }