text:
Booting
From Wikipedia, the free encyclopedia
Jump to navigation Jump to search
This article includes a list of references, but its sources remain unclear because it has insufficient inline citations. Please help to improve this article by introducing more precise citations. (October 2018) (Learn how and when to remove this template message)
"Quick boot" redirects here. For the feature of the Quarterdeck memory manager, see Quickboot (QEMM).
This article is about bootstrapping operating systems. For the general concept, see Bootstrapping.
For other uses, see Boot (disambiguation).
In computing, booting is starting up a computer or computer appliance until it can be used. It can be initiated by hardware such as a button press or by software command. After the power is switched on, the computer is relatively dumb and can read only part of its storage called read-only memory. There, a small program is stored called firmware. It does power-on self-tests and, most importantly, allows accessing other types of memory like a hard disk and main memory. The firmware loads bigger programs into the computer's main memory and runs it. In general purpose computers, but additionally in smartphones and tablets, optionally a boot manager is run. The boot manager lets a user choose which operating system to run and set more complex parameters for it. The firmware or the boot manager then loads the boot loader into the memory and runs it. This piece of software is able to place an operating system kernel like Windows or Linux into the computers main memory and run it. Afterwards, the kernel runs so-called user space software – well known is the graphical user interface (GUI), which lets the user log in to the computer or run some other applications. The whole process may take seconds to tenths of seconds on modern day general purpose computers.
Restarting a computer also is called reboot, which can be "hard", e.g. after 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 zero. Both hard and soft booting can be initiated by hardware such as a button press or by software command. Booting is complete when the operative runtime system, typically operating system and some applications,[NB 1] is attained.
The process of returning a computer from a state of hibernation or sleep does not involve booting. Minimally, some embedded systems do not require a noticeable boot sequence to begin functioning and when turned on may simply run operational programs that are stored in ROM. All computing systems are state machines, and a reboot may be the only method to return to a designated zero-state from an unintended, locked state.
In addition to loading an operating system or stand-alone utility, the boot process can also load a storage dump program for diagnosing problems in an operating system.
Boot is short for bootstrap[1][2] or bootstrap load and derives from the phrase to pull oneself up by one's bootstraps.[3][4][citation needed] The usage calls attention to the requirement that, if most 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.[5] 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 memory (ROM) of various types solved this paradox by allowing computers to be shipped with a start up program that could not be erased. Growth in the capacity of ROM has allowed ever more elaborate start up procedures to be implemented.
Contents
1 History
1.1 Pre integrated-circuit-ROM examples
1.1.1 Early computers
1.1.2 First commercial computers
1.1.3 IBM System/360 and successors
1.1.4 Minicomputers
1.1.4.1 Early minicomputer boot loader examples
1.1.5 Booting the first microcomputers
1.2 Integrated circuit read-only memory era
2 Modern boot loaders
2.1 First-stage boot loader
2.2 Second-stage boot loader
2.3 Network booting
3 Personal computers (PC)
3.1 Boot devices
3.2 Boot sequence
4 Other kinds of boot sequences
5 See also
6 Notes
7 References
History[edit]
Switches and cables used to program ENIAC (1946)
There are many different methods available to load a short initial program into a computer. These methods reach from simple, physical input to removable media that can hold more complex programs.
Pre integrated-circuit-ROM examples[edit]
Early computers[edit]
Early computers in the 1940s and 1950s were one-of-a-kind engineering efforts that could take weeks to program and program loading was one of many problems that had to be solved. An early computer, ENIAC, had no "program" stored in memory, but was set up for each problem by a configuration of interconnecting cables. Bootstrapping did not apply to ENIAC, whose hardware configuration was ready for solving problems as soon as power was applied.
The EDSAC system, the second stored program computer to be built, used stepping switches to transfer a fixed program into memory when its start button was pressed. The program stored on this device, which David Wheeler completed in late 1948, loaded further instructions from punched tape and then executed them.[6][7]
First commercial computers[edit]
The first programmable computers for commercial sale, such as the UNIVAC I and the IBM 701[8] 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 card (the most typical ones) or other input media, such as a magnetic drum or magnetic tape, that contained a bootstrap program by pressing a single button. This booting concept was called a variety of names for IBM computers of the 1950s and early 1960s, but IBM used the term "Initial Program Load" with the IBM 7030 Stretch[9] and later used it for their mainframe lines, starting with the System/360 in 1964.
Initial program load punched card 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 main 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-bit half-word was then executed as an instruction, which usually read additional words into memory.[10][11] The loaded boot program was then executed, which, in turn, loaded a larger program from that medium into memory without further 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 card. The 80 characters stored in the punched card were read into memory locations 001 to 080, then the computer would branch to memory location 001 to read its first stored instruction. This instruction was always the same: move the information in these first 80 memory locations to an assembly area where the information in punched cards 2, 3, 4, and so on, could be combined to form the stored program. Once this information was moved to the assembly area, the machine would branch to an instruction in location 080 (read a card) and the next card would be read and its information processed.
Another example was the IBM 650 (1953), a decimal machine, which had a group of ten 10-position switches on its operator panel which were addressable as a memory word (address 8000) and could be executed as an instruction. Thus setting the switches to 7004000400 and pressing the appropriate button would read the first card in the card reader into memory (op code 70), starting at address 400 and then jump to 400 to begin executing the program on that card.[13]
IBM's competitors also offered single button program 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" button that, when pressed, caused one of the I/O controllers to load a 64-word program into memory from a diode read-only memory and deliver an interrupt to cause that program to start running.[14]
The first model of the PDP-10 had a "READ IN" button that, when pressed, reset the processor and started an I/O operation on a device specified by switches on the control panel, reading in a 36-bit word giving a target address 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 system is reset it reads and executes opcodes sequentially from a tape drive mounted on the front panel; this sets up a boot loader in RAM which is then executed. However, since this makes few assumptions about the system it can equally well be 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 current z/Architecture machines, the boot process is known as Initial Program Load (IPL).
IBM coined this term for the 7030 (Stretch),[9] revived it for the design of the System/360, and continues to use it in those environments today.[16] In the System/360 processors, an IPL is initiated by the computer operator by selecting the three hexadecimal digit device address (CUU; C=I/O Channel address, UU=Control unit and Device address[NB 2]) followed by pressing the LOAD button. On the high end System/360 models, most[NB 3] System/370 and some later systems, the functions of the switches and the LOAD button are simulated using selectable areas on the screen of a graphics console, often[NB 4] an IBM 2250-like device or an IBM 3270-like device. For example, on the System/370 Model 158, the keyboard sequence 0-7-X (zero, seven and X, in that order) results in an IPL from the device address which was keyed into the input area. The Amdahl 470V/6 and related CPUs supported four hexadecimal digits on those CPUs which had the optional second channel unit installed, for a total of 32 channels. Later, IBM would also support more than 16 channels.
The IPL function in the System/360 and its successors, and its compatibles such as Amdahl's, reads 24 bytes from an operator-specified device into main storage starting at real address zero. The second and third groups of eight bytes are treated as Channel Command Words (CCWs) to continue loading the startup program (the first CCW is always simulated by the CPU and consists of a Read IPL command, 02h, with command chaining and suppress incorrect length indication being enforced). When the I/O channel commands are complete, the first group of eight bytes is then loaded into the processor's Program Status Word (PSW) and the startup program begins execution at the location designated by that PSW.[16] The IPL device is usually a disk drive, hence the special significance of the 02h read-type command, but exactly the same procedure is also used to IPL from other input-type devices, such as tape drives, or even card readers, in a device-independent manner, allowing, for example, the installation of an operating system on a brand-new computer from an OS initial distribution magnetic tape. For disk 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 tape and card controllers, as for these device classes an 02h command is simply a sequential read command, not a Read IPL command.
The disk, tape or card deck must contain a special program to load the actual operating system or standalone utility into main storage, and for this specific purpose "IPL Text" is placed on the disk by the stand-alone DASDI (Direct Access Storage Device Initialization) program or an equivalent program running under an operating system, e.g., ICKDSF, but IPL-able tapes and card decks are usually distributed with this "IPL Text" already present.
Minicomputers[edit]
PDP-8/E front panel showing the switches used to load the bootstrap program
Minicomputers, starting with the Digital Equipment Corporation (DEC) PDP-5 and PDP-8 (1965) simplified design by using the CPU to assist input and output operations. This saved cost but 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 core memory, which did not lose its information when power was off, these bootstrap loaders would remain in place unless they were erased. Erasure sometimes happened accidentally when a program bug caused a loop that overwrote all of memory.
Other minicomputers with such simple form of booting include Hewlett-Packard's HP 2100 series (mid-1960s), the original Data General Nova (1969), and DEC's PDP-11 (1970).
DEC later added an optional diode matrix read-only memory 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 16 array of semiconductor diodes. With all 512 diodes in place, the memory contained all "one" bits; the card was programmed by cutting off each diode whose bit was to be "zero". DEC also sold versions of the card, the BM792-Yx series, pre-programmed for many standard input devices by simply omitting the unneeded diodes.[17]
Following the older approach, the earlier PDP-1 has a hardware loader, such that an operator need only push the "load" switch to instruct the paper tape reader to load a program directly into core memory. The Data General Supernova used front panel switches to cause the computer to automatically load instructions into memory from a device specified by the front panel's data switches, and then jump to loaded code; 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 program to run in the boot process, the boot loader, would read into core memory either the second-stage boot loader (often called a Binary Loader) that could read paper tape with checksum or the operating system from an outside storage medium. Pseudocode for the boot loader might be as simple as the following eight instructions:
Set the P register to 9
Check paper tape reader ready
If not ready, jump to 2
Read a byte from paper tape reader to accumulator
Store accumulator to address in P register
If end of tape, jump to 9
Increment the P register
Jump to 2
A related example is based on a loader for a Nicolet Instrument Corporation minicomputer of the 1970s, using the paper tape reader-punch unit on a Teletype Model 33 ASR teleprinter. The bytes of its second-stage loader are read from paper tape in reverse order.
Set the P register to 106
Check paper tape reader ready
If not ready, jump to 2
Read a byte from paper tape reader to accumulator
Store accumulator to address in P register
Decrement the P register
Jump to 2
The length of the second stage loader is such that the final byte overwrites location 7. After the instruction in location 6 executes, location 7 starts the second stage loader executing. The second stage loader then waits for the much longer tape containing the operating system to be placed in the tape 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, "part-time-duty" hardware, such as the Teletype Model 33 ASR. (Friden Flexowriters were far more reliable, but also comparatively costly.)
Booting the first microcomputers[edit]
The earliest microcomputers, such as the Altair 8800 (released first in 1975) and an even earlier, similar machine (based on the Intel 8008 CPU) had no bootstrapping hardware as such.[19] When started, the CPU would see memory that would contain executable code containing only binary zeros—memory was cleared by resetting when powering up. The front panels of these machines carried toggle switches for entering addresses and data, one switch per bit of the computer memory word and address bus. Simple additions to the hardware permitted one memory 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 code. This process was tedious and had to be error-free.[20]
Integrated circuit read-only memory era[edit]
An Intel 2708 EPROM "chip" on a circuit board.
The boot process was revolutionized by the introduction of integrated circuit read-only memory (ROM), with its many variants, including mask-programmed ROMs, programmable ROMs (PROM), erasable programmable ROMs (EPROM), and flash memory. These allowed firmware boot programs to be shipped installed on the computer. The introduction of an (external) ROM was in an Italian telephone 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 machine booting into the operating system from a ROM memory composed from semiconductors, not from ferrite cores. Although the ROM device was not natively embedded in the computer of Gruppi Speciali, due to the design of the machine, it also allowed the single-button ROM booting in machines not designed for that (therefore, this "bootstrap device" was architecture-independent), e.g. the PDP-11. Storing the state of the machine after the switch-off was also in place, which was another critical feature in the telephone switching contest.[22]
Typically, every microprocessor will, after a reset or power-on condition, perform a start-up process that usually takes the form of "begin execution of the code that is found starting at a specific address" or "look for a multibyte code at a specific address and jump 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 assistance. For example, Intel x86 processors always start by running the instructions beginning 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 Inc.'s first computer, the Apple 1 introduced in 1976, featured PROM chips that eliminated the need for a front panel for the boot process (as it was the case with the Altair 8800) in a commercial computer. According to Apple's ad announcing it "No More Switches, No More 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-only memory at the time, the Apple II series booted its disk operating systems using a series of very small incremental steps, each passing control onward to the next phase of the gradually more complex boot process. (See Apple DOS: Boot loader). Because so little of the disk operating system relied on ROM, the hardware was also extremely flexible and supported a wide range of customized disk copy protection mechanisms. (See Software Cracking: History.)
Some operating systems, most notably pre-1995 Macintosh systems from Apple, are so closely interwoven with their hardware that it is impossible to natively boot an operating system other than the standard one. This is the opposite extreme of the scenario using switches mentioned above; it is highly inflexible but relatively error-proof and foolproof as long as all hardware is working normally. A common solution in such situations is to design a boot loader that works as a program belonging to the standard OS that hijacks the system and loads the alternative OS. 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, like the Atari ST microcomputer, were "instant-on", with the operating system executing from a ROM. Retrieval of the OS from secondary or tertiary store 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 additional components during the boot process. 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 disk. The Atari ST hardware was also designed so the cartridge slot could provide native program execution for gaming purposes as a holdover from Atari's legacy making electronic games; by inserting the Spectre GCR cartridge with the Macintosh system ROM in the game slot and turning the Atari on, it could "natively boot" the Macintosh operating system rather than Atari's own 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 test when the machine was powered up, and then to read software from a boot device and execute it. Firmware compatible with the BIOS on the IBM Personal Computer is used in IBM PC compatible computers. The Extensible Firmware Interface was developed by Intel, originally for Itanium-based machines, and later also used as an alternative to the BIOS in x86-based machines, including Apple Macs using Intel processors.
Unix workstations originally had vendor-specific ROM-based firmware. Sun Microsystems later developed OpenBoot, later known as Open Firmware, which incorporated a Forth interpreter, with much of the firmware being written in Forth. 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 as Sun's own SPARC-based computers. The Advanced RISC Computing specification defined another 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]
See also: Comparison of boot loaders
When a computer is turned off, its software—including operating systems, application code, and data—remains stored on non-volatile memory. When the computer is powered on, it typically does not have an operating system or its loader in random-access memory (RAM). The computer first executes a relatively small program stored in read-only memory (ROM) along with a small amount of needed data, to access the nonvolatile device or devices from which the operating system programs and data can be loaded into RAM.
The small program that starts this sequence is known as a bootstrap loader, bootstrap or boot loader. This small program's only job is to load other data and programs which are then executed from RAM. Often, 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 computer systems, upon receiving a boot signal 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 one CPU, and then point the CPU to the instructions and start their execution. These instructions typically start an input operation from some peripheral device (which may be switch-selectable by the operator). Other systems may send hardware commands directly to peripheral devices or I/O controllers that cause an extremely simple input operation (such as "read sector zero of the system device into memory starting at location 1000") to be carried out, effectively loading a small number of boot loader instructions into memory; a completion signal from the I/O device may then be used to start execution of the instructions by the CPU.
Smaller computers often use less flexible but more automatic boot loader mechanisms to ensure that the computer starts quickly and with a predetermined software configuration. In many desktop computers, for example, the bootstrapping process begins with the CPU executing software contained in ROM (for example, the BIOS of an IBM PC) at a predefined address (some CPUs, including the Intel x86 series are designed to execute this software after reset without outside help). This software contains rudimentary functionality to search for devices eligible to participate in booting, and load a small program from a special section (most commonly the boot sector) of the most promising device, typically starting at a fixed entry point such as the start of the sector.
First-stage boot loader[edit]
Boot loaders may face peculiar constraints, especially in size; for instance, on the IBM PC and compatibles, a boot sector should typically work in only 32 KB[27] (later relaxed to 64 KB[28]) of system memory and not use instructions not supported by the original 8088/8086 processors. The first stage of PC boot loaders (FSBL, first-stage boot loader) located on fixed disks and removable drives must fit into the first 446 bytes of the Master Boot Record in order to leave room for the default 64-byte partition table with four partition entries and the two-byte boot signature, which the BIOS requires for a proper boot loader — or even less, when additional features like more than four partition entries (up to 16 with 16 bytes each), a disk signature (6 bytes), a disk timestamp (6 bytes), an Advanced Active Partition (18 bytes) or special multi-boot loaders have to be supported as well in some environments. In floppy and superfloppy Volume Boot Records, up to 59 bytes are occupied for the Extended BIOS Parameter Block on FAT12 and FAT16 volumes since DOS 4.0, whereas the FAT32 EBPB introduced with DOS 7.1 requires even 71 bytes, leaving only 441 bytes for the boot loader when assuming a sector size of 512 bytes. Microsoft boot sectors therefore traditionally imposed certain restrictions on the boot process, for example, the boot file had to be located at a fixed position in the root directory of the file system and stored as consecutive sectors, conditions taken care of by the SYS command and slightly relaxed in later versions of DOS. The boot loader was then able to load the first three sectors of the file into memory, which happened to contain another embedded boot loader able to load the remainder of the file into memory. When they added LBA and FAT32 support, they even switched to a two-sector boot loader using 386 instructions. At the same time other vendors managed to squeeze much more functionality into a single boot sector without relaxing the original constraints on the only minimal available memory and processor support. For example, DR-DOS boot sectors are able to locate the boot file in the FAT12, FAT16 and FAT32 file system, and load it into memory as a whole via CHS or LBA, even if the file is not stored in a fixed location and in consecutive sectors.
Examples of first-stage bootloaders include coreboot, Libreboot and Das U-Boot.
Second-stage boot loader[edit]
Second-stage boot loaders, such as GNU GRUB, BOOTMGR, Syslinux, NTLDR or BootX, are not themselves operating systems, but are able to load an operating system properly and transfer execution to it; the operating system subsequently initializes itself and may load extra device drivers. The second-stage boot loader does not need drivers for its own operation, but may instead use generic storage access methods provided by system firmware such as the BIOS or Open Firmware, though typically with restricted hardware functionality and lower performance.[29]
Many boot loaders (like GNU GRUB, Windows's BOOTMGR, and Windows NT/2000/XP's NTLDR) can be configured to give the user multiple booting choices. These choices can include different operating systems (for dual or multi-booting from different 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 system, such as memory testers (e.g., memtest86+), a basic shell (as in GNU GRUB), or even games (see List of PC Booter games).[30] 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 so normal booting can occur without interaction.
The boot process can be considered complete when the computer is ready to interact with the user, or the operating system is capable of running system programs or application 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 can begin functioning immediately; little 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 have boot procedures that proceed in multiple phases until finally the operating system and other programs are loaded and ready to execute. Because operating systems are designed as if they never start or stop, a boot loader might load the operating system, configure itself as a mere process within that system, and then irrevocably transfer control to the operating system. The boot loader then terminates normally as any other process would.
Network booting[edit]
Main article: Network booting
Most 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 certain parts of it are transferred to the client using a simple protocol such as the Trivial File Transfer Protocol (TFTP). After these parts have been transferred, the operating system takes over the control of the booting process.
As with the second-stage boot loader, network booting begins by using generic network access methods provided by the network interface's boot ROM, which typically contains a Preboot Execution Environment (PXE) image. No drivers are required, but the system functionality is limited until the operating system kernel and drivers are transferred and started. As a result, once the ROM-based booting has completed it is entirely possible to network boot into an operating system that itself does not have the ability to use the network interface.
Personal computers (PC)[edit]
Boot devices[edit]
See also: System partition and boot partition
Windows To Go bootable flash drive, a Live USB example
The boot device is the device from which the operating system is loaded. A modern PC's UEFI or BIOS firmware supports booting from various devices, typically a local solid state drive or hard disk drive via the GPT or Master 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 card slot; hard disk drive, optical disc drive, etc.), or a network interface card (using PXE). Older, less common BIOS-bootable devices include floppy disk drives, SCSI devices, Zip drives, and LS-120 drives.
Typically, the firmware (UEFI or BIOS) will allow the user to configure a boot order. If the boot order is set to "first, the DVD drive; second, the hard disk drive", then the firmware will try to boot from the DVD drive, and if this fails (e.g. because there is no DVD in the drive), it will try to boot from the local hard disk drive.
For example, on a PC with Windows XP installed on the hard drive, the user could set the boot order to the one given above, and then insert a Linux Live CD in order to try out Linux without having to install an operating system onto the hard drive. This is an example of dual booting, in which the user chooses which operating system to start after the computer has performed its Power-on self-test (POST). In this example of dual booting, the user chooses by inserting or removing the CD from the computer, but it is more common to choose which operating system to boot by selecting from a BIOS or UEFI boot menu, by using the computer keyboard; the boot menu is typically entered by pressing Delete or F11 keys during the POST.
Several devices are available that enable the user to quick-boot into what is usually a variant of Linux for various simple tasks such as Internet access; examples are Splashtop and Latitude ON.[31][32][33]
Boot sequence[edit]
A hex dump of FreeBSD's boot0 MBR
Award Software BIOS from 2000 during booting
Upon starting, an IBM-compatible personal computer's x86 CPU executes, in real mode, the instruction located at reset vector (the physical memory address FFFF0h on 16-bit x86 processors[34] and FFFFFFF0h on 32-bit and 64-bit x86 processors[35][36]), 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 program. This program runs a power-on self-test (POST) to check and initialize required devices such as DRAM and the PCI bus (including running embedded ROMs). The most complicated step is setting up DRAM over SPI, made more difficult by the fact that at this point 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 one that can be read from, and where the last two bytes of the first sector contain the little-endian word AA55h, found as byte sequence 55h, AAh on disk (also known as the MBR boot 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:offset 0000h:7C00h, but some BIOSes erroneously use 07C0h:0000h[citation needed]) and transfers execution to the boot code. In the case of a hard disk, this is referred to as the Master Boot Record (MBR) and is by definition not operating-system specific. The conventional MBR code checks the MBR's partition table for a partition set as bootable (the one with active flag set). If an active partition is found, the MBR code loads the boot sector code from that partition, known as Volume Boot Record (VBR), and executes it.
The VBR is often operating-system specific; however, in most operating systems its main function is to load and execute the operating system kernel, which continues startup.
If there is no active partition, or the active partition'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 boot sector, which usually loads the corresponding operating system kernel. In some cases, the MBR may also attempt to load secondary boot loaders before trying to boot the active partition. If all else fails, it should issue an INT 18h[28] BIOS interrupt call (followed by an INT 19h just in case INT 18h would return) in order to give back control to the BIOS, which would then attempt to boot off other devices, attempt a remote boot via network or invoke ROM BASIC.
Some systems (particularly newer Macintoshes and new editions of Microsoft Windows) use Intel's EFI. Also coreboot allows a computer to boot without having the firmware/BIOS constantly running in system management mode. 16-bit BIOS interfaces are required by certain x86 operating systems, such as DOS and Windows 3.1/95/98 (and all when not booted via UEFI). However, most boot loaders retain 16-bit BIOS call support.[37][NB 5][38]
Other kinds of boot sequences[edit]
An unlocked Android bootloader, showing additional available options
Some modern CPUs and microcontrollers (for example, TI OMAP) or sometimes even DSPs may have boot ROM with boot code integrated directly into their silicon, so such a processor could perform quite a sophisticated boot sequence on its own and load boot programs from various sources like NAND flash, SD or MMC card and so on. It is difficult to hardwire all the required logic for handling such devices, so an integrated boot ROM is used instead in such scenarios. Boot ROM usage enables more flexible boot sequences than hardwired logic could provide. For example, the boot ROM could try to perform boot from multiple boot sources. Also, a boot ROM is often able to load a boot loader or diagnostic program via serial interfaces like UART, SPI, USB and so on. This feature is often used for system recovery purposes when for some reasons usual boot software in non-volatile memory got erased, and it could also be used for initial non-volatile memory programming when there is clean non-volatile memory installed and hence no software available in the system yet.
Some embedded system designs may also include an intermediary boot sequence step in form of additional code 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 small amounts of RAM, so a dedicated primary boot loader, such as Das U-Boot, can be loaded as the next step in system's boot sequence. The additional code and boot sequence step are usually referred to as secondary program loader (SPL).[39]
It is also 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 boot loader program into bootable non-volatile memory (e.g. flash) by instructing the processor core to perform the necessary actions to program non-volatile memory. Alternatively, the debug interface may be used to upload some diagnostic or boot code into RAM, and then to start the processor core and instruct it to execute the uploaded code. This allows, for example, the recovery of embedded systems where no software remains on any supported boot device, and where the processor does not have any integrated boot 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 be used to take arbitrary control of a system or directly run code, but instead they allow the insertion of boot code into bootable non-volatile memory (like flash memory) via simple protocols. Then at the manufacturing phase, such interfaces are used to inject boot code (and possibly other code) into non-volatile memory. After system reset, the microcontroller begins to execute code programmed into its non-volatile memory, just like usual processors are using ROMs for booting. Most notably this technique is used by Atmel AVR microcontrollers, and by others as well. In many cases such interfaces are implemented by hardwired logic. In other cases such interfaces could be created by software running in integrated on-chip boot ROM from GPIO pins.
Most digital signal processors have a serial mode boot, and a parallel mode boot, such as the host port interface (HPI boot)
In case of DSPs there is often a second microprocessor or microcontroller present in the system design, and this is responsible for overall system behavior, interrupt handling, dealing with external events, user interface, etc. while the DSP is dedicated to signal 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 master, since it usually boots first from its own memories and then controls overall system behavior, including booting of the DSP, and then further controlling 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 design are cell phones, modems, audio and video players and so on, where a DSP and a CPU/microcontroller are co-existing.
Many FPGA chips load their configuration from an external serial EEPROM ("configuration ROM") on power-up.
See also[edit]
Boot disk
Bootkit
Comparison of boot loaders
Das U-Boot
El Torito (CD-ROM standard)
Linux startup process
Live USB
Macintosh startup
Microreboot
Multi boot
Network booting
PC booter
Rebooting (computing)
RedBoot
Unified Extensible Firmware Interface
Windows NT startup process
Windows To Go
Windows Vista startup process
Notes[edit]
Jump up ^ Including daemons
Jump up ^ UU was often of the form Uu, U=Control unit address, u=Device address, but some control units attached only 8 devices; some attached more than 16. Indeed, the 3830 DASD controller offered 32-drive-addressing as an option.
Jump up ^ Excluding the 370/145 and 370/155, which used a 3210 or 3215 console typewriter
Jump up ^ Only the S/360 used the 2250; the 360/85, 370/165 and 370/168 used a keyboard/display device compatible with nothing else.
Jump up ^ Intel Macintosh computers all have firmware with compatibility mode for legacy BIOS operations
References[edit]
Jump up ^ "Bootstrap". Dictionary.com.
Jump up ^ "Bootstrap". TheFreeDictionary.com.
Jump up ^ "Pull oneself up by bootstraps - Idioms by The Free Dictionary". TheFreeDictionary.com. Retrieved 8 September 2015.
Jump up ^ "Bootstrap Definition". techterms.com. Retrieved 2018-10-16.
Jump up ^ "Phrase Finder". phrases.org.uk.
Jump up ^ Campbell-Kelly, Martin (1980). "Programming the EDSAC". IEEE Annals of the History of Computing. 2 (1): 7–36.
Jump up ^ Wilkes, Maurice V.; Wheeler, David J.; Gill, Stanley (1951). The Preparation of Programs for an Electronic Digital Computer. Addison-Wesley.
Jump up ^ Buchholz, Werner (1953). "The System Design of the IBM Type 701 Computer" (PDF). Proceedings of the I.R.E. 41 (10): 1273.
^ Jump up to: a b "IBM 7619 Exchange". Reference Manual 7030 Data Processing System (PDF). IBM. August 1961. pp. 125–127. A22-6530-2.
Jump up ^ Principles of Operation Type 701 And Associated Equipment (PDF). IBM. 1953. p. 26. Retrieved November 9, 2012.
Jump up ^ From Gutenberg to the Internet, Jeremy M. Norman, 2005, page 436, ISBN 0-930405-87-0
Jump up ^ Oxford English Dictionary. Oxford University.
Jump up ^ 650 magnetic drum data-processing machine manual of operation (PDF). IBM. 1955. pp. 49, 53–54.
Jump up ^ GE-645 System Manual (PDF). General Electric. January 1968. Retrieved December 21, 2017.
Jump up ^ PDP-10 System Reference Manual, Part 1 (PDF). Digital Equipment Corporation. 1969. pp. 2–72. Retrieved November 9, 2012.
^ Jump up to: a b z/Architecture Principles of Operation (PDF). IBM. September 2005. Chapter 17. Retrieved 2007-04-14.
Jump up ^ PDP-11 Peripherals Handbook (PDF). Digital Equipment Corporation. 1976. pp. 4–25.
Jump up ^ How To Use The Nova Computers (PDF). Data General. October 1974. section 2.8 "Program Loading".
Jump up ^ Oldcomputers: Altair 8800b
Jump up ^ "Altair 8800 loads 4K BASIC from paper tape", video by Glenn Holmer
Jump up ^ Ciaramella, Alberto. "Device for automatically loading the central memory of electronic processors." U.S. Patent No. 4,117,974. 3 Oct. 1978. (submitted in 1975)
Jump up ^ 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).
Jump up ^ Adam Osborne; Gerry Kane. Osborne 16-Bbit Microprocessor Handbook (PDF). pp. 5–27. ISBN 0-931988-43-8.
Jump up ^ Intel® 64 and IA-32 Architectures Software Developer’s Manual Volume 3 (3A, 3B, 3C & 3D): System Programming Guide (PDF).
Jump up ^ Adam Osborne; Gerry Kane. Osborne 4&8-Bit Microprocessor Handbook. pp. 10–20. ISBN 0-931988-42-X.
Jump up ^ Apple Ad, Interface Age, October 1976
Jump up ^ Masahiko Sakamoto (May 13, 2010). "Why BIOS loads MBR into 7C00h in x86?". Glamenv-Septzen.net. Retrieved 2012-08-22.
^ Jump up to: a b Compaq Computer Corporation; Phoenix Technologies Ltd; Intel Corporation (January 11, 1996). "BIOS Boot Specification 1.01" (PDF). Retrieved December 21, 2017.
Jump up ^ "Chapter 6 - Troubleshooting Startup and Disk Problems". Windows NT Server Resource Kit. Microsoft. Archived from the original on May 15, 2007.
Jump up ^ "Tint". coreboot. Retrieved 20 November 2010.
Jump up ^ Brown, Eric (2008-10-02). "MontaVista Linux drives Dell's quick-boot feature". linuxdevices.com. Retrieved 20 November 2010.
Jump up ^ Larabel, Michael (June 14, 2008). "SplashTop Linux On HP, Dell Notebooks?". Phoronix. Retrieved 20 November 2010.
Jump up ^ "Voodoo Envy's Instant-On IOS (powered by Splashtop)". YouTube. Retrieved 20 November 2010.
Jump up ^ "iAPX 286 Programmer's Reference Manual" (PDF). Intel. 1983. Section 5.3 SYSTEM INITIALIZATION, p. 5-7. Retrieved November 5, 2016. Since the CS register contains F000 (thus specifying a code segment starting at physical address F0000) and the instruction pointer contains FFF0, the processor will execute its first instruction at physical address FFFF0H.
Jump up ^ "80386 Programmer's Reference Manual" (PDF). Intel. 1986. Section 10.2.3 First Instructions, p. 10-3. Retrieved November 3, 2013. After RESET, address lines A31-20 are automatically asserted for instruction fetches. This fact, together with the initial values of CS:IP, causes instruction execution to begin at physical address FFFFFFF0H.
Jump up ^ "Intel® 64 and IA-32 Architectures Software Developer's Manual" (PDF). Intel Corporation. May 2012. Section 9.1.4 First Instruction Executed, p. 2611. Retrieved August 23, 2012. The first instruction that is fetched and executed following a hardware reset is located at physical address FFFFFFF0h. This address is 16 bytes below the processor’s uppermost physical address. The EPROM containing the software-initialization code must be located at this address.
Jump up ^ "Intel Platform Innovation Framework for EFI". Intel. Retrieved 2008-01-07.
Jump up ^ "OpenBIOS - coreboot". coreboot.org. Retrieved 2013-03-20.
Jump up ^ "Overview – The four bootloader stages". ti.com. Texas Instruments. December 5, 2013. Retrieved January 25, 2015.
Look up bootup in Wiktionary, the free dictionary.
Retrieved from "https://en.wikipedia.org/w/index.php?title=Booting&oldid=865869251"
Categories:
Booting
BIOS
Boot loaders
Hidden categories:
CS1 Italian-language sources (it)
Articles lacking in-text citations from October 2018
All articles lacking in-text citations
All articles with unsourced statements
Articles with unsourced statements from January 2017
Articles with unsourced statements from August 2012
Navigation menu
Personal tools
Not logged in
Talk
Contributions
Create account
Log in
Namespaces
Article
Talk
Variants
Views
Read
Edit
View history
More
Search
Navigation
Main page
Contents
Featured content
Current events
Random article
Donate to Wikipedia
Wikipedia store
Interaction
Help
About Wikipedia
Community portal
Recent changes
Contact page
Tools
What links here
Related changes
Upload file
Special pages
Permanent link
Page information
Wikidata item
Cite this page
Print/export
Create a book
Download as PDF
Printable version
In other projects
Wikimedia Commons
Languages
Afrikaans
العربية
Azərbaycanca
বাংলা
Bân-lâm-gú
Беларуская
Български
Català
Čeština
Dansk
Deutsch
Eesti
Español
Esperanto
فارسی
Français
Galego
한국어
Hrvatski
Bahasa Indonesia
Íslenska
Italiano
עברית
Latina
Latviešu
Limburgs
Magyar
മലയാളം
Bahasa Melayu
မြန်မာဘာသာ
Nederlands
नेपाल भाषा
日本語
Norsk
Norsk nynorsk
Polski
Português
Русский
Shqip
Simple English
Slovenčina
Српски / srpski
Suomi
Svenska
Tagalog
தமிழ்
తెలుగు
ไทย
Тоҷикӣ
Türkçe
Українська
Tiếng Việt
粵語
中文
45 more
Edit links
This page was last edited on 26 October 2018, at 18:21 (UTC).
Text is available under the Creative Commons Attribution-ShareAlike License; additional terms may apply. By using this site, you agree to the Terms of Use and Privacy Policy. Wikipedia® is a registered trademark of the Wikimedia Foundation, Inc., a non-profit organization.
Privacy policy
About Wikipedia
Disclaimers
Contact Wikipedia
Developers
Cookie statement
Mobile view
Enable previews

