rom/dosboot/dosboot_init.c

   1 /*
   2     Copyright © 1995-2010, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Start up the ol' Dos boot process.
   6     Lang: english
   7 */
   8
   9 #define AROS_BOOT_CHECKSIG
  10
  11 # define  DEBUG 0
  12 # include <aros/debug.h>
  13
  14 #include <aros/macros.h>
  15 #include <aros/asmcall.h>
  16 #include <aros/symbolsets.h>
  17
  18 #include <proto/exec.h>
  19 #include <proto/dos.h>
  20
  21 #include <exec/types.h>
  22 #include <exec/nodes.h>
  23 #include <exec/lists.h>
  24 #include <exec/execbase.h>
  25 #include <exec/alerts.h>
  26 #include <exec/memory.h>
  27 #include <dos/dosextens.h>
  28 #include <dos/dostags.h>
  29 #include <dos/filehandler.h>
  30 #include <dos/filesystem.h>
  31 #include <libraries/expansionbase.h>
  32 #include <devices/trackdisk.h>
  33
  34 #include <string.h>
  35 #include <stdio.h>
  36
  37 #include LC_LIBDEFS_FILE
  38
  39 #include "menu.h"
  40 #include "dosboot_intern.h"
  41
  42 #define BNF_RETRY 0x8000 /* Private flag for the BootNode */
  43 #define BNF_MOUNTED 0x4000 /* Private flag for the BootNode */
  44
  45 #ifdef AROS_DOS_PACKETS
  46
  47 struct Process *RunPacketHandler(struct DeviceNode *dn, const char *name, struct DosLibrary *DOSBase);
  48
  49 BOOL __dosboot_RunHandler(struct DeviceNode *deviceNode, struct DosLibrary *DOSBase)
  50 {
  51         return RunPacketHandler(deviceNode, NULL, DOSBase) != NULL;
  52 }
  53
  54 static BOOL __dosboot_Mount(struct DeviceNode *dn, struct DosLibrary * DOSBase)
  55 {
  56     BOOL rc;
  57
  58     D(bug("[DOSBoot] __dosboot_Mount: handler=%08lx stack=%08x seglist=%08x\n",
  59         dn->dn_Handler, dn->dn_StackSize, dn->dn_SegList));
  60     if (!dn->dn_Task)
  61     {
  62         D(bug("[DOSBoot] __dosboot_Mount: Attempting to mount\n"));
  63         rc = __dosboot_RunHandler(dn, DOSBase);
  64     }
  65     else
  66     {
  67         D(bug("[DOSBoot] __dosboot_Mount: Volume already mounted\n"));
  68         rc = TRUE;
  69     }
  70
  71     if (rc)
  72     {
  73         if (!AddDosEntry((struct DosList *) dn))
  74         {
  75             kprintf("Mounting node %08lx (%s) failed at AddDosEntry() -- maybe it was already added by someone else!\n", dn, AROS_DOSDEVNAME(dn));
  76             Alert(AT_DeadEnd | AG_NoMemory | AN_DOSLib);
  77         }
  78     }
  79     return rc;
  80 }
  81
  82 #else
  83
  84 /** Support Functions **/
  85 /* Attempt to start a handler for the DeviceNode */
  86 BOOL __dosboot_RunHandler(struct DeviceNode *deviceNode, struct DosLibrary *DOSBase)
  87 {
  88     struct MsgPort *mp;
  89     struct IOFileSys *iofs;
  90     BOOL ok = FALSE;
  91     BOOL opened = FALSE;
  92
  93     D(bug("[DOSBoot] __dosboot_RunHandler()\n" ));
  94     mp = CreateMsgPort();
  95
  96     if (mp != NULL)
  97     {
  98         iofs = (struct IOFileSys *)CreateIORequest(mp, sizeof(struct IOFileSys));
  99
 100         if (iofs != NULL)
 101         {
 102             STRPTR handler;
 103             struct FileSysStartupMsg *fssm;
 104             ULONG fssmFlags = 0;
 105
 106             if (deviceNode->dn_Handler == BNULL)
 107             {
 108                 handler = "afs.handler";
 109             }
 110             else
 111             {
 112                 handler = AROS_BSTR_ADDR(deviceNode->dn_Handler);
 113             }
 114
 115             /* FIXME: this assumes that dol_Startup points to struct FileSysStartupMsg.
 116                This is not true for plain handlers, dol_Startup is a BSTR in this case.
 117                In order to make use of this we should implement direct support for
 118                packet-style handlers in dos.library */
 119             fssm = (struct FileSysStartupMsg *)BADDR(deviceNode->dn_Startup);
 120             if (fssm != NULL)
 121             {
 122                 iofs->io_Union.io_OpenDevice.io_DeviceName = AROS_BSTR_ADDR(fssm->fssm_Device);
 123                 iofs->io_Union.io_OpenDevice.io_Unit       = fssm->fssm_Unit;
 124                 iofs->io_Union.io_OpenDevice.io_Environ    = (IPTR *)BADDR(fssm->fssm_Environ);
 125                 fssmFlags = fssm->fssm_Flags;
 126             }
 127             iofs->io_Union.io_OpenDevice.io_DosName    = deviceNode->dn_Ext.dn_AROS.dn_DevName;
 128             iofs->io_Union.io_OpenDevice.io_DeviceNode = deviceNode;
 129
 130             D(bug("[DOSBoot] __dosboot_RunHandler: Starting up %s\n", handler));
 131             opened = !OpenDevice(handler, 0, &iofs->IOFS, fssmFlags);
 132             if(!opened)
 133             {
 134                 D(bug("[DOSBoot] __dosboot_RunHandler: Retrying with packet.handler\n"));
 135                 opened = !OpenDevice("packet.handler", 0, &iofs->IOFS, fssmFlags);
 136             }
 137             if (opened)
 138             {
 139                 /* Ok, this means that the handler was able to open. */
 140                 D(bug("[DOSBoot] __dosboot_RunHandler: Handler started\n"));
 141                 deviceNode->dn_Ext.dn_AROS.dn_Device = iofs->IOFS.io_Device;
 142                 deviceNode->dn_Ext.dn_AROS.dn_Unit = iofs->IOFS.io_Unit;
 143                 // FIXME I think the device must be closed again, especially because the IORequest is freed a few lines below (chodges, 04-08-2009)
 144                 //CloseDevice(&iofs->IOFS);
 145                 ok = TRUE;
 146             }
 147
 148             DeleteIORequest(&iofs->IOFS);
 149         }
 150
 151         DeleteMsgPort(mp);
 152     }
 153     return ok;
 154 }
 155
 156 static BOOL __dosboot_Mount(struct DeviceNode *dn, struct DosLibrary * DOSBase)
 157 {
 158     BOOL rc;
 159
 160     D(bug("[DOSBoot] __dosboot_Mount: handler=%08lx stack=%08x seglist=%08x\n",
 161         dn->dn_Handler, dn->dn_StackSize, dn->dn_SegList));
 162     if (!dn->dn_Ext.dn_AROS.dn_Device)
 163     {
 164         D(bug("[DOSBoot] __dosboot_Mount: Attempting to mount\n"));
 165         rc = __dosboot_RunHandler(dn, DOSBase);
 166     }
 167     else
 168     {
 169         D(bug("[DOSBoot] __dosboot_Mount: Volume already mounted\n"));
 170         rc = TRUE;
 171     }
 172
 173     if (rc)
 174     {
 175         if (!AddDosEntry((struct DosList *) dn))
 176         {
 177             kprintf("Mounting node %08lx (%s) failed at AddDosEntry() -- maybe it was already added by someone else!\n", dn, dn->dn_Ext.dn_AROS.dn_DevName);
 178             Alert(AT_DeadEnd | AG_NoMemory | AN_DOSLib);
 179         }
 180     }
 181     return rc;
 182 }
 183
 184 #endif
 185
 186 static BOOL __dosboot_IsBootable(CONST_STRPTR deviceName, struct DosLibrary * DOSBase)
 187 {
 188     BPTR lock;
 189     BOOL            result = FALSE;
 190     STRPTR          buffer;
 191     LONG            bufferLength;
 192
 193     D(bug("[DOSBoot] __dosboot_IsBootable('%s')\n", deviceName));
 194
 195 #if (AROS_FLAVOUR & AROS_FLAVOUR_BINCOMPAT) && defined(mc68000)
 196
 197     {
 198         bufferLength = strlen(deviceName) + 1 + 1;
 199         /* bootable if we can lock the device */
 200         buffer = AllocMem(bufferLength, MEMF_ANY);
 201         if (!buffer)
 202             return FALSE;
 203         sprintf(buffer, "%s:", deviceName);
 204         if ((lock = Lock(buffer, SHARED_LOCK)))
 205             result = TRUE;
 206         UnLock(lock);
 207         lock = 0;
 208     }
 209
 210 #else
 211
 212 #if defined(AROS_BOOT_CHECKSIG)
 213 #define AROSBOOTSIG_FILE ":AROS.boot"
 214
 215     LONG readsize;
 216     struct FileInfoBlock abfile_fib;
 217
 218     bufferLength = strlen(deviceName) + sizeof(AROSBOOTSIG_FILE) + 1;
 219
 220     if ((buffer = AllocMem(bufferLength, MEMF_ANY)) == NULL)
 221     {
 222         Alert(AT_DeadEnd | AG_NoMemory | AN_DOSLib);
 223     }
 224
 225     strcpy(buffer, deviceName);
 226     strcat(buffer, AROSBOOTSIG_FILE);
 227
 228     if ((lock = Open(buffer, MODE_OLDFILE)) == 0)
 229     {
 230         D(bug("[DOSBoot] __dosboot_IsBootable: Failed to open '%s'\n", buffer));
 231         goto cleanup;
 232     }
 233
 234     D(bug("[DOSBoot] __dosboot_IsBootable: Opened '%s'\n", buffer));
 235     FreeMem(buffer, bufferLength);
 236     buffer = NULL;
 237
 238     if (ExamineFH(lock, &abfile_fib))
 239     {
 240         bufferLength = abfile_fib.fib_Size + 1;
 241
 242         if ((buffer = AllocMem(bufferLength, MEMF_ANY)) == NULL)
 243         {
 244             Alert(AT_DeadEnd | AG_NoMemory | AN_DOSLib);
 245         }
 246         D(bug("[DOSBoot] __dosboot_IsBootable: Allocated %d bytes for Buffer @ %p\n", bufferLength, buffer));
 247         if ((readsize = Read(lock, buffer, (bufferLength - 1))) != -1)
 248         {
 249             char *sigptr = NULL;
 250
 251             if (readsize != 0)
 252                 buffer[readsize] = '\0';
 253             else
 254                 buffer[bufferLength - 1] = '\0';
 255
 256             D(bug("[DOSBoot] __dosboot_IsBootable: Buffer contains '%s'\n", buffer));
 257             if ((sigptr = strstr(buffer, AROS_CPU)) != 0)
 258             {
 259                 D(bug("[DOSBoot] __dosboot_IsBootable: Signature '%s' found\n", sigptr));
 260                 result = TRUE;
 261             }
 262         }
 263     }
 264     Close(lock);
 265     lock = BNULL;
 266
 267 #else
 268 #define SHELL_FILE ":C/Shell"
 269
 270     BPTR seglist;
 271
 272     bufferLength = strlen(deviceName) + sizeof(SHELL_FILE) + 1;
 273
 274     if ((buffer = AllocMem(bufferLength, MEMF_PUBLIC)) == NULL)
 275     {
 276         Alert(AT_DeadEnd | AG_NoMemory | AN_DOSLib);
 277     }
 278
 279     strcpy(buffer, deviceName);
 280     strcat(buffer, SHELL_FILE);
 281
 282     D(bug("[DOSBoot] __dosboot_IsBootable: "
 283         "Trying to load '%s' as an executable\n", buffer));
 284
 285     if ((seglist = LoadSeg(buffer)) == (BPTR)NULL)
 286     {
 287         D(bug("[DOSBoot] __dosboot_IsBootable: could not load '%s'\n", buffer));
 288         goto cleanup;
 289     }
 290
 291     UnLoadSeg(seglist);
 292     result = TRUE;
 293 #endif
 294
 295 #endif
 296
 297 cleanup:
 298     if (buffer != NULL ) FreeMem(buffer, bufferLength);
 299
 300     D(bug("[DOSBoot] __dosboot_IsBootable returned %d\n", result));
 301
 302     return result;
 303 }
 304
 305 static void AddBootAssign(CONST_STRPTR path, CONST_STRPTR assign)
 306 {
 307     BPTR lock;
 308     if (!(lock = Lock(path, SHARED_LOCK)))
 309         lock = Lock("SYS:", SHARED_LOCK);
 310     if (lock)
 311         AssignLock(assign, lock);
 312 }
 313
 314 /** Boot Code **/
 315
 316 AROS_UFH3(void, __dosboot_BootProcess,
 317     AROS_UFHA(APTR, argString, A0),
 318     AROS_UFHA(ULONG, argSize, D0),
 319     AROS_UFHA(struct ExecBase *,SysBase, A6)
 320 )
 321 {
 322     AROS_USERFUNC_INIT
 323
 324     struct ExpansionBase        *ExpansionBase = NULL;
 325     struct DosLibrary           *DOSBase       = NULL;
 326     LIBBASETYPEPTR              LIBBASE        = FindTask(NULL)->tc_UserData;
 327
 328     struct BootNode             *bootNode      = NULL;
 329     struct Node                 *tmpNode       = NULL;
 330     STRPTR                      bootName;
 331     LONG                        bootNameLength;
 332     BPTR                        lock;
 333     APTR                        BootLoaderBase = OpenResource("bootloader.resource");
 334     struct Screen *bootScreen = NULL;
 335
 336     D(bug("[DOSBoot] __dosboot_BootProcess()\n"));
 337
 338 #define deviceName AROS_DOSDEVNAME(bootNode->bn_DeviceNode)
 339
 340     /**** Open all required libraries **********************************************/
 341     if ((DOSBase = (struct DosLibrary *)OpenLibrary("dos.library", 0)) == NULL)
 342     {
 343         D(bug("[DOSBoot] __dosboot_BootProcess: Failed to open dos.library.\n" ));
 344         Alert(AT_DeadEnd| AG_OpenLib | AN_DOSLib | AO_DOSLib);
 345     }
 346
 347     if ((ExpansionBase = (struct ExpansionBase *)OpenLibrary("expansion.library", 0)) == NULL)
 348     {
 349         D(bug("[DOSBoot] __dosboot_BootProcess: Failed to open expansion.library.\n"));
 350         Alert(AT_DeadEnd | AG_OpenLib | AN_DOSLib | AO_ExpansionLib);
 351     }
 352
 353     /**** Try to mount all filesystems in the MountList ****************************/
 354     D(bug("[DOSBoot] __dosboot_BootProcess: Checking expansion.library/MountList for useable nodes:\n"));
 355
 356     ForeachNode(&ExpansionBase->MountList, bootNode)
 357     {
 358         D(bug("[DOSBoot] __dosboot_BootProcess: BootNode: %p, bn_DeviceNode: %p, Name '%s', Priority %4d\n",
 359                 bootNode, bootNode->bn_DeviceNode, deviceName, bootNode->bn_Node.ln_Pri
 360         ));
 361         /*
 362             Try to mount the filesystem. If it fails, mark the BootNode
 363             so DOS doesn't try to boot from it later but will retry to
 364             mount it after boot device is found and system directories
 365             assigned.
 366         */
 367
 368         if (!(__dosboot_Mount( (struct DeviceNode *) bootNode->bn_DeviceNode, DOSBase)))
 369         {
 370             bootNode->bn_Flags |= BNF_RETRY;
 371             D(bug("[DOSBoot] __dosboot_BootProcess: Marked '%s' as needing retry\n", deviceName));
 372         }
 373         else
 374         {
 375             bootNode->bn_Flags |= BNF_MOUNTED;
 376             bootNode->bn_Flags &= ~BNF_RETRY;
 377             D(bug("[DOSBoot] __dosboot_BootProcess: Marked '%s' as useable\n", deviceName));
 378         }
 379     }
 380
 381     /**** Try to find a bootable filesystem ****************************************/
 382     while (LIBBASE->db_BootDevice == NULL)
 383     {
 384         ForeachNode(&ExpansionBase->MountList, bootNode)
 385         {
 386             D(bug("[DOSBoot] __dosboot_BootProcess: Trying '%s' ...\n", deviceName));
 387             /*  Check if the mounted filesystem is bootable. If it's not,
 388                 it's probably some kind of transient error (ie. no disk
 389                 in drive or wrong disk) so we only move it to the end of
 390                 the list. */
 391             if ((!(bootNode->bn_Flags & BNF_RETRY)) && (bootNode->bn_Node.ln_Pri != -128)
 392                 && __dosboot_IsBootable(deviceName, DOSBase))
 393             {
 394                 LIBBASE->db_BootDevice = deviceName;
 395                 break;
 396             }
 397         }
 398
 399         if (!(LIBBASE->db_BootDevice))
 400         {
 401             if (!bootScreen)
 402                 bootScreen = NoBootMediaScreen(LIBBASE);
 403
 404             D(kprintf("No bootable disk was found.\n"));
 405             D(kprintf("Please insert a bootable disk in any drive.\n"));
 406             D(kprintf("Retrying in 5 seconds...\n"));
 407
 408             Delay(500);
 409
 410             /* retry to mount stuff -- there might be some additional device in the meanwhile */
 411             ForeachNode(&ExpansionBase->MountList, bootNode)
 412             {
 413                 D(bug("[DOSBoot] __dosboot_BootProcess: Retrying to mount '%s' ...\n", deviceName));
 414                 if(((bootNode->bn_Flags & BNF_RETRY) || (!(bootNode->bn_Flags & BNF_MOUNTED))) && (bootNode->bn_Node.ln_Pri != -128))
 415                 {
 416                     if (!(__dosboot_Mount( (struct DeviceNode *) bootNode->bn_DeviceNode, DOSBase)))
 417                     {
 418                         bootNode->bn_Flags |= BNF_RETRY;
 419                     } else {
 420                         bootNode->bn_Flags |= BNF_MOUNTED;
 421                         bootNode->bn_Flags &= ~BNF_RETRY;
 422                         D(bug("[DOSBoot] __dosboot_BootProcess: Late marked '%s' as useable\n", deviceName));
 423                     }
 424                 }
 425             }
 426         }
 427     }
 428
 429     if (bootScreen)
 430         CloseBootScreen(bootScreen, LIBBASE);
 431
 432     if (LIBBASE->db_BootDevice != NULL)
 433     {
 434         /* Construct the complete device name of the boot device */
 435         bootNameLength = strlen(LIBBASE->db_BootDevice) + 2;
 436
 437         if ((bootName = AllocMem(bootNameLength, MEMF_ANY|MEMF_CLEAR)) == NULL)
 438         {
 439             Alert(AT_DeadEnd | AG_NoMemory | AO_DOSLib | AN_StartMem);
 440         }
 441
 442         strcpy(bootName, LIBBASE->db_BootDevice);
 443         strcat(bootName, ":");
 444
 445         D(bug("[DOSBoot] __dosboot_BootProcess: Booting from device '%s'\n", bootName));
 446
 447         /* Lock the boot device and add some default assigns */
 448         lock =  Lock(bootName, SHARED_LOCK);
 449         if (lock)
 450                 DOSBase->dl_SYSLock = DupLock(lock);
 451
 452         if ((lock != BNULL) && (DOSBase->dl_SYSLock != BNULL))
 453         {
 454             AssignLock("SYS", lock);
 455         }
 456         else
 457         {
 458             Alert(AT_DeadEnd | AG_BadParm | AN_DOSLib);
 459         }
 460
 461         FreeMem( bootName, bootNameLength );
 462
 463         if ((lock = Lock("SYS:", SHARED_LOCK)) != BNULL)
 464         {
 465             CurrentDir(lock);
 466         }
 467         else
 468         {
 469             Alert(AT_DeadEnd | AG_BadParm | AN_DOSLib);
 470         }
 471
 472         AddBootAssign("SYS:C", "C");
 473         AddBootAssign("SYS:S", "S");
 474         AddBootAssign("SYS:Libs", "LIBS");
 475         AddBootAssign("SYS:Devs", "DEVS");
 476         AddBootAssign("SYS:L", "L");
 477         AddBootAssign("SYS:Fonts", "FONTS");
 478
 479 #if !(mc68000)
 480         if ((lock = Lock("DEVS:Drivers", SHARED_LOCK)) != BNULL)
 481         {
 482             AssignLock("DRIVERS", lock);
 483             AssignAdd("LIBS", lock);        /* Let hidds in DRIVERS: directory be found by OpenLibrary */
 484         }
 485 #endif
 486
 487         /* Late binding ENVARC: assign, only if used */
 488         AssignLate("ENVARC", "SYS:Prefs/env-archive");
 489
 490         /*
 491             Attempt to mount filesystems marked for retry. If it fails again,
 492             remove the BootNode from the list.
 493         */
 494         D(bug("[DOSBoot] Assigns done, retrying mounting handlers\n"));
 495         ForeachNodeSafe(&ExpansionBase->MountList, bootNode, tmpNode)
 496         {
 497             if (bootNode->bn_Flags & BNF_RETRY)
 498             {
 499                 D(bug("[DOSBoot] __dosboot_BootProcess: Retrying node: %p, DevNode: %p, Name = %s\n", bootNode, bootNode->bn_DeviceNode, deviceName));
 500                 if( !__dosboot_Mount((struct DeviceNode *)bootNode->bn_DeviceNode, DOSBase))
 501                 {
 502                     Forbid();
 503                     REMOVE( bootNode );
 504                     Permit();
 505                 }
 506             }
 507         }
 508         ExpansionBase->Flags |= EBF_BOOTFINISHED;
 509
 510         /* We don't need expansion.library any more */
 511         D(bug("[DOSBoot] Closing expansion.library\n"));
 512         CloseLibrary( (struct Library *) ExpansionBase );
 513
 514 #if !(mc68000)
 515         /* Initialize HIDDs */
 516         if (!(LIBBASE->BootFlags & BF_NO_DISPLAY_DRIVERS))
 517         {
 518             D(bug("[DOSBoot] Loading display drivers\n"));
 519             __dosboot_InitHidds(DOSBase);
 520         }
 521 #endif
 522         /* We now call the system dependant boot - should NEVER return! */
 523         D(bug("[DOSBoot] Calling bootstrap code\n"));
 524         __dosboot_Boot(BootLoaderBase, DOSBase, LIBBASE->BootFlags);
 525     }
 526
 527     //We Should NEVER reach here!
 528 #undef deviceName
 529
 530     AROS_USERFUNC_EXIT
 531 }
 532
 533 int dosboot_Init(LIBBASETYPEPTR LIBBASE)
 534 {
 535     struct TagItem bootprocess[] =
 536     {
 537         { NP_Entry,             (IPTR) __dosboot_BootProcess    },
 538         { NP_Name,              (IPTR) "Boot Process"           },
 539         { NP_UserData,          (IPTR) LIBBASE                  },
 540         { NP_Input,             (IPTR) NULL                     },
 541         { NP_Output,            (IPTR) NULL                     },
 542         { NP_WindowPtr,         -1                              },
 543         { NP_CurrentDir,        (IPTR) NULL                     },
 544         { NP_StackSize,         AROS_STACKSIZE * 2              },
 545         { NP_Cli,               (IPTR) 0                        },
 546         { TAG_END,                                              }
 547     };
 548
 549     D(bug("[DOSBoot] dosboot_Init()\n"));
 550     D(bug("[DOSBoot] dosboot_Init: Launching Boot Process control task ..\n"));
 551
 552     LIBBASE->db_BootDevice = NULL;
 553     LIBBASE->BootFlags = 0;
 554
 555     bootmenu_Init(LIBBASE);
 556
 557     if (CreateNewProc(bootprocess) == NULL)
 558     {
 559         D(bug("[DOSBoot] dosboot_Init: CreateNewProc() failed with %ld\n", ((struct Process *)FindTask(NULL))->pr_Result2));
 560         Alert( AT_DeadEnd | AN_DOSLib | AG_ProcCreate );
 561     }
 562     return TRUE;
 563 }
 564
 565 ADD2INITLIB(dosboot_Init, 1)