Skip to content Skip to sidebar Skip to footer
Home / Which Option Should Be Enabled in Order to View What Did and Did Not Load During the Bootup?

Which Option Should Be Enabled in Order to View What Did and Did Not Load During the Bootup?

Post a Comment

Process of starting a computer

"Quick kicking" redirects hither. For the feature of the Quarterdeck memory manager, run into Quickboot (QEMM).

This article is about bootstrapping operating systems. For the full general concept, see Bootstrapping.

A catamenia diagram of a reckoner booting

In computing, booting is the process of starting a computer as initiated via hardware such as a push or by a software command. Afterwards it is switched on, a computer's key processing unit (CPU) has no software in its main memory, so some process must load software into memory before it can be executed. This may be done by hardware or firmware in the CPU, or by a separate processor in the computer organisation.

Restarting a figurer also is called rebooting, which can be "hard", e.thou. later electrical power to the CPU is switched from off to on, or "soft", where the power is not cut. On some systems, a soft boot may optionally clear RAM to nix. Both difficult and soft booting can be initiated by hardware such as a push printing or by a software command. Booting is complete when the operative runtime system, typically the operating system and some applications,[nb 1] is attained.

The procedure of returning a computer from a country of slumber (suspension) does not involve booting; however, restoring information technology from a country of hibernation does. Minimally, some embedded systems exercise not crave a noticeable boot sequence to brainstorm functioning and when turned on may simply run operational programs that are stored in ROM. All calculating systems are state machines, and a reboot may be the only method to return to a designated goose egg-state from an unintended, locked country.

In add-on to loading an operating system or stand up-alone utility, the boot process can also load a storage dump program for diagnosing problems in an operating arrangement.

Boot is short for bootstrap [1] [two] or bootstrap load and derives from the phrase to pull oneself upwardly by i's bootstraps.[3] [4] The usage calls attention to the requirement that, if nigh software is loaded onto a computer by other software already running on the computer, some mechanism must exist to load the initial software onto the computer.[five] Early computers used a variety of ad-hoc methods to get a small program into memory to solve this problem. The invention of read-only retentivity (ROM) of various types solved this paradox by allowing computers to be shipped with a start upwardly program that could not be erased. Growth in the capacity of ROM has immune e'er more elaborate start upwards procedures to be implemented.

History [edit]

Switches and cables used to program ENIAC (1946)

At that place are many different methods available to load a short initial program into a computer. These methods reach from simple, concrete input to removable media that tin hold more complex programs.

Pre integrated-excursion-ROM examples [edit]

Early on computers [edit]

Early computers in the 1940s and 1950s were 1-of-a-kind engineering efforts that could take weeks to plan and program loading was ane of many bug that had to be solved. An early computer, ENIAC, had no programme stored in retentivity, but was gear up up for each problem by a configuration of interconnecting cables. Bootstrapping did not apply to ENIAC, whose hardware configuration was ready for solving problems equally soon every bit power was applied.

The EDSAC organisation, the 2nd stored-plan computer to be congenital, used stepping switches to transfer a stock-still program into retentiveness when its offset button was pressed. The program stored on this device, which David Wheeler completed in tardily 1948, loaded further instructions from punched tape and then executed them.[half-dozen] [vii]

First commercial computers [edit]

The first programmable computers for commercial sale, such as the UNIVAC I and the IBM 701[eight] included features to make their operation simpler. They typically included instructions that performed a complete input or output operation. The same hardware logic could be used to load the contents of a punch carte du jour (the virtually typical ones) or other input media, such as a magnetic pulsate or magnetic tape, that independent a bootstrap program by pressing a unmarried button. This booting concept was called a diverseness of names for IBM computers of the 1950s and early 1960s, but IBM used the term "Initial Program Load" with the IBM 7030 Stretch[nine] and later used it for their mainframe lines, starting with the System/360 in 1964.

Initial program load punched carte du jour for the IBM 1130 (1965)

The IBM 701 computer (1952–1956) had a "Load" button that initiated reading of the first 36-bit word into chief memory from a punched card in a card reader, a magnetic tape in a tape drive, or a magnetic drum unit, depending on the position of the Load Selector switch. The left 18-chip half-give-and-take was then executed as an instruction, which usually read additional words into memory.[ten] [11] The loaded boot program was so executed, which, in turn, loaded a larger program from that medium into retentiveness without farther help from the human operator. The term "boot" has been used in this sense since at least 1958.[12]

IBM System/3 console from the 1970s. Program load selector switch is lower left; Program load switch is lower right.

Other IBM computers of that era had similar features. For example, the IBM 1401 system (c. 1958) used a card reader to load a program from a punched menu. The fourscore characters stored in the punched card were read into retentiveness locations 001 to 080, and so the computer would branch to memory location 001 to read its kickoff stored instruction. This teaching was ever the same: move the information in these showtime 80 memory locations to an assembly area where the information in punched cards two, three, 4, and then on, could exist combined to form the stored program. Once this information was moved to the assembly surface area, the motorcar would branch to an instruction in location 080 (read a carte du jour) and the next card would be read and its data processed.

Another example was the IBM 650 (1953), a decimal machine, which had a grouping of ten 10-position switches on its operator panel which were addressable as a memory word (accost 8000) and could be executed as an instruction. Thus setting the switches to 7004000400 and pressing the appropriate push button would read the beginning card in the card reader into retention (op lawmaking 70), starting at accost 400 and and so jump to 400 to brainstorm executing the program on that carte du jour.[13]

IBM's competitors likewise offered unmarried push programme load.

  • The CDC 6600 (c. 1964) had a dead start panel with 144 toggle switches; the dead start switch entered 12 words from the toggle switches to the memory of peripheral processor (PP) 0 and initiated the load sequence. PP 0 loaded the necessary code into its own memory and then initialized the other PPs.
  • The GE 645 (c. 1965) had a "System BOOTLOAD" push button that, when pressed, caused one of the I/O controllers to load a 64-word program into retentiveness from a diode read-only memory and deliver an interrupt to cause that program to start running.[fourteen]
  • The first model of the PDP-10 had a "READ IN" push that, when pressed, reset the processor and started an I/O performance on a device specified past switches on the control panel, reading in a 36-bit give-and-take giving a target accost and count for subsequent word reads; when the read completed, the processor started executing the code read in by jumping to the last word read in.[15]