key: html

type: local

value: div

attrs: id class

values: mw-page-base noprint

values: mw-head-base noprint

value: a

attrs: id class lang

values: firstHeading firstHeading en

values: siteSub noprint

attrs: class href

values: mw-jump-link #mw-head

values: mw-jump-link #p-search

attrs: alt src width height srcset data-file-width data-file-height

attrs: href title

value: b

values: Wikipedia:WikiProject Fact and Reference Check

value: span

value: i

value: small

values: plainlinks metadata ambox ambox-style ambox-More_footnotes

values:
/wiki/Quickboot_(QEMM)
mw-redirect
Quickboot (QEMM)

values:
/wiki/Boot_(disambiguation)
mw-disambig
Boot (disambiguation)

values:
/wiki/Main_memory
mw-redirect
Main memory

values:
/wiki/Operating_system_kernel
mw-redirect
Operating system kernel

values:
/wiki/Reboot_(computing)
mw-redirect
Reboot (computing)

values:
/wiki/Embedded_systems
mw-redirect
Embedded systems

values:
/wiki/State_machine
mw-redirect
State machine

values: Definition of idiom isn't sufficient evidence of the origin of the term in the context of computer science. (January 2017)

values:
noprint Inline-Template Template-Fact
white-space:nowrap;

values: checkbox button toctogglecheckbox toctogglecheckbox display:none

