Ho molti dubbi su quello che accade durante l'avvio di un calcolatore (fase di boot?). Da quello che ho capito l'alimentazione attiva il BIOS che è un programma salvato su una memoria di ROM, il quale forza il processore a caricare nel program counter l'indirizzo dell'istruzione relativa al sistema operativo. Ho capito io male? Il "loader" che ha il compito di caricare i programmi in memoria, che ruolo ha in tutto questo?
Il BIOS fa una prima inizializzazione dell'hardware e cerca un dispositivo da cui effettuare il boot; a seconda del dispositivo specifico, va a cercare in un punto particolare il codice da eseguire per effettuare il boot. Nel caso dei dischi rigidi, si tratta solitamente dell'MBR (i primi 512 byte del disco), che contiene il codice di bootstrap e il layout delle partizioni. Il codice di avvio viene quindi caricato ad un particolare indirizzo di memoria, e il processore viene impostato per eseguirlo.
Lo spazio riservato al bootloader nell'MBR è solo 446 byte, per cui tipicamente tutto ciò che fa è andare a recuperare altrove il bootloader "vero" altrove. Nel caso di Windows pre-Vista, di fatto sceglie tra le partizioni la prima ad essere marcata come "attiva" e "di boot" (se non ricordo male), carica il relativo volume boot record in memoria e lo esegue. Questo normalmente ha meno constraint a livello di dimensioni, e può quindi fare cose più complicate; tipicamente carica in memoria il codice di avvio del sistema operativo, che si occuperà di impostare il processore nella modalità corretta (il processore parte in real mode, mentre i sistemi moderni lavorano in protected mode o in long mode se a 64 bit) e che include normalmente un primo mini-driver per poter leggere il file system, da cui carica i file di sistema (driver & co.) con cui prosegue nel boot del sistema operativo.
Nel caso di sistemi Linux e di bootloader "complicati" come GRUB spesso l'MBR non fa altro che avviare lo "stage" successivo del bootloader, che già di suo è quasi un mini-sistema operativo che contiene, tra le altre cose, driver per filesystem vari; per questo motivo, GRUB è in grado di caricare il codice di avvio del sistema operativo in maniera più flessibile - dal chainloading (si limita a passare il controllo al VBR di un certo volume, tipico quando deve avviare Windows) all'occuparsi da sé di leggere da filesystem e caricare in memoria immagini di kernel e farle partire, passandoci eventuali parametri (cosa che avviene normalmente in caso di boot di sistemi Linux).
In ogni caso, trovi approfondimenti di vario genere su Wikipedia:
http://en.wikipedia.org/wiki/Master_..._bootstrapping
http://en.wikipedia.org/wiki/Boot_lo...n_boot_loaders
http://en.wikipedia.org/wiki/Volume_Boot_Record
http://en.wikipedia.org/wiki/NTLDR
http://en.wikipedia.org/wiki/Windows_NT_startup_process
http://en.wikipedia.org/wiki/GRUB
Trovi anche molte informazioni e riferimenti dettagliati su osdev.org, partendo ad esempio da qui.
---
Il loader a cui ti riferisci credo sia quello usato dal sistema operativo per caricare immagini eseguibili (tipicamente eseguibili e librerie dinamiche) "a sistema caricato"; in questi primi stadi di avvio del sistema non dovrebbe c'entrare nulla (c'entra in seguito quando ci sono, appunto, da caricare eseguibili, anche se in alcuni sistemi operativi i driver condividono in parte il formato delle normali dll, per cui parte del loader potrebbe essere la stessa anche qui).
Amaro C++, il gusto pieno dell'undefined behavior.
Grazie, volendo riassumere il tutto, all'avvio del sistema cosa viene caricato per prima? Nell'ottica del ciclo del processore, quali sono le condizioni per cui abbia inizio? Cosa centra il loader con il BIOS? La prima istruzione da prelevare per iniziare il ciclo da dove viene presa?
Scusa per le troppe domande ma l'argomento non mi è molto chiaro
Il BIOS, che è mappato nell'area di memoria dove il processore inizia ad eseguire istruzioni appena viene acceso.Originariamente inviato da djanthony93
Grazie, volendo riassumere il tutto, all'avvio del sistema cosa viene caricato per prima? Nell'ottica del ciclo del processore, quali sono le condizioni per cui abbia inizio?
Per i dettagli, vedi qui: http://en.wikipedia.org/wiki/BIOS#The_BIOS_boot_process
Ci sono più loader in ballo...Cosa centra il loader con il BIOS?
Il codice del BIOS (eseguito dal processore) si occupa di copiare in memoria il settore di avvio del dispositivo scelto per il boot all'indirizzo 0x0000:0x7c00, e quindi fa un JMP a questa locazione di memoria, per cui inizia ad eseguire il codice del settore di avvio. Questo codice tipicamente va a pescare altrove il loader del sistema operativo vero e proprio.
Amaro C++, il gusto pieno dell'undefined behavior.
Quindi all'avvio il processore esegue il BIOS, il quale fa partire il boot e il loader che poi farà partire il sistema operativo? Ho capito bene?
Il mio professore non è entrato nel dettaglio, si è limitato a dirci solo come il ciclo del processore inizia all'avvio, la prima istruzione che viene prelevata durante la fase fetch è quella del BIOS? E quindi quest'ultimo fa partire il sistema operativo?
Grazie ancora e per la pazienza
Sostanzialmente sì. Il processore parte, appena acceso, parte da un certo indirizzo di memoria, dove si trova il BIOS, che inizializza le periferiche e recupera (dal disco, da un floppy, da una chiavetta USB, ...) il settore di avvio. Lo piazza ad un certo indirizzo e fa un JMP a questo indirizzo.Originariamente inviato da djanthony93
Quindi all'avvio il processore esegue il BIOS, il quale fa partire il boot e il loader che poi farà partire il sistema operativo? Ho capito bene?
Questo a sua volta carica il loader vero e proprio (o un boot manager di qualche genere) che carica in memoria ed esegue il kernel del sistema operativo.
Questo comunque vale in genere per sistemi operativi "veri", è anche possibile scrivere un settore di avvio che non fa altro che stampare a schermo "il mattino ha l'oro in bocca".
Amaro C++, il gusto pieno dell'undefined behavior.
Grazie mille, solo un passaggio non mi è chiaro:
Chi piazza chi?Lo piazza ad un certo indirizzo e fa un JMP a questo indirizzo.
Il codice del BIOS carica il settore di avvio in memoria.
Amaro C++, il gusto pieno dell'undefined behavior.
Piazza il settore d'avvio ad un certo indirizzo ed obbliga il processore a prelevare la sua prima istruzione dopo l'avvio da quell'indirizzo, è giusto?
Sì, comunque per il processore non è nulla di che: semplicemente il codice che sta eseguendo - quello del BIOS - contiene ad un certo punto un JMP all'indirizzo di memoria dove è appena stato caricato il settore di avvio.
---EDIT---
Ad esempio, qui si vede bene.
Amaro C++, il gusto pieno dell'undefined behavior.
Permessi di invio
Rispondi quotando