A noteworthy variation of this is found on the Burroughs B1700 where there is neither a bootstrap ROM nor a hardwired IPL operation. Instead, after the organization is reset it reads and executes opcodes sequentially from a record bulldoze mounted on the front panel; this sets upwardly a kicking loader in RAM which is so executed. However, since this makes few assumptions about the organisation it tin equally well exist used to load diagnostic (Maintenance Test Routine) tapes which display an intelligible code on the front panel even in cases of gross CPU failure.

IBM System/360 and successors [edit]

In the IBM System/360 and its successors, including the electric current z/Compages machines, the kick process is known equally Initial Program Load (IPL).

IBM coined this term for the 7030 (Stretch),[9] revived it for the design of the Arrangement/360, and continues to use it in those environments today.[16] In the System/360 processors, an IPL is initiated past the computer operator by selecting the three hexadecimal digit device address (CUU; C=I/O Channel accost, UU=Control unit and Device accost[nb 2]) followed past pressing the LOAD button. On the high end System/360 models, most[nb 3] Organisation/370 and some later systems, the functions of the switches and the LOAD push are simulated using selectable areas on the screen of a graphics console, often[nb 4] an IBM 2250-like device or an IBM 3270-similar device. For instance, on the System/370 Model 158, the keyboard sequence 0-7-10 (zippo, vii and X, in that order) results in an IPL from the device address which was keyed into the input surface area. The Amdahl 470V/6 and related CPUs supported 4 hexadecimal digits on those CPUs which had the optional 2d aqueduct unit of measurement installed, for a total of 32 channels. After, IBM would also support more than 16 channels.

The IPL function in the System/360 and its successors prior to IBM Z, and its compatibles such as Amdahl'south, reads 24 bytes from an operator-specified device into main storage starting at existent accost null. The second and third groups of eight bytes are treated as Channel Control Words (CCWs) to continue loading the startup program (the outset CCW is always faux past the CPU and consists of a Read IPL command, 02h, with control chaining and suppress incorrect length indication being enforced). When the I/O channel commands are complete, the first group of eight bytes is so loaded into the processor's Program Status Word (PSW) and the startup programme begins execution at the location designated past that PSW.[16] The IPL device is usually a deejay bulldoze, hence the special significance of the 02h read-blazon control, but exactly the same procedure is also used to IPL from other input-type devices, such as tape drives, or even carte du jour readers, in a device-contained manner, allowing, for case, the installation of an operating system on a brand-new computer from an OS initial distribution magnetic tape. For deejay controllers, the 02h command also causes the selected device to seek to cylinder 0000h, head 0000h, simulating a Seek cylinder and head command, 07h, and to search for record 01h, simulating a Search ID Equal command, 31h; seeks and searches are not simulated by record and card controllers, as for these device classes a Read IPL command is simply a sequential read control.

The deejay, tape or menu deck must contain a special program to load the actual operating system or standalone utility into master storage, and for this specific purpose "IPL Text" is placed on the disk past the stand-solitary DASDI (Direct Access Storage Device Initialization) program or an equivalent programme running under an operating organization, eastward.g., ICKDSF, but IPL-able tapes and card decks are usually distributed with this "IPL Text" already present.

IBM introduced some evolutionary changes in the IPL process, changing some details for System/370 Extended Compages (S/370-XA) and later, and calculation a new blazon of IPL for z/Architecture.

Minicomputers [edit]

PDP-8/Due east front panel showing the switches used to load the bootstrap program

Minicomputers, starting with the Digital Equipment Corporation (Dec) PDP-5 and PDP-viii (1965) simplified design by using the CPU to assist input and output operations. This saved toll simply made booting more complicated than pressing a single button. Minicomputers typically had some way to toggle in short programs by manipulating an array of switches on the front panel. Since the early minicomputers used magnetic cadre memory, which did non lose its data when power was off, these bootstrap loaders would remain in place unless they were erased. Erasure sometimes happened accidentally when a programme problems acquired a loop that overwrote all of memory.

Other minicomputers with such simple form of booting include Hewlett-Packard's HP 2100 serial (mid-1960s), the original Data Full general Nova (1969), and DEC'due south PDP-11 (1970).

Dec afterwards added an optional diode matrix read-just retention for the PDP-11 that stored a bootstrap program of up to 32 words (64 bytes). It consisted of a printed circuit card, the M792, that plugged into the Unibus and held a 32 by xvi array of semiconductor diodes. With all 512 diodes in identify, the memory contained all "1" bits; the card was programmed by cutting off each diode whose flake was to be "cypher". December also sold versions of the bill of fare, the BM792-Yx serial, pre-programmed for many standard input devices by only omitting the unneeded diodes.[17]

Post-obit the older approach, the before PDP-one has a hardware loader, such that an operator need simply push the "load" switch to instruct the paper tape reader to load a program directly into core retentiveness. The Information Full general Supernova used front panel switches to crusade the figurer to automatically load instructions into retentivity from a device specified by the front panel's information switches, and then leap to loaded lawmaking; the Nova 800 and 1200 had a switch that loaded a program into main memory from a special read-only memory and jumped to it.[18]

Early minicomputer boot loader examples [edit]

In a minicomputer with a paper tape reader, the first plan to run in the boot process, the boot loader, would read into core memory either the 2nd-stage kick loader (often called a Binary Loader) that could read paper tape with checksum or the operating arrangement from an outside storage medium. Pseudocode for the kick loader might be as elementary equally the post-obit 8 instructions:

  1. Set the P register to ix
  2. Check paper tape reader ready
  3. If not prepare, jump to 2
  4. Read a byte from paper record reader to accumulator
  5. Shop accumulator to address in P register
  6. If terminate of tape, jump to 9
  7. Increment the P annals
  8. Spring to 2

A related example is based on a loader for a Nicolet Instrument Corporation minicomputer of the 1970s, using the newspaper tape reader-punch unit on a Teletype Model 33 ASR teleprinter. The bytes of its 2d-stage loader are read from paper tape in reverse society.

  1. Gear up the P register to 106
  2. Check paper record reader ready
  3. If not ready, jump to 2
  4. Read a byte from newspaper record reader to accumulator
  5. Shop accumulator to address in P register
  6. Decrement the P annals
  7. Leap to 2

The length of the second stage loader is such that the last byte overwrites location 7. Subsequently the didactics in location 6 executes, location seven starts the second stage loader executing. The second stage loader then waits for the much longer record containing the operating system to exist placed in the record reader. The difference between the boot loader and second stage loader is the addition of checking code to trap paper tape read errors, a frequent occurrence with relatively low-cost, "role-fourth dimension-duty" hardware, such as the Teletype Model 33 ASR. (Friden Flexowriters were far more reliable, only as well comparatively costly.)