attrs: alt src width height class srcset data-file-width data-file-height

values: Edit section: Pre integrated-circuit-ROM examples

values: Edit section: First commercial computers

values:
/wiki/Magnetic_drum
mw-redirect
Magnetic drum

values:
/wiki/Punched_card_reader
mw-redirect
Punched card reader

values: Edit section: IBM System/360 and successors

values:
/wiki/Channel_Command_Word
mw-redirect
Channel Command Word

values:
/wiki/Program_Status_Word
mw-redirect
Program Status Word

values:
/wiki/Magnetic_core_memory
mw-redirect
Magnetic core memory

values: Edit section: Early minicomputer boot loader examples

values: Nicolet Instrument Corporation (page does not exist)

values: Edit section: Booting the first microcomputers

values: Edit section: Integrated circuit read-only memory era

values:
/wiki/Apple_Macintosh
mw-redirect
Apple Macintosh

values:
/wiki/Power-on_self_test
mw-redirect
Power-on self test

values:
/wiki/Extensible_Firmware_Interface
mw-redirect
Extensible Firmware Interface

values:
/wiki/Unix_workstation
mw-redirect
Unix workstation

values:
/wiki/Removable_drive
mw-redirect
Removable drive

values:
/wiki/Master_Boot_Record
mw-redirect
Master Boot Record

