rom/dos/dosboot.c

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