Booting the first microcomputers [edit]

The earliest microcomputers, such every bit the Altair 8800 (released get-go in 1975) and an even earlier, like machine (based on the Intel 8008 CPU) had no bootstrapping hardware as such.[19] When started, the CPU would meet memory that would contain executable code containing only binary zeros—retentivity was cleared by resetting when powering up. The front end panels of these machines carried toggle switches for inbound addresses and information, i switch per bit of the estimator memory word and address autobus. Simple additions to the hardware permitted i retentivity location at a time to be loaded from those switches to store bootstrap code. Meanwhile, the CPU was kept from attempting to execute memory content. Once correctly loaded, the CPU was enabled to execute the bootstrapping lawmaking. This process was wearisome and had to be mistake-costless.[20]

Integrated excursion read-only memory era [edit]

An Intel 2708 EPROM "chip" on a circuit board.

The boot process for minicomputers and microcomputers[nb 5] was revolutionized past the introduction of integrated circuit read-but retention (ROM), with its many variants, including mask-programmed ROMs, programmable ROMs (PROM), erasable programmable ROMs (EPROM), and flash memory. These immune firmware boot programs to exist included as part of the figurer. The introduction of an (external) ROM was in an Italian phone switching elaborator, called "Gruppi Speciali", patented in 1975 by Alberto Ciaramella, a researcher at CSELT.[21] Gruppi Speciali was, starting from 1975, a fully single-button automobile booting into the operating system from a ROM retention composed from semiconductors, not from ferrite cores. Although the ROM device was not natively embedded in the figurer of Gruppi Speciali, due to the design of the machine, it also allowed the single-push button ROM booting in machines not designed for that (therefore, this "bootstrap device" was architecture-independent), east.g. the PDP-xi. Storing the country of the machine after the switch-off was as well in place, which was another disquisitional feature in the telephone switching competition.[22]

Typically, every microprocessor volition, subsequently a reset or power-on condition, perform a kickoff-upward process that normally takes the form of "begin execution of the lawmaking that is found starting at a specific address" or "look for a multibyte code at a specific address and leap to the indicated location to begin execution". A system built using that microprocessor will have the permanent ROM occupying these special locations so that the system always begins operating without operator help. For example, Intel x86 processors always start past running the instructions offset at F000:FFF0,[23] [24] while for the MOS 6502 processor, initialization begins by reading a two-byte vector address at $FFFD (MS byte) and $FFFC (LS byte) and jumping to that location to run the bootstrap code.[25]

Apple tree Inc.'southward first figurer, the Apple tree one introduced in 1976, featured PROM chips that eliminated the need for a forepart console for the boot process (as was the case with the Altair 8800) in a commercial computer. According to Apple'due south ad announcing it "No More Switches, No More than Lights ... the firmware in PROMS enables you to enter, display and debug programs (all in hex) from the keyboard."[26]

Due to the expense of read-just memory at the fourth dimension, the Apple Two series booted its disk operating systems using a series of very small incremental steps, each passing command onward to the next phase of the gradually more than circuitous boot process. (Meet Apple tree DOS: Boot loader). Because so lilliputian of the disk operating arrangement relied on ROM, the hardware was also extremely flexible and supported a wide range of customized disk copy protection mechanisms. (Encounter Software Cracking: History.)

Some operating systems, nigh notably pre-1995 Macintosh systems from Apple, are so closely interwoven with their hardware that information technology is impossible to natively boot an operating organisation other than the standard ane. This is the reverse extreme of the scenario using switches mentioned above; it is highly inflexible just relatively mistake-proof and foolproof every bit long as all hardware is working commonly. A common solution in such situations is to design a boot loader that works as a program belonging to the standard Bone that hijacks the system and loads the alternative Bone. This technique was used by Apple for its A/UX Unix implementation and copied by various freeware operating systems and BeOS Personal Edition 5.

Some machines, similar the Atari ST microcomputer, were "instant-on", with the operating system executing from a ROM. Retrieval of the Bone from secondary or tertiary shop was thus eliminated as one of the characteristic operations for bootstrapping. To allow system customizations, accessories, and other support software to be loaded automatically, the Atari's floppy drive was read for boosted components during the boot procedure. There was a timeout delay that provided time to manually insert a floppy as the system searched for the extra components. This could be avoided by inserting a blank deejay. The Atari ST hardware was also designed so the cartridge slot could provide native program execution for gaming purposes equally a holdover from Atari's legacy making electronic games; past inserting the Spectre GCR cartridge with the Macintosh organization ROM in the game slot and turning the Atari on, it could "natively boot" the Macintosh operating system rather than Atari'south ain TOS.

The IBM Personal Computer included ROM-based firmware called the BIOS; one of the functions of that firmware was to perform a power-on self exam when the machine was powered up, and and so to read software from a boot device and execute it. Firmware uniform with the BIOS on the IBM Personal Estimator is used in IBM PC compatible computers. The UEFI was adult by Intel, originally for Itanium-based machines, and later also used equally an alternative to the BIOS in x86-based machines, including Apple Macs using Intel processors.

Unix workstations originally had vendor-specific ROM-based firmware. Lord's day Microsystems later developed OpenBoot, later known equally Open Firmware, which incorporated a Forth interpreter, with much of the firmware existence written in Along. It was standardized by the IEEE as IEEE standard 1275-1994; firmware that implements that standard was used in PowerPC-based Macs and some other PowerPC-based machines, as well equally Dominicus's own SPARC-based computers. The Advanced RISC Computing specification defined some other firmware standard, which was implemented on some MIPS-based and Alpha-based machines and the SGI Visual Workstation x86-based workstations.

Modern boot loaders [edit]

When a computer is turned off, its software‍—‌including operating systems, awarding code, and data‍—‌remains stored on not-volatile memory. When the computer is powered on, it typically does not have an operating organisation or its loader in random-access retentiveness (RAM). The computer first executes a relatively small program stored in read-only memory (ROM, and later EEPROM, NOR flash) along with some needed data, to initialize RAM (particularly on x86 systems), to access the nonvolatile device (commonly block device, e.g. NAND flash) or devices from which the operating organization programs and information can be loaded into RAM.

The small program that starts this sequence is known as a bootstrap loader, bootstrap or kick loader. Ofttimes, multiple-stage boot loaders are used, during which several programs of increasing complexity load one after the other in a process of chain loading.