values:
/wiki/MBR_boot_signature
mw-redirect
MBR boot signature

values:
/wiki/MBR_disk_signature
mw-redirect
MBR disk signature

values:
/wiki/MBR_disk_timestamp
mw-redirect
MBR disk timestamp

values:
/wiki/Advanced_Active_Partition
mw-redirect
Advanced Active Partition

values:
/wiki/Volume_Boot_Record
mw-redirect
Volume Boot Record

values:
/wiki/Extended_BIOS_Parameter_Block
mw-redirect
Extended BIOS Parameter Block

values:
/wiki/SYS_(DOS_command)
mw-redirect
SYS (DOS command)

values:
/wiki/List_of_PC_Booter_games
mw-redirect
List of PC Booter games

values:
/wiki/Universal_Serial_Bus
mw-redirect
Universal Serial Bus

values:
/wiki/Flash_Translation_Layer
mw-redirect
Flash Translation Layer

values:
/wiki/Boot_floppy
mw-redirect
Boot floppy

values:
/wiki/Dual_booting
mw-redirect
Dual booting

values: border: 1px solid #aaa; -moz-border-radius: 0.2em; -webkit-border-radius: 0.2em; border-radius: 0.2em; -moz-box-shadow: 0.1em 0.1em 0.2em rgba(0,0,0,0.1); -webkit-box-shadow: 0.1em 0.1em 0.2em rgba(0,0,0,0.1); box-shadow: 0.1em 0.1em 0.2em rgba(0,0,0,0.1); background-color: #f9f9f9; background-image: -moz-linear-gradient(top, #eee, #f9f9f9, #eee); background-image: -o-linear-gradient(top, #eee, #f9f9f9, #eee); background-image: -webkit-linear-gradient(top, #eee, #f9f9f9, #eee); background-image: linear-gradient(to bottom, #eee, #f9f9f9, #eee); color: #000; padding: 0.1em 0.3em; font-family: inherit; font-size: 0.85em;

