rom/dos/dosboot.c

   1 /*
   2     Copyright © 1995-2006, 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
  10 # define  DEBUG  0
  11 # include <aros/debug.h>
  12
  13 #include <aros/macros.h>
  14
  15 #include <exec/types.h>
  16 #include <exec/nodes.h>
  17 #include <exec/lists.h>
  18 #include <exec/execbase.h>
  19 #include <exec/alerts.h>
  20 #include <exec/memory.h>
  21 #include <dos/dosextens.h>
  22 #include <dos/dostags.h>
  23 #include <libraries/expansionbase.h>
  24 #include <aros/asmcall.h>
  25 #include <string.h>
  26 #include <dos/filehandler.h>
  27 #include <dos/filesystem.h>
  28 #include <devices/trackdisk.h>
  29
  30 #include <proto/exec.h>
  31 #include <proto/dos.h>
  32
  33 #include <string.h>
  34
  35 extern void boot();
  36
  37 BOOL init_hidds( struct ExecBase *, struct DosLibrary * );
  38 BOOL mount( struct DeviceNode *dn, struct DosLibrary * );
  39 BOOL isBootable( CONST_STRPTR deviceNam, struct DosLibrary * );
  40
  41 AROS_UFH3(void, intBoot,
  42     AROS_UFHA(APTR, argString, A0),
  43     AROS_UFHA(ULONG, argSize, D0),
  44     AROS_UFHA(struct ExecBase *,SysBase, A6)
  45 )
  46 {
  47     AROS_USERFUNC_INIT
  48
  49     struct ExpansionBase *ExpansionBase = NULL;
  50     struct DosLibrary    *DOSBase       = NULL;
  51     struct BootNode      *bootNode      = NULL;
  52     STRPTR                bootName;
  53     LONG                  bootNameLength;
  54     BPTR                  lock;
  55     LONG                  second;
  56
  57 #   define deviceName (((struct DosList *) bootNode->bn_DeviceNode)->dol_DevName)
  58
  59     /**** Open all required libraries **********************************************/
  60     DOSBase       = (struct DosLibrary *)    OpenLibrary( "dos.library", 0 );
  61     ExpansionBase = (struct ExpansionBase *) OpenLibrary( "expansion.library", 0 );
  62
  63     if( DOSBase == NULL )
  64     {
  65         D(bug( "Could not open dos.library, something's wrong!\n" ));
  66         Alert(AT_DeadEnd| AG_OpenLib | AN_DOSLib | AO_DOSLib);
  67     }
  68
  69     if( ExpansionBase == NULL )
  70     {
  71         D(bug( "Could not open expansion.library, something's wrong!\n"));
  72         Alert(AT_DeadEnd | AG_OpenLib | AN_DOSLib | AO_ExpansionLib);
  73     }
  74
  75     /**** Try to mount all filesystems in the MountList ****************************/
  76     D(bug( "Examining MountList:\n" ));
  77
  78     ForeachNode( &ExpansionBase->MountList, bootNode )
  79     {
  80         D(bug
  81         (
  82             "Node: %p, DevNode: %p, Name = %s\n",
  83             bootNode, bootNode->bn_DeviceNode,
  84             deviceName ? deviceName : "(null)"
  85         ));
  86 #if (AROS_FLAVOUR & AROS_FLAVOUR_EMULATION)
  87         AddDosEntry( (struct DosList *) bootNode->bn_DeviceNode );
  88 #else
  89         /*
  90             Try to mount the filesystem. If it fails, remove the BootNode
  91             from the list so DOS doesn't try to boot from it later.
  92         */
  93
  94         if( !mount( (struct DeviceNode *) bootNode->bn_DeviceNode ,
  95                     (struct DosLibrary *) DOSBase))
  96         {
  97             REMOVE( bootNode );
  98         }
  99 #endif
 100     }
 101
 102     /**** Try to find a bootable filesystem ****************************************/
 103     while( TRUE )
 104     {
 105         ForeachNode( &ExpansionBase->MountList, bootNode )
 106         {
 107             /*
 108                 Check if the mounted filesystem is bootable. If it's not,
 109                 it's probably some kind of transient error (ie. no disk
 110                 in drive or wrong disk) so we only move it to the end of
 111                 the list.
 112             */
 113
 114             if( isBootable( deviceName, (struct DosLibrary *)DOSBase ) )
 115             {
 116                 goto boot;
 117             }
 118         }
 119
 120         kprintf( "No bootable disk was found.\n" );
 121         kprintf( "Please insert a bootable disk in any drive.\n" );
 122
 123 #if 0
 124         for( second = 5; second > 0; second-- ) {
 125             kprintf( "Retrying in %d seconds...\n", second );
 126             Delay( 50 );
 127         }
 128 #else
 129             kprintf( "Retrying in 5 seconds...\n" );
 130             Delay( 500 );
 131 #endif
 132
 133         /* FIXME: Should there be a prompt instead of a automatic retry? */
 134     }
 135
 136 boot:
 137
 138     /* Construct the complete device name of the boot device */
 139     bootNameLength = strlen( deviceName ) + 2;
 140     bootName       = AllocMem( bootNameLength, MEMF_ANY);
 141
 142     if( bootName == NULL )
 143     {
 144         Alert(AT_DeadEnd | AG_NoMemory | AO_DOSLib | AN_StartMem);
 145     }
 146
 147     strcpy( bootName, deviceName );
 148     strcat( bootName, ":" );
 149
 150     kprintf("[DOS] Booting from device %s\n",bootName);
 151
 152     /* We don't need expansion.library any more */
 153     CloseLibrary( (struct Library *) ExpansionBase );
 154
 155     /* Lock the boot device and add some default assigns */
 156     D(bug("Locking primary boot device %s\n", bootName));
 157
 158     lock =  Lock(bootName, SHARED_LOCK);
 159     if (lock) DOSBase->dl_SYSLock = DupLock(lock);
 160
 161     if ((lock != NULL) && (DOSBase->dl_SYSLock != NULL))
 162     {
 163         AssignLock("SYS", lock);
 164     }
 165     else
 166     {
 167         Alert(AT_DeadEnd | AG_BadParm | AN_DOSLib);
 168     }
 169
 170     FreeMem( bootName, bootNameLength );
 171
 172     lock = Lock("SYS:", SHARED_LOCK);
 173
 174     if (lock != NULL)
 175     {
 176         CurrentDir(lock);
 177     }
 178     else
 179     {
 180         Alert(AT_DeadEnd | AG_BadParm | AN_DOSLib);
 181     }
 182
 183     lock = Lock("SYS:C", SHARED_LOCK);
 184
 185     if (lock != NULL)
 186     {
 187         AssignLock("C", lock);
 188     }
 189
 190     lock = Lock("SYS:S", SHARED_LOCK);
 191
 192     if (lock != NULL)
 193     {
 194         AssignLock("S", lock);
 195     }
 196
 197     lock = Lock("SYS:Libs", SHARED_LOCK);
 198
 199     if (lock != NULL)
 200     {
 201         AssignLock("LIBS", lock);
 202     }
 203
 204     lock = Lock("SYS:Devs", SHARED_LOCK);
 205
 206     if (lock != NULL)
 207     {
 208         AssignLock("DEVS", lock);
 209     }
 210
 211     lock = Lock("DEVS:Drivers", SHARED_LOCK);
 212
 213     if (lock != NULL)
 214     {
 215         AssignLock("DRIVERS", lock);
 216         AssignAdd("LIBS", lock);        /* Let hidds in DRIVERS: directory be found by OpenLibrary */
 217     }
 218
 219     /* Late binding ENVARC: assign, only if used */
 220     AssignLate("ENVARC", "SYS:Prefs/env-archive");
 221
 222     /* Initialize HIDDs */
 223     init_hidds(SysBase, (struct DosLibrary *)DOSBase);
 224
 225     /* We now call the system dependant boot - should never return. */
 226     AROS_UFC3(void, boot,
 227               AROS_UFCA(STRPTR, argString, A0),
 228               AROS_UFCA(ULONG, argSize, D0),
 229               AROS_UFCA(struct ExecBase *, SysBase, A6));
 230
 231 #   undef deviceName
 232
 233     AROS_USERFUNC_EXIT
 234 }
 235
 236 void DOSBoot(struct ExecBase *SysBase, struct DosLibrary *DOSBase)
 237 {
 238     struct TagItem bootprocess[] =
 239     {
 240         { NP_Entry,      (IPTR) intBoot },
 241         { NP_Name,       (IPTR) "Boot Process" },
 242         { NP_Input,      (IPTR) NULL },
 243         { NP_Output,     (IPTR) NULL },
 244         { NP_CurrentDir, (IPTR) NULL },
 245         { NP_StackSize, AROS_STACKSIZE * 2},
 246         { NP_Cli,        (IPTR) 0 },
 247         { TAG_END, }
 248     };
 249
 250     if( CreateNewProc( bootprocess ) == NULL )
 251     {
 252         D(bug
 253         (
 254             "CreateNewProc() failed with %ld\n",
 255             ((struct Process *) FindTask( NULL ))->pr_Result2
 256         ));
 257         Alert( AT_DeadEnd | AN_DOSLib | AG_ProcCreate );
 258     }
 259 }
 260
 261 BOOL mount( struct DeviceNode *dn, struct DosLibrary * DOSBase )
 262 {
 263     struct FileSysStartupMsg *fssm = BADDR(dn->dn_Startup);
 264     struct IOFileSys         *iofs;
 265     struct MsgPort           *mp = CreateMsgPort();
 266     BOOL                      rc = FALSE;
 267
 268     if (mp != NULL)
 269     {
 270         iofs = (struct IOFileSys *)CreateIORequest(mp,
 271                                                    sizeof(struct IOFileSys));
 272         if (iofs != NULL)
 273         {
 274             iofs->io_Union.io_OpenDevice.io_DeviceName = AROS_BSTR_ADDR(fssm->fssm_Device);
 275             iofs->io_Union.io_OpenDevice.io_Unit       = fssm->fssm_Unit;
 276             iofs->io_Union.io_OpenDevice.io_Environ    = BADDR(fssm->fssm_Environ);
 277             iofs->io_Union.io_OpenDevice.io_DosName    = dn->dn_NewName;
 278             if (!OpenDevice(AROS_BSTR_ADDR(dn->dn_Handler), 0, &iofs->IOFS, 0))
 279             {
 280                 if (AddDosEntry((struct DosList *) dn))
 281                 {
 282                     dn->dn_Unit = iofs->IOFS.io_Unit;
 283                     dn->dn_Device = iofs->IOFS.io_Device;
 284                     /* Do not close filesys !!! */
 285                     rc = TRUE;
 286                 }
 287             }
 288
 289             DeleteIORequest((struct IORequest *)iofs);
 290         }
 291         else
 292         {
 293             Alert(AT_DeadEnd | AG_NoMemory | AN_DOSLib);
 294         }
 295
 296         DeleteMsgPort(mp);
 297     }
 298     else
 299     {
 300         Alert(AT_DeadEnd | AG_NoMemory | AN_DOSLib);
 301     }
 302
 303     return rc;
 304 }
 305
 306 BOOL isBootable( CONST_STRPTR deviceName, struct DosLibrary * DOSBase )
 307 {
 308     BOOL            result = FALSE;
 309     BPTR            lock;
 310     STRPTR          buffer;
 311     LONG            bufferLength;
 312     struct InfoData info;
 313
 314     #define STARTUP_SEQUENCE_FILE ":S/Startup-Sequence"
 315
 316     bufferLength = strlen( deviceName ) + sizeof(STARTUP_SEQUENCE_FILE) + 1;
 317
 318     if( (buffer = AllocMem( bufferLength, MEMF_ANY ) ) == NULL )
 319     {
 320         Alert( AT_DeadEnd | AG_NoMemory | AN_DOSLib );
 321     }
 322
 323     strcpy( buffer, deviceName );
 324     strcat( buffer, STARTUP_SEQUENCE_FILE );
 325
 326     if( (lock = Lock( buffer, SHARED_LOCK )) == 0 )
 327     {
 328         D(bug( "dosboot: could not lock '%s'\n", buffer ));
 329         goto cleanup;
 330     }
 331
 332     if( !Info( lock, &info ) )
 333     {
 334         D(bug( "dosboot: could not get info on '%s'\n", buffer ));
 335         goto cleanup;
 336     }
 337
 338     if( info.id_DiskType != ID_NO_DISK_PRESENT )
 339     {
 340         result = TRUE;
 341     }
 342
 343 cleanup:
 344     if( buffer != NULL ) FreeMem( buffer, bufferLength );
 345     if( lock   != 0    ) UnLock( lock );
 346
 347     return result;
 348 }