Some earlier estimator systems, upon receiving a boot indicate from a human operator or a peripheral device, may load a very small number of fixed instructions into memory at a specific location, initialize at least 1 CPU, and and so point the CPU to the instructions and beginning their execution. These instructions typically commencement an input operation from some peripheral device (which may be switch-selectable by the operator). Other systems may transport hardware commands direct to peripheral devices or I/O controllers that crusade an extremely unproblematic input functioning (such as "read sector nil of the organization device into memory starting at location grand") to be carried out, effectively loading a small number of kick loader instructions into retentivity; a completion signal from the I/O device may then be used to start execution of the instructions past the CPU.

Smaller computers often use less flexible just more automatic boot loader mechanisms to ensure that the reckoner starts quickly and with a predetermined software configuration. In many desktop computers, for case, the bootstrapping process begins with the CPU executing software contained in ROM (for case, the BIOS of an IBM PC) at a predefined address (some CPUs, including the Intel x86 series are designed to execute this software later reset without outside assist). This software contains rudimentary functionality to search for devices eligible to participate in booting, and load a modest program from a special section (nearly unremarkably the kicking sector) of the almost promising device, typically starting at a stock-still entry betoken such equally the starting time of the sector.

Kicking loaders may face peculiar constraints, peculiarly in size; for instance, on the IBM PC and compatibles, the boot code must fit in the Master Boot Tape (MBR) and the Partition Kick Record (PBR), which in turn are limited to a unmarried sector; on the IBM System/360, the size is limited by the IPL medium, e.g., menu size, track size.

On systems with those constraints, the first programme loaded into RAM may not be sufficiently large to load the operating system and, instead, must load another, larger program. The starting time plan loaded into RAM is called a first-phase kick loader, and the program it loads is called a 2d-stage boot loader.

First-stage boot loader [edit]

Examples of first-phase (Hardware initialization stage) bootloaders include BIOS, UEFI, coreboot, Libreboot and Das U-Kicking. On the IBM PC, the kicking loader in the Master Boot Record (MBR) and the Partition Boot Record (PBR) was coded to require at least 32 KB[27] [28] (later tightened to 64 KB[29]) of system memory and but use instructions supported past the original 8088/8086 processors.

Second-phase kick loader [edit]

2nd-stage (Bone initialization stage) boot loaders, such as GNU Grub, rEFInd, BOOTMGR, Syslinux, NTLDR or iBoot, are not themselves operating systems, but are able to load an operating system properly and transfer execution to it; the operating system afterwards initializes itself and may load actress device drivers. The second-stage boot loader does not need drivers for its ain functioning, but may instead use generic storage access methods provided by system firmware such as the BIOS, UEFI or Open Firmware, though typically with restricted hardware functionality and lower functioning.[30]

Many boot loaders (like GNU GRUB, rEFInd, Windows'due south BOOTMGR, Syslinux, and Windows NT/2000/XP'due south NTLDR) tin can exist configured to give the user multiple booting choices. These choices tin can include different operating systems (for dual or multi-booting from dissimilar partitions or drives), different versions of the same operating system (in case a new version has unexpected problems), different operating system loading options (e.g., booting into a rescue or safe mode), and some standalone programs that can function without an operating organisation, such as retentiveness testers (e.g., memtest86+), a basic shell (as in GNU Grub), or even games (see List of PC Booter games).[31] Some boot loaders can also load other boot loaders; for example, GRUB loads BOOTMGR instead of loading Windows directly. Usually a default choice is preselected with a time delay during which a user can press a key to change the choice; after this delay, the default choice is automatically run then normal booting can occur without interaction.

The boot process can exist considered complete when the computer is prepare to interact with the user, or the operating organisation is capable of running organisation programs or awarding programs.

Many embedded systems must boot immediately. For example, waiting a minute for a digital television or a GPS navigation device to start is generally unacceptable. Therefore, such devices have software systems in ROM or flash memory so the device tin brainstorm performance immediately; fiddling or no loading is necessary, because the loading can be precomputed and stored on the ROM when the device is made.

Large and complex systems may take kick procedures that continue in multiple phases until finally the operating organization and other programs are loaded and ready to execute. Because operating systems are designed as if they never start or cease, a boot loader might load the operating organization, configure itself equally a mere process inside that arrangement, and then irrevocably transfer command to the operating arrangement. The boot loader and so terminates unremarkably as any other process would.

Network booting [edit]

Near computers are also capable of booting over a computer network. In this scenario, the operating system is stored on the disk of a server, and sure parts of information technology are transferred to the client using a elementary protocol such as the Trivial File Transfer Protocol (TFTP). After these parts take been transferred, the operating arrangement takes over the command of the booting procedure.

Equally with the second-phase kick loader, network booting begins by using generic network access methods provided past the network interface's kick ROM, which typically contains a Preboot Execution Surround (PXE) paradigm. No drivers are required, just the organisation functionality is limited until the operating system kernel and drivers are transferred and started. As a outcome, once the ROM-based booting has completed it is entirely possible to network boot into an operating arrangement that itself does not accept the ability to use the network interface.

Personal computers (PC) [edit]

Kick devices [edit]

The boot device is the device from which the operating system is loaded. A modern PC's UEFI or BIOS firmware supports booting from diverse devices, typically a local solid state drive or difficult disk drive via the GPT or Principal Boot Record (MBR) on such a drive or disk, an optical disc drive (using El Torito), a USB mass storage device (FTL-based flash drive, SD card or multi-media carte du jour slot, USB hard disk drive, USB optical disc bulldoze, etc.), or a network interface card (using PXE). Older, less common BIOS-bootable devices include floppy disk drives, Zip drives, and LS-120 drives.

Typically, the arrangement firmware (UEFI or BIOS) will allow the user to configure a boot club. If the kick order is gear up to "starting time, the DVD drive; second, the hd", then the firmware volition try to boot from the DVD drive, and if this fails (e.one thousand. because in that location is no DVD in the bulldoze), it will try to boot from the local hard disk bulldoze.