values:
/wiki/Serial_Peripheral_Interface_Bus
mw-redirect
Serial Peripheral Interface Bus

values:
/wiki/Word_(data_type)
mw-redirect
Word (data type)

values: Some Compaq BIOSes are known to jump to 07C0h:0000h instead of the correct and official 0000h:7C00h address. This breaks any boot sector/MBR code not written to be relocatible or assuming certain register values on startup. (August 2012)

values:
/wiki/Kernel_(computer_science)
mw-redirect
Kernel (computer science)

values: Edit section: Other kinds of boot sequences

values:
/wiki/Rebooting_(computing)
mw-redirect
Rebooting (computing)

values: -moz-column-width: 18em; -webkit-column-width: 18em; column-width: 18em;

values:
reflist mw-references-wrap
list-style-type: decimal;

values:
/wiki/Oxford_University
mw-redirect
Oxford University

values:
nofollow
external text
http://www.coreboot.org/Tint

values:
/wiki/Intel_Corporation
mw-redirect
Intel Corporation

values:
nofollow
external text
http://www.coreboot.org/OpenBIOS

values: Category:CS1 Italian-language sources (it)

values: Category:Articles lacking in-text citations from October 2018

values: Category:All articles lacking in-text citations

values: Category:All articles with unsourced statements