For case, on a PC with Windows installed on the hard drive, the user could set up the boot guild to the ane given in a higher place, and so insert a Linux Alive CD in society to try out Linux without having to install an operating system onto the difficult drive. This is an case of dual booting, in which the user chooses which operating system to offset afterwards the figurer has performed its Power-on cocky-test (Mail). In this instance of dual booting, the user chooses by inserting or removing the DVD from the computer, but information technology is more common to choose which operating system to kicking by selecting from a boot director menu on the selected device, by using the computer keyboard to select from a BIOS or UEFI Boot Card, or both; the Boot Card is typically entered by pressing F8 or F12 keys during the POST; the BIOS Setup is typically entered by pressing F2 or DEL keys during the Mail.[32] [33]

Several devices are available that enable the user to quick-boot into what is normally a variant of Linux for various simple tasks such as Internet access; examples are Splashtop and Latitude ON.[34] [35] [36]

Boot sequence [edit]

Upon starting, an IBM-compatible personal reckoner'due south x86 CPU, executes in real mode, the instruction located at reset vector (the physical retentivity address FFFF0h on 16-flake x86 processors[37] and FFFFFFF0h on 32-scrap and 64-bit x86 processors[38] [39]), usually pointing to the firmware (UEFI or BIOS) entry point inside the ROM. This memory location typically contains a jump instruction that transfers execution to the location of the firmware (UEFI or BIOS) start-up programme. This program runs a power-on self-test (POST) to check and initialize required devices such as master memory (DRAM), the PCI bus and the PCI devices (including running embedded Option ROMs). One of the most involved steps is setting up DRAM over SPD, further complicated by the fact that at this indicate memory is very limited.

After initializing required hardware, the firmware (UEFI or BIOS) goes through a pre-configured list of non-volatile storage devices ("boot device sequence") until it finds one that is bootable. A bootable MBR device is defined as ane that can exist read from, and where the last 2 bytes of the showtime sector contain the picayune-endian word AA55h,[nb vi] found as byte sequence 55h, AAh on disk (as well known equally the MBR kicking signature), or where it is otherwise established that the code inside the sector is executable on x86 PCs.

Once the BIOS has found a bootable device it loads the boot sector to linear address 7C00h (usually segment:kickoff 0000h:7C00h,[27] but some BIOSes erroneously utilise 07C0h:0000h [ citation needed ]) and transfers execution to the kicking code. In the case of a hard disk, this is referred to as the Master Kicking Record (MBR). The conventional MBR code checks the MBR's partition tabular array for a sectionalization set as bootable [nb 7] (the one with active flag set up). If an active partition is establish, the MBR code loads the boot sector lawmaking from that partition, known as Volume Boot Tape (VBR), and executes it. The MBR boot code is often operating-organisation specific.

The boot sector code is the get-go-stage boot loader. It is located on stock-still disks and removable drives, and must fit into the first 446 bytes of the Main Boot Record in order to go out room for the default 64-byte segmentation tabular array with four partition entries and the ii-byte kicking signature, which the BIOS requires for a proper kicking loader — or even less, when additional features like more than four sectionalisation entries (up to 16 with 16 bytes each), a deejay signature (six bytes), a disk timestamp (half-dozen bytes), an Avant-garde Active Partition (18 bytes) or special multi-kicking loaders have to be supported as well in some environments. In floppy and superfloppy Book Boot Records, up to 59 bytes are occupied for the Extended BIOS Parameter Cake on FAT12 and FAT16 volumes since DOS 4.0, whereas the FAT32 EBPB introduced with DOS 7.ane requires even 87 bytes, leaving only 423 bytes for the boot loader when assuming a sector size of 512 bytes. Microsoft kick sectors therefore traditionally imposed certain restrictions on the kick process, for instance, the kicking file had to be located at a stock-still position in the root directory of the file system and stored every bit consecutive sectors,[forty] [41] conditions taken care of by the SYS command and slightly relaxed in later versions of DOS.[41] [nb 8] The boot loader was then able to load the first iii sectors of the file into retention, which happened to comprise another embedded kicking loader able to load the remainder of the file into memory.[41] When Microsoft added LBA and FAT32 support, they even switched to a boot loader reaching over 2 physical sectors and using 386 instructions for size reasons. At the same fourth dimension other vendors managed to squeeze much more functionality into a unmarried kick sector without relaxing the original constraints on merely minimal available retention (32 KB) and processor back up (8088/8086).[nb ix] For example, DR-DOS kick sectors are able to locate the kicking file in the FAT12, FAT16 and FAT32 file system, and load it into memory every bit a whole via CHS or LBA, even if the file is not stored in a fixed location and in consecutive sectors.[42] [27] [43] [44] [45] [nb 10] [nb 9]

The VBR is oft OS-specific; however, its chief part is to load and execute the operating system boot loader file (such every bit bootmgr or ntldr), which is the second-phase boot loader, from an active sectionalisation. Then the boot loader loads the Bone kernel from the storage device.

If there is no active sectionalization, or the agile sectionalization's boot sector is invalid, the MBR may load a secondary boot loader which will select a partition (often via user input) and load its kick sector, which usually loads the corresponding operating system kernel. In some cases, the MBR may as well attempt to load secondary boot loaders before trying to boot the active partition. If all else fails, it should issue an INT 18h[29] [27] BIOS interrupt call (followed by an INT 19h merely in example INT 18h would return) in order to give dorsum command to the BIOS, which would then try to boot off other devices, attempt a remote kicking via network.[27]

Many modern systems (Intel Macs and newer PCs) use UEFI.[46] [47]

Unlike BIOS, UEFI (non Legacy boot via CSM) does not rely on kicking sectors, UEFI system loads the kick loader (EFI application file in USB disk or in the EFI Organization Partitioning) directly,[48] and the Bone kernel is loaded past the kicking loader.

Other kinds of boot sequences [edit]

Many modern CPUs, SoCs and microcontrollers (for example, TI OMAP) or sometimes fifty-fifty DSPs may have boot ROM integrated direct into their silicon, so such a processor can perform a simple kicking sequence on its own and load boot programs (firmware or software) from sources such equally NAND flash or eMMC. Information technology is difficult to hardwire all the required logic for treatment such devices, so an integrated boot ROM is used instead in such scenarios. Too, a boot ROM may be able to load a kick loader or diagnostic program via serial interfaces similar UART, SPI, USB so on. This feature is oftentimes used for arrangement recovery purposes, or it could also exist used for initial not-volatile memory programming when there is no software available in the non-volatile memory notwithstanding. Many modernistic microcontrollers (e.g. flash memory controller on some USB flash drives) have firmware ROM integrated directly into their silicon.