values: Category:Articles with unsourced statements from January 2017

values: Category:Articles with unsourced statements from August 2012

values: Discussion about edits from this IP address [ctrl-alt-n]

values: A list of edits made from this IP address [ctrl-alt-y]

values: You are encouraged to create an account and log in; however, it is not mandatory

values: You're encouraged to log in; however, it's not mandatory. [ctrl-alt-o]

values:
/wiki/Booting
View the content page [ctrl-alt-c]
c

values: Discussion about the content page [ctrl-alt-t]

values: p-namespaces navigation vectorTabs p-namespaces-label

values:
p-variants
navigation
vectorMenu emptyPortlet
p-variants-label

values:
/w/index.php?title=Booting&action=edit
Edit this page [ctrl-alt-e]
e

values: Past revisions of this page [ctrl-alt-h]

values: p-views navigation vectorTabs p-views-label

values:
p-cactions
navigation
vectorMenu emptyPortlet
p-cactions-label

values:
mw-wiki-logo
/wiki/Main_Page
Visit the main page

values:
/wiki/Main_Page
Visit the main page [ctrl-alt-z]
z

values: Featured content – the best of Wikipedia

values: Find background information on current events

values:
/wiki/Special:Random
Load a random article [ctrl-alt-x]
x

values: portal navigation p-navigation p-navigation-label

values: Guidance on how to use and edit Wikipedia

values: About the project, what you can do, where to find things

values: A list of recent changes in the wiki [ctrl-alt-r]

values: portal navigation p-interaction p-interaction-label

values: List of all English Wikipedia pages containing links to this page [ctrl-alt-j]

values: Recent changes in pages linked from this page [ctrl-alt-k]

values:
/wiki/Wikipedia:File_Upload_Wizard
Upload files [ctrl-alt-u]
u

values: A list of all special pages [ctrl-alt-q]

values: Permanent link to this revision of the page

values: Link to connected data repository item [ctrl-alt-g]

values: Printable version of this page [ctrl-alt-p]

values: portal navigation p-wikibase-otherprojects p-wikibase-otherprojects-label

values:
interlanguage-link interwiki-af
display: none;

values: إقلاع (حاسوب) – Arabic

values:
interlanguage-link interwiki-az
display: none;

values: বুট লোডার – Bangla

values:
interlanguage-link interwiki-bn
display: none;

values:
interlanguage-link interwiki-zh-min-nan
display: none;

values: Загрузчык аперацыйнай сістэмы – Belarusian

values:
interlanguage-link interwiki-be
display: none;

values: Стартиране (компютри) – Bulgarian

values:
interlanguage-link interwiki-bg
display: none;