Some embedded organisation designs may also include an intermediary boot sequence step in form of additional lawmaking that gets loaded into system RAM by the integrated boot ROM. Additional code loaded that way usually serves as a way for overcoming platform limitations, such as modest amounts of RAM, so a dedicated primary boot loader, such equally Das U-Boot, can exist loaded as the next footstep in system'south boot sequence. The boosted lawmaking and boot sequence step are unremarkably referred to as secondary program loader (SPL).[49]

It is besides possible to take control of a system by using a hardware debug interface such as JTAG. Such an interface may be used to write the kick loader plan into bootable non-volatile retention (e.g. flash) by instructing the processor cadre to perform the necessary actions to programme non-volatile memory. Alternatively, the debug interface may be used to upload some diagnostic or boot code into RAM, and so to start the processor core and instruct information technology to execute the uploaded code. This allows, for example, the recovery of embedded systems where no software remains on whatever supported kick device, and where the processor does not have whatsoever integrated kick ROM. JTAG is a standard and popular interface; many CPUs, microcontrollers and other devices are manufactured with JTAG interfaces (as of 2009).

Some microcontrollers provide special hardware interfaces which cannot exist used to take capricious command of a system or straight run code, but instead they allow the insertion of boot code into bootable non-volatile memory (like wink retention) via simple protocols. Then at the manufacturing phase, such interfaces are used to inject boot lawmaking (and mayhap other code) into not-volatile retention. After system reset, the microcontroller begins to execute code programmed into its non-volatile memory, just like usual processors are using ROMs for booting. Near notably this technique is used by Atmel AVR microcontrollers, and by others as well. In many cases such interfaces are implemented past hardwired logic. In other cases such interfaces could be created by software running in integrated on-chip kicking ROM from GPIO pins.

About digital betoken processors have a serial way boot, and a parallel mode boot, such equally the host port interface (HPI boot).

In case of DSPs there is often a second microprocessor or microcontroller present in the system blueprint, and this is responsible for overall system behavior, interrupt treatment, dealing with external events, user interface, etc. while the DSP is dedicated to indicate processing tasks only. In such systems the DSP could be booted by another processor which is sometimes referred as the host processor (giving name to a Host Port). Such a processor is also sometimes referred as the chief, since it ordinarily boots get-go from its own memories and then controls overall system behavior, including booting of the DSP, and so further decision-making the DSP's behavior. The DSP often lacks its own boot memories and relies on the host processor to supply the required code instead. The most notable systems with such a blueprint are cell phones, modems, audio and video players and and then on, where a DSP and a CPU/microcontroller are co-existing.

Many FPGA chips load their configuration from an external series EEPROM ("configuration ROM") on power-up.

See also [edit]

  • Boot disk
  • Bootkit
  • Comparing of boot loaders
  • Linux startup process
  • Macintosh startup
  • Microreboot
  • Multi boot
  • Network booting
  • RedBoot
  • Self-booting deejay
  • Windows startup procedure

Notes [edit]

  1. ^ Including daemons.
  2. ^ UU was often of the class Uu, U=Control unit of measurement address, u=Device address, only some command units attached only eight devices; some attached more than 16. Indeed, the 3830 DASD controller offered 32-bulldoze-addressing equally an option.
  3. ^ Excluding the 370/145 and 370/155, which used a 3210 or 3215 panel typewriter.
  4. ^ Only the S/360 used the 2250; the 360/85, 370/165 and 370/168 used a keyboard/display device compatible with nothing else.
  5. ^ The IBM 1401, IBM 7090, IBM Organisation/360 and many others did not crave keying in a kicking loader. The Southward/360 had a read just storage in most models, although not using integrated circuits.
  6. ^ The signature at offset +1FEh in boot sectors is 55h AAh, that is 55h at first +1FEh and AAh at offset +1FFh. Since little-endian representation must be assumed in the context of IBM PC compatible machines, this tin can exist written every bit 16-bit word AA55h in programs for x86 processors (notation the swapped club), whereas it would have to be written as 55AAh in programs for other CPU architectures using a big-endian representation. Since this has been mixed up numerous times in books and even in original Microsoft reference documents, this article uses the commencement-based byte-wise on-disk representation to avoid any possible misinterpretation.
  7. ^ The agile sectionalisation may contain a Second-stage kicking loader, e.g., Bone/ii Boot Manager, rather than an Bone.
  8. ^ The PC DOS 5.0 manual incorrectly states that the systen files no longer need to be contiguous. However, for the boot process to piece of work the organisation files nonetheless need to occupy the kickoff ii directory entries and the beginning three sectors of IBMBIO.COM still need to be stored contiguously. SYS continues to accept care of these requirements.
  9. ^ a b As an example, while the extended functionality of DR-DOS MBRs and boot sectors compared to their MS-DOS/PC DOS counterparts could however be achieved utilizing conventional code optimization techniques in assembly linguistic communication upwardly to 7.05, for the addition of LBA, FAT32 and LOADER support the 7.07 sectors had to resort to self-modifying lawmaking, opcode-level programming in motorcar language, controlled utilization of (documented) side effects, multi-level information/code overlapping and algorithmic folding techniques to clasp everything into a unmarried physical sector, as information technology was a requirement for backward- and cross-compatibility with other operating systems in multi-kicking and chain load scenarios.
  10. ^ There is 1 exception to the dominion that DR-DOS VBRs will load the whole IBMBIO.COM file into memory: If the IBMBIO.COM file is larger than some 29 KB, trying to load the whole file into memory would result in the boot loader to overwrite the stack and relocated Disk Parameter Table (DPT/FDPB). Therefore, a DR-DOS 7.07 VBR would but load the outset 29 KB of the file into memory, relying on another loader embedded into the get-go part of IBMBIO.COM to check for this condition and load the balance of the file into retention by itself if necessary. This does not crusade compatibility problems, as IBMBIO.COM's size never exceeded this limit in previous versions without this loader. Combined with a dual entry construction this as well allows the system to be loaded by a PC DOS VBR, which would load only the commencement three sectors of the file into memory.