values:
interlanguage-link interwiki-ca
display: none;

values:
interlanguage-link interwiki-cs
display: none;

values:
https://da.wikipedia.org/wiki/Boot
Boot – Danish
da
da
interlanguage-link-target

values:
interlanguage-link interwiki-da
display: none;

values:
https://de.wikipedia.org/wiki/Booten
Booten – German
de
de
interlanguage-link-target

values:
interlanguage-link interwiki-et
display: none;

values:
https://eo.wikipedia.org/wiki/Startigo
Startigo – Esperanto
eo
eo
interlanguage-link-target

values:
interlanguage-link interwiki-eo
display: none;

values: راه‌اندازی (رایانه) – Persian

values:
interlanguage-link interwiki-fa
display: none;

values:
interlanguage-link interwiki-gl
display: none;

values:
interlanguage-link interwiki-ko
display: none;

values:
interlanguage-link interwiki-hr
display: none;

values:
interlanguage-link interwiki-is
display: none;

values:
https://it.wikipedia.org/wiki/Boot
Boot – Italian
it
it
interlanguage-link-target

values:
interlanguage-link interwiki-it
display: none;

values: אתחול – Hebrew

values:
interlanguage-link interwiki-he
display: none;

values:
interlanguage-link interwiki-la
display: none;

values:
interlanguage-link interwiki-lv
display: none;

values:
https://li.wikipedia.org/wiki/Boot
Boot – Limburgish
li
li
interlanguage-link-target

values:
interlanguage-link interwiki-li
display: none;

values:
https://hu.wikipedia.org/wiki/Boot
Boot – Hungarian
hu
hu
interlanguage-link-target

values:
interlanguage-link interwiki-hu
display: none;

values: ബൂട്ട് ലോഡർ – Malayalam

values:
interlanguage-link interwiki-ml
display: none;

values: ဘုတင်း (ကွန်ပျူတာ) – Burmese

values:
interlanguage-link interwiki-my
display: none;

values:
https://nl.wikipedia.org/wiki/Opstarten
Opstarten – Dutch
nl
nl
interlanguage-link-target

values:
interlanguage-link interwiki-nl
display: none;

values: बुत लोदर – Newari

values:
interlanguage-link interwiki-new
display: none;

values:
interlanguage-link interwiki-ja
display: none;

values:
https://no.wikipedia.org/wiki/Oppstart
Oppstart – Norwegian
no
no
interlanguage-link-target

values:
interlanguage-link interwiki-no
display: none;

values:
https://nn.wikipedia.org/wiki/Oppstart
Oppstart – Norwegian Nynorsk
nn
nn
interlanguage-link-target

values:
interlanguage-link interwiki-pl
display: none;

values:
https://pt.wikipedia.org/wiki/Boot
Boot – Portuguese
pt
pt
interlanguage-link-target

values: Загрузчик операционной системы – Russian

values:
https://sq.wikipedia.org/wiki/Booting
Booting – Albanian
sq
sq
interlanguage-link-target

values:
interlanguage-link interwiki-sq
display: none;

values:
interlanguage-link interwiki-sk
display: none;

values:
interlanguage-link interwiki-sr
display: none;

values:
interlanguage-link interwiki-fi
display: none;

values:
https://sv.wikipedia.org/wiki/Bootning
Bootning – Swedish
sv
sv
interlanguage-link-target

values:
interlanguage-link interwiki-sv
display: none;

values:
interlanguage-link interwiki-tl
display: none;

values: தொடக்க ஏற்றி – Tamil

values:
interlanguage-link interwiki-ta
display: none;

values: బూటింగ్ – Telugu

values:
interlanguage-link interwiki-te
display: none;

values: การปลุกเครื่อง – Thai

values:
interlanguage-link interwiki-th
display: none;

values: Роҳандозӣ – Tajik

values:
interlanguage-link interwiki-tg
display: none;

values:
https://tr.wikipedia.org/wiki/Booting
Booting – Turkish
tr
tr
interlanguage-link-target

values: Завантаження операційної системи – Ukrainian

values:
interlanguage-link interwiki-uk
display: none;

values:
interlanguage-link interwiki-vi
display: none;

values:
interlanguage-link interwiki-zh-yue
display: none;

values: All languages (initial selection from common choices by you and others)

values:
suggestions
display: none; font-size: 13px;

values: mediawiki ltr sitedir-ltr mw-hide-empty-elt ns-0 ns-subject page-Booting rootpage-Booting skin-vector action-view