References [edit]

  1. ^ "bootstrap". Computer Dictionary of It.
  2. ^ "Bootstrap". The Gratuitous Dictionary.
  3. ^ "Pull oneself up by bootstraps". Idioms by The Free Dictionary . Retrieved 2019-ten-07 .
  4. ^ "Bootstrap Definition". Tech Terms . Retrieved 2019-x-02 .
  5. ^ "Pull yourself upwards by your bootstraps". The Phrase Finder.
  6. ^ Campbell-Kelly, Martin (1980). "Programming the EDSAC". IEEE Annals of the History of Computing. 2 (1): 7–36. doi:10.1109/mahc.1980.10009.
  7. ^ Wilkes, Maurice V.; Wheeler, David J.; Gill, Stanley (1951). The Training of Programs for an Electronic Digital Computer. Addison-Wesley.
  8. ^ Buchholz, Werner (1953). "The System Pattern of the IBM Type 701 Calculator" (PDF). Proceedings of the I.R.Due east. 41 (10): 1273.
  9. ^ a b "IBM 7619 Commutation". Reference Manual 7030 Information Processing System (PDF). IBM. Baronial 1961. pp. 125–127. A22-6530-2.
  10. ^ Principles of Operation Type 701 And Associated Equipment (PDF). IBM. 1953. p. 26. Retrieved 2012-11-09 .
  11. ^ From Gutenberg to the Internet, Jeremy M. Norman, 2005, page 436, ISBN 0-930405-87-0
  12. ^ Oxford English Dictionary. Oxford University.
  13. ^ 650 magnetic drum data-processing motorcar transmission of operation (PDF). IBM. 1955. pp. 49, 53–54.
  14. ^ GE-645 System Manual (PDF). Full general Electric. January 1968. Retrieved 2019-10-30 .
  15. ^ PDP-ten System Reference Transmission, Part ane (PDF). Digital Equipment Corporation. 1969. pp. 2–72. Retrieved 2012-11-09 .
  16. ^ a b z/Architecture Principles of Operation (PDF). IBM. September 2005. pp. Affiliate 17. Retrieved 2007-04-14 .
  17. ^ PDP-xi Peripherals Handbook (PDF). Digital Equipment Corporation. 1976. pp. 4–25.
  18. ^ How To Utilise The Nova Computers (PDF). Information General. October 1974. Department ii.8 "Program Loading".
  19. ^ "Oldcomputers: Altair 8800b". Retrieved 2019-12-10 .
  20. ^ Holmer, Glenn. Altair 8800 loads 4K BASIC from paper tape.
  21. ^ Ciaramella, Alberto. "Device for automatically loading the primal retention of electronic processors." U.Southward. Patent No. 4,117,974. 1978-10-03. (submitted in 1975)
  22. ^ Alberto Ciaramella racconta il brevetto del boostrap dei computer concepito in CSELT [Alberto Ciaramella discusses the patent for bootstrapping computers conceived at CSELT] (in Italian). Archived from the original on 2021-eleven-xiii.
  23. ^ Osborne, Adam; Kane, Gerry (1981). Osborne xvi-Fleck Microprocessor Handbook (PDF). pp. 5–27. ISBN0-931988-43-eight . Retrieved 2019-08-23 .
  24. ^ Intel 64 and IA-32 Architectures Software Developer'southward Transmission Volume 3 (3A, 3B, 3C & 3D): Arrangement Programming Guide (PDF).
  25. ^ Osborne, Adam; Kane, Gerry. Osborne four&eight-Bit Microprocessor Handbook. pp. 10–20. ISBN0-931988-42-X.
  26. ^ Apple Ad, Interface Age, October 1976
  27. ^ a b c d e Paul, Matthias R. (1997-ten-02) [1997-09-29]. "Caldera OpenDOS vii.01/7.02 Update Blastoff iii IBMBIO.COM - README.TXT and BOOT.TXT - A short clarification of how OpenDOS is booted". Archived from the original on 2003-10-04. Retrieved 2009-03-29 . [1]
  28. ^ Sakamoto, Masahiko (2010-05-13). "Why BIOS loads MBR into 7C00h in x86?". Glamenv-Septzen.cyberspace . Retrieved 2012-08-22 .
  29. ^ a b Compaq Computer Corporation; Phoenix Technologies Ltd; Intel Corporation (1996-01-11). "BIOS Boot Specification one.01" (PDF) . Retrieved 2017-12-21 .
  30. ^ "Chapter 6 - Troubleshooting Startup and Disk Issues". Windows NT Server Resource Kit. Microsoft. Archived from the original on 2007-05-fifteen.
  31. ^ "Tint". coreboot. Retrieved 2010-eleven-xx .
  32. ^ "List of PC brands with their respective hot-keys". www.disk-prototype.com . Retrieved 2020-09-26 .
  33. ^ "How to Enter the BIOS on Whatever PC: Access Keys by Manufacturer | Tom's Hardware". www.tomshardware.com . Retrieved 2020-09-26 .
  34. ^ Brownish, Eric (2008-ten-02). "MontaVista Linux drives Dell's quick-boot characteristic". linuxdevices.com. Retrieved 2010-eleven-20 .
  35. ^ Larabel, Michael (2008-06-xiv). "SplashTop Linux On HP, Dell Notebooks?". Phoronix. Retrieved 2010-11-20 .
  36. ^ "Voodoo Envy's Instant-On IOS (powered past Splashtop)". YouTube. Archived from the original on 2021-xi-thirteen. Retrieved 2010-eleven-20 .
  37. ^ "iAPX 286 Developer's Reference Manual" (PDF). Intel. 1983. Section 5.3 Arrangement INITIALIZATION, p. v-seven. Retrieved 2019-08-23 . Since the CS annals contains F000 (thus specifying a lawmaking segment starting at concrete address F0000) and the didactics pointer contains FFF0, the processor will execute its first instruction at physical accost FFFF0H.
  38. ^ "80386 Programmer'due south Reference Manual" (PDF). Intel. 1986. Section 10.2.iii Beginning Instructions, p. 10-iii. Retrieved 2013-11-03 . Afterward RESET, address lines A31-twenty are automatically asserted for didactics fetches. This fact, together with the initial values of CS:IP, causes teaching execution to begin at physical address FFFFFFF0H.
  39. ^ "Intel 64 and IA-32 Architectures Software Developer's Transmission" (PDF). Intel Corporation. May 2012. Department 9.i.4 Start Instruction Executed, p. 2611. Retrieved 2012-08-23 . The kickoff instruction that is fetched and executed following a hardware reset is located at physical address FFFFFFF0h. This accost is 16 bytes below the processor's uppermost physical address. The EPROM containing the software-initialization code must be located at this address.
  40. ^ Zbikowski, Mark; Allen, Paul; Ballmer, Steve; Borman, Reuben; Borman, Rob; Butler, John; Carroll, Chuck; Chamberlain, Marking; Chell, David; Colee, Mike; Courtney, Mike; Dryfoos, Mike; Duncan, Rachel; Eckhardt, Kurt; Evans, Eric; Farmer, Rick; Gates, Beak; Geary, Michael; Griffin, Bob; Hogarth, Doug; Johnson, James W.; Kermaani, Kaamel; Rex, Adrian; Koch, Reed; Landowski, James; Larson, Chris; Lennon, Thomas; Lipkie, Dan; McDonald, Marc; McKinney, Bruce; Martin, Pascal; Mathers, Estelle; Matthews, Bob; Melin, David; Mergentime, Charles; Nevin, Randy; Newell, Dan; Newell, Tani; Norris, David; O'Leary, Mike; O'Rear, Bob; Olsson, Mike; Osterman, Larry; Ostling, Ridge; Pai, Sunil; Paterson, Tim; Perez, Gary; Peters, Chris; Petzold, Charles; Pollock, John; Reynolds, Aaron; Rubin, Darryl; Ryan, Ralph; Schulmeisters, Karl; Shah, Rajen; Shaw, Barry; Short, Anthony; Slivka, Ben; Smirl, Jon; Stillmaker, Betty; Stoddard, John; Tillman, Dennis; Whitten, Greg; Yount, Natalie; Zeck, Steve (1988). "Technical advisors". The MS-DOS Encyclopedia: versions 1.0 through 3.2. Past Duncan, Ray; Bostwick, Steve; Burgoyne, Keith; Byers, Robert A.; Hogan, Thom; Kyle, Jim; Letwin, Gordon; Petzold, Charles; Rabinowitz, Chip; Tomlin, Jim; Wilton, Richard; Wolverton, Van; Wong, William; Woodcock, JoAnne (Completely reworked ed.). Redmond, Washington, USA: Microsoft Printing. ISBNane-55615-049-0. LCCN 87-21452. OCLC 16581341. (19+1570 pages; 26 cm) (NB. This edition was published in 1988 later on extensive rework of the withdrawn 1986 commencement edition by a dissimilar team of authors. [two])
  41. ^ a b c Chappell, Geoff (January 1994). "Chapter 2: The System Footprint". In Schulman, Andrew; Pedersen, Amorette (eds.). DOS Internals. The Andrew Schulman Programming Serial (1st press, 1st ed.). Addison Wesley Publishing Company. ISBN978-0-201-60835-nine. (xxvi+738+iv pages, 3.5"-floppy [iii][four]) Errata: [5][6][7]
  42. ^ Rosch, Winn 50. (1991-02-12). "DR DOS 5.0 - The better operating system?". PC Magazine. Vol. 10, no. iii. p. 241-246, 257, 264, 266. Archived from the original on 2019-07-25. Retrieved 2019-07-26 . […] SYS has been improved under DR DOS 5.0 then you don't have to worry about leaving the first cluster free on a disk that you want to make bootable. The DR DOS organisation files can exist located anywhere on the disk, so any disk with plenty free infinite can be set to boot your system. […] (NB. The source attributes this to the SYS utility while in fact this is a feature of the advanced bootstrap loader in the kick sector. SYS just plants this sector onto the deejay.)
  43. ^ Paul, Matthias R. (2001-01-17). "FAT32 in DR-DOS". opendos@delorie. Archived from the original on 2017-x-06. Retrieved 2017-10-06 . […] The DR-DOS boot sector […] searches for the IBMBIO.COM (DRBIOS.SYS) file and and then loads the *whole* file into memory before information technology passes command to it. […]
  44. ^ Paul, Matthias R. (2002-02-20). "Can't copy". opendos@delorie. Archived from the original on 2017-10-06. Retrieved 2017-10-06 . […] The DR-DOS boot sector loads the whole IBMBIO.COM file into memory before it executes it. It does not care at all about the IBMDOS.COM file, which is loaded by IBMBIO.COM. […] The DR-DOS boot sector […] will find the […] kernel files as long as they are logically stored in the root directory. Their physical location on the disk, and if they are fragmented or non, is don't care for the DR-DOS boot sector. Hence, yous can simply copy the kernel files to the deejay (even with a simply Re-create), and as soon as the boot sector is a DR-DOS sector, it will notice and load them. Of course, it is hard to put all this into only 512 bytes, the size of a single sector, but this is a major convenience improvement if yous accept to gear up a DR-DOS system, and it is also the primal for the DR-DOS multi-OS LOADER utility to work. The MS-DOS kernel files must reside on specific locations, but the DR-DOS files can exist anywhere, so y'all don't take to physically swap them around each fourth dimension yous boot the other Bone. Too, information technology allows to upgrade a DR-DOS organisation simply past copying the kernel files over the old ones, no need for SYS, no difficult setup procedures every bit required for MS-DOS/PC DOS. Y'all can fifty-fifty have multiple DR-DOS kernel files under dissimilar file names stored on the same drive, and LOADER will switch between them according to the file names listed in the Kicking.LST file. […]
  45. ^ Paul, Matthias R. (2017-08-14) [2017-08-07]. "The continuing saga of Windows 3.1 in enhanced mode on OmniBook 300". MoHPC - the Museum of HP Calculators. Archived from the original on 2017-10-06. Retrieved 2017-x-06 . […] the DR-DOS FDISK does non only sectionalisation a disk, just can too format the freshly created volumes and initialize their boot sectors in one go, and so there's no gamble to accidentally mess upwardly the wrong volume and no need for FORMAT /S or SYS. After, y'all could just copy over the remaining DR-DOS files, including the organization files. It is important to know that, in dissimilarity to MS-DOS/PC DOS, DR-DOS has "smart" kick sectors which will actually "mount" the file-system to search for and load the arrangement files in the root directory instead of expecting them to be placed at a sure location. Physically, the system files tin can be located anywhere and likewise tin be fragmented. […]
  46. ^ "Intel Platform Innovation Framework for EFI". Intel. Retrieved 2008-01-07 .
  47. ^ "OpenBIOS - coreboot". coreboot.org. Retrieved 2013-03-20 .
  48. ^ "UEFI - OSDev Wiki". wiki.osdev.org . Retrieved 2020-09-26 .
  49. ^ "Overview – The 4 bootloader stages". ti.com. Texas Instruments. 2013-12-05. Retrieved 2015-01-25 .

hoyenowhimed.blogspot.com

Source: https://en.wikipedia.org/wiki/Booting

Post a Comment for "Which Option Should Be Enabled in Order to View What Did and Did Not Load During the Bootup?"