IMG (file format)

Files created using this format typically use the ".IMG" file extension.
>resides on the hard drive,
>but is recognized by the computer as a disc or hard disk when mounted.

Use

IMG files are used for:

* Digital storage, transmission, and replication of floppy disks.
* Mounting virtual floppy disk volumes.

Linux Startup Sequence

To trace the full startup sequence from hardware powerup to shell, we'll assume: x86 hardware, the boot manager is LILO installed in the MBR, the kernel is on the hard disk, the system normally starts in runlevel 3, the example user's shell is bash, and the system is not using X Windows. Other possibilities are indicated where appropriate.

Hardware

1. When the computer power is turned on, a special circuit signals the RESET pin of the CPU.
2. The CPU resets its registers and executes the code at a fixed address (0xFFFFFFF0), the starting point of the BIOS (Basic Input/Output System).

BIOS

3. Executes the POST (Power-On Self-Test) and displays various banners on the monitor screen.
4. Initializes the hardware devices and maps IRQs for PCI devices.
5. Searches for an operating system to load (usually floppy disk then CD-ROM then hard disk).
6. Copies first sector of operating system device into memory and begins execution.

LILO Bootloader

7. Only part of LILO fits into the MBR (the first sector loaded by the BIOS) so its role is to load the rest of the bootloader code into memory and begin execution of that code. (If the system was booted from a floppy, a portion of the kernel itself is located in the first sector--enough to load the rest of the compressed kernel image into memory.)
8. Displays a timed prompt for the user to choose a kernel to load.
9. Loads the full kernel image into memory and begins execution at the setup() function entry point.

Kernel

10. setup(): determines amount of RAM, initializes keyboard and mouse, initializes video adapter, looks up hard disk partitions, resets the FPU, maps the IRQ lines, switches the CPU from Real to Protected mode, and finally jumps to Part I of the startup_32() function.
11. startup_32() Part I: decompresses the kernel, and jumps to the now uncompressed Part II of the startup_32() function.
12. startup_32() Part II: initializes internal kernel tables, identifies the processor type, and then jumps to the start_kernel() function.
13. start_kernel(): initializes the memory management tables, finalizes the interrupt tables, spawns the kernel threads (which are responsible for the dmesg messages as they complete the system initialization), and finally launches init as process ID (PID) 1.

init

14. Reads the /etc/inittab configuration file.
15. Sets the default runlevel.
16. Runs the rc.sysinit script which: enables disk swapping, checks and mounts filesystems, and synchronizes the system time with the CMOS clock. The rc.sysinit script is responsible for the OK messages that appear during the startup before entering interactive/non-interactive mode.
17. Runs the rc script, passing the runlevel as a parameter. The rc script in turn starts or stops all of the services in the approprate rcN.d directory in numerical order. Usually the rc.local script is run last. The rc script is responsible for the OK messages that appear during the startup after entering interactive/non-interactive mode.
18. Installs the Ctrl+Alt+Del interrupt handler (usually a form of shutdown ).
19. Starts the virtual terminals using a variant of the getty program which in turn run login to accept user logins.

login

20. User logs in through one of the tty processes (virtual terminals).
21. Authenticates the login and password against the /etc/passwd file.
22. Runs the /etc/profile script to set global user settings.
23. Sets the current working directory to the user's home directory (from /etc/passwd).
24. Launches the user's preferred shell (from /etc/passwd).

bash

25. Runs the .bash_profile script to set personalized shell settings. Typically .bash_profile in turn calls .bashrc for the bulk of the settings. On subsequent opening of subshells, only the .bashrc script is run.
26. The command line prompt signals to the user that the shell is ready to accept commands.

User space and kernel space

When you write device drivers, it’s important to make the distinction between “user space” and “kernel space”.

* Kernel space. Linux (which is a kernel) manages the machine’s hardware in a simple and efficient manner, offering the user a simple and uniform programming interface. In the same way, the kernel, and in particular its device drivers, form a bridge or interface between the end-user/programmer and the hardware. Any subroutines or functions forming part of the kernel (modules and device drivers, for example) are considered to be part of kernel space.
* User space. End-user programs, like the UNIX shell or other GUI based applications (kpresenter for example), are part of the user space. Obviously, these applications need to interact with the system’s hardware . However, they don’t do so directly, but through the kernel supported functions.

All of this is shown in figure 1.

Figure 1: User space where applications reside, and kernel space where modules or device drivers reside

What is the difference between a daemon and a server process?

A 'daemon' is a software process that runs in the background (continuously) and provides the service to client upon request.

For example
* named is a daemon. When requested it will provide DNS service. Other examples are:

* xinetd (it is a super-daemon, it is responsible for invoking other Internet servers when they are needed)
* inetd (same as xinetd, but with limited configuration options)
* sendmail/postfix (to send/route email)
* Apache/httpd (web server)



A 'server process' run runs one time, when called by a daemon. Once done it will stop. For example telnetd (in.telnetd) or ftpd called from xinetd/inetd daemon . By calling server process from daemon you can save the load and memory. Use a server process for small services such as ftpd, telnetd

What is EEPROM?

1.EEPROM (also written E2PROM and pronounced "e-e-prom," "double-e prom" or simply "e-squared") stands for Electrically Erasable Programmable Read-Only Memory and is a type of non-volatile memory used in computers and other electronic devices to store small amounts of data that must be saved when power is removed, e.g., calibration tables or device configuration.

When larger amounts of static data are to be stored (such as in USB flash drives) a specific type of EEPROM such as flash memory is more economical than traditional EEPROM devices.



2.Electrically Erasable Programmable Read-Only Memory (EEPROM): A special nonvolatile memory that can be erased and (re)programmed electrically. Commonly used in contact and contact-less smart cards. Retains the content of its memory even when the power is turned off.


3.Electrical Erasable ROM (EEPROM) It is inconvenient to have to remove a chip to prepare it for programming using a separate light source. EEPROMs allow the erasing of data to be achieved with the ROM in situ. The main difference between EPROMs and EEPROMs is the way that they discharge the charge stored in the floating gate. Fowler-Nordheim tunnelling technique (allowing low energy electrons to jump the gap) this alows the gate to be discharged when required. It is possible to change just individual locations.


4.EEPROM (Electrically Erasable Programmable Read-Only Memory)
A small memory chip that retains data even without power.


5.EEPROM (Electrically Erasable Programmable Read-Only Memory): A non-volatile storage device on microchips. Usually bytes can be erased and reprogrammed individually.

List of Linux kernel names

List of Linux kernel names

What are Different versions of linux kernels available in Market?

Yet to be answered .........

Booting and Boot Managers in suse

http://www.novell.com/documentation/suse91/suselinux-adminguide/html/ch07.html

Linux/UNIX treats everything like a file.

1. Linux/UNIX treats everything like a file.
2. When it's writing to your screen it thinks it's just writing to a file.
3. When it sends data through a modem it thinks it's just writing to a file.
4. As a result, all your hardware, including

ports,
hard-drives,
video cards, etc.
on your system must be represented somehow somewhere in the file system.

Linux Resources for Educators

Below are links to some of the best websites about the use of Linux and other open source software in educational institutions:

---

Authenticated User Community - an intranet system for kindergarten through high school use which provides a uniform web-based interface for discussion forums, e-mail, file management and a searchable user database. Also, "Interactive Classrooms" provide a means for students and teachers to have a web-based extension to their in-class interaction.

The Case for Linux in Universities - a long, single-page article with numerous links.

Discussion on using Linux in education - provides a mailing list, a catalog of free educational software and Linux case studies.

Fossil Lab Home Page - the Free/Open Source Laboratory at Worcester Polytechnic Institute (in Worcester, MA) is funded under an NSF grant. It allows students to run experiments on dedicated machines, do kernel "hacking" and gain valuable system administration experience that is not possible in conventional computer science laboratories.

K12Admin - a system developed in Northern British Columbia, Canada for administering Linux servers in individual kindergarten through 12th grade schools. It allows the staff in each school to maintain their own student and staff accounts while providing a homogeneous network throughout the school district.

K-12 Linux Project - contains three linked sites providing software, tutorials and discussion forums.

LearnLoop - open source groupware being developed to support education and collaboration.

Linux and Education - an article by the Bellevue Linux Users Group that discusses the advantages of using Linux rather than proprietary software in the classroom.

Linux in Higher Education: Open Source, Open Minds, Social Justice - a 2000 article in Linux Journal advocating the adoption of Linux as an international standard for computing in higher education.

The Linux for Schools Project - a single page site (as of March, 2004) that explains techniques for efficiently adding and removing large numbers of user accounts.

Open Administration for Schools - an open source school administration program. It can support multiple schools on single, central server and provides separate, secure websites for use both by the school office and by teachers in the classroom.

The Open Source Education Foundation - a non-profit company devoted to enhancing kindergarten through high school education through the use of technologies and concepts derived from the open source and free software movements.

Open Source Software in American Public Schools - an article by Bill French, a graduate student at the University of California at Berkeley's School of Information Management and Systems.

Penguin Enrolls in U.S. Schools - a 2001 article from Wired.

Open Source Educational Group - information about open source computing for educational and governmental institutions.

Schoolforge News-Journal - provides articles and links as well as tools and materials to create a school and all its parts.

Software Freedom, Open Software and the Undergraduate Computer Science Curriculum - an article by John Howland of the Department of Computer Science, Trinity University in San Antonio, Texas.

Open Source in Education - an informal essay designed to help educators better understand open source software.

Site@School - a program to manage and maintain the website of a primary school without technical knowledge. Pupils can have personal pages on the site and teachers can check them before publication.

SWEEPING INITIATIVE PUTS 80,000 COMPUTERS RUNNING GNOME . . . - a brief article about the installation by the regional government of Extremadura, Spain of 80,000 Linux computers in its schools.

Trinity drinks deeply at learning's open source - a 2001 article by Nathan Cochrane about how Trinity College at Melbourne University (in Melbourne, Australia) discarded its Windows NT network and replaced it with Debian Linux.

Why should open source software be used in schools? - a brief article followed by numerous comments from educators.

How to Find The Kernel Version

It can be useful to know the version number of the kernel (i.e., the core of the operating system) on a particular Linux system. Not only is it instructive in itself, but it can also be helpful in diagnosing and upgrading systems because each release of the kernel contains some differences, sometimes minor and sometimes substantial.

Fortunately, it is extremely easy to obtain this information, and, in fact, there is a choice of at least five ways to do it. Moreover, each of these techniques can also be used, with slight modification, to obtain additional information about a system.

Perhaps the easiest is to use the uname command (which reports basic information about a system's hardware and software) with its -r option, that is,

uname -r

This method has the advantages that only a minimal amount of typing is required and that it provides just information about the kernel with no extra output to search through.

A second way is to look at the /proc/version file. This can be easily accomplished by using the cat command (which is commonly used to read and concatenate files), i.e.,

cat /proc/version

A third way is to use the rpm (i.e., Red Hat package manager) command with its -q (i.e., query) option and use the word kernel as an argument (i.e., input data) as follows:

rpm -q kernel

This method has the advantage that it provides output information solely about the kernel. However, it has the disadvantage that it only works on distributions (i.e., versions) of Linux that use the rpm package system, such as those based on Red Hat.

A fourth method is to look at the contents of the dmesg command, which is used to report information about the system as it boots up (i.e., starts up). Because dmesg generates a large amount of output, it is convenient to first transfer that output using a pipe (represented by the vertical bar character) to the grep filter with the word Linux as an argument in order to display only lines that contain that word (and thus the kernel version information) as follows:

dmesg | grep Linux

The disadvantages of this method are that it requires some extra typing and that there is still a lot of output to search through even though it has been greatly reduced through the use of the grep filter.

A fifth method is to look in directories in which the kernel or its source code (i.e., the original version as written by humans in a programming language) is kept. There can be differences among systems, and some systems might not contain the source code. However, the kernel frequently resides in the boot directory, and thus its name, which includes the version and release numbers, can be found by using the ls command (which lists the contents of a directory) with that directory as an argument as follows:

ls /boot

This command will likely produce several references to the version of the currently installed and running kernel. Among them should be an entry such as vmlinuz-2.4.20-6 (in the case of kernel version 2, major release 4, minor release 20). vmlinuz is a compressed Linux kernel, and it is bootable, which means that it is capable of loading the operating system into memory so that the computer becomes usable and application programs can be run.

User Space Definition

User space is that portion of system memory in which user processes run. This contrasts with kernel space, which is that portion of memory in which the kernel executes and provides its services.

The contents of memory, which consists of dedicated RAM (random access memory) VLSI (very large scale integrated circuit) semiconductor chips, can be accessed (i.e., read and written to) at extremely high speeds but are retained only temporarily (i.e., while in use or, at most, while the power supply remains on). This contrasts with storage (e.g., disk drives), which has much slower access speeds but whose contents are retained after the power is turned off and which usually has a far greater capacity.

A process is an executing (i.e., running) instance of a program. User processes are instances of all programs other than the kernel (i.e., utility and application programs). When a program is to be run, it is copied from storage into user space so that it can be accessed at high speed by the CPU (central processing unit).

The kernel is a program that constitutes the central core of a computer operating system. It is not a process, but rather a controller of processes, and it has complete control over everything that occurs on the system. This includes managing individual user processes within user space and preventing them from interfering with each other.

The division of system memory in Unix-like operating systems into user space and kernel space plays an important role in maintaining system stability and security.

User Mode Definition

User mode is one of two distinct execution modes for the CPU (central processing unit) in Linux.

It is a non-privileged mode in which each process (i.e., a running instance of a program) starts out. It is non-privileged in that it is forbidden for processes in this mode to access those portions of memory (i.e., RAM) that have been allocated to the kernel or to other programs. The kernel is not a process, but rather a controller of processes, and it alone has access to all resources on the system.

When a user mode process (i.e., a process currently in user mode) wants to use a service that is provided by the kernel (i.e., access system resources other than the limited memory space that is allocated to the user program), it must switch temporarily into kernel mode, which has root (i.e., administrative) privileges, including root access permissions (i.e., permission to access any memory space or other resources on the system). When the kernel has satisfied the process's request, it restores the process to user mode.

This change in mode is termed a mode switch, which should not be confused with a context switch (i.e., the switching of the CPU from one process to another). The standard procedure to switch from user mode to kernel mode is to call the 0x80 software interrupt.

An interrupt is a signal to the operating system that an event has occurred, and it results in changes in the sequence of instructions that is executed by the CPU. In the case of a hardware interrupt, the signal originates from a hardware device such as a keyboard (e.g., when a user presses a key), mouse or system clock (a circuit that generates pulses at precise intervals that are used to coordinate the computer's activities). A software interrupt is an interrupt that originates in software, usually by a program in user mode.

Multitasking Definition

Multitasking refers to an operating system in which multiple processes, also called tasks, can execute (i.e., run) on a single computer seemingly simultaneously and without interfering with each other. That is, each process has the illusion that it is the only process on the computer and that it has exclusive access to all the services of the operating system.

The concurrently running processes can represent different programs, different parts of a single program and different instances of a single program. The total number of processes (or programs) that can run on the system at any time depends on several factors including the size of the memory, the speed of the CPU (central processing unit) and the size of the programs.

All processes are fully protected from each other, just as the kernel (i.e., the core of an operating system) on a well-designed system is protected from all processes, so that a crash (i.e., a halt to functioning) in one process or program will not cause another program or the entire system to crash. However, processes communicate with each other when necessary.

The CPU (or CPUs if there are more than one) is continuously in demand by the typically numerous processes that are competing for its services. But because a CPU can execute only one process at a time, multitasking is accomplished through the use of a time slice technique that alternates its use at extremely high speeds among the various processes.

In unitasking operating systems, such as MS-DOS, the CPU remains idle until the system resource that a process desires (such as a disk drive or printer) becomes available, thus wasting processor time and reducing system efficiency. In a multitasking system, however, multiple processes are retained in the main memory, which physically consists of RAM (i.e., random access memory) chips, so that whenever one process has to wait, the operating system can immediately allocate the CPU to other processes.

Origins of Multitasking

Multitasking originated in the 1960s, when time sharing systems were developed to enable multiple users to share single, and very costly, mainframe computers. It soon became apparent that a similar technique could also be used to allow a single user to simultaneously run multiple application programs. The term time sharing was subsequently replaced by the more general term multitasking.

On early multitasking systems, groups of related application programs voluntarily relinquished the CPU to each other in what is referred to as cooperative multitasking. One disadvantages of that approach is that the scheduler cannot make system-wide decisions as to how long each process should run, which can result in the inefficient use of system resources. The scheduler is a part of the kernel that assigns priorities to processes in a priority queue.

Another disadvantage is that it can be more difficult to develop application programs for use on such operating systems. In addition, a poorly designed program or a crashed process can potentially crash the entire operating system because it could prevent a process from relinquishing the CPU to other processes.

Thus, cooperative multitasking evolved into preemptive multitasking, in which the hardware can interrupt an executing process and instruct the CPU to execute a different section of code. Such a system does not need to rely on the voluntary relinquishing of processor time by individual processes. Rather, it can be set to preempt currently running processes and return control to the operating system, which can later restore each preempted process in exactly the same state where it was interrupted. Preemption is the involuntary suspension of some running processes so that other processes can be executed.

Preemptive multitasking increases overall system efficiency by freeing up the CPU and other system resources when ordered to by the operating system on a time slice basis or a priority basis so that one application cannot monopolize system resources when they are needed by another program. It also permits the system to respond immediately to important external events, such as incoming data from a keyboard or network. Moreover, it simplifies the development of application programs and provides better program performance because processes can switch in and out of the processor with less overhead, i.e., with less and simpler code.

Multitasking is particularly crucial for real time operating systems (such as are used in embedded systems), for which it is necessary to monitor and control multiple external activities with a single processor virtually instantaneously. Such systems employ a hierarchical interrupt mechanism together with prioritization of processes to ensure that specified types of activities are granted an immediate and adequate slice of processor time.

Multitasking in Linux

Today most major operating systems employ multitasking. Earlier versions of the Macintosh and Microsoft Windows used cooperative multitasking. Preemptive multitasking operating systems include Linux and other Unix-like systems, Microsoft Windows NT/2000/XP, Mac OS X and OS/2.

Unix-like operating systems were developed right from the start as preemptive multitasking and multi-user systems. These are among the features that have helped make them an extremely efficient and robust (as well as highly successful and long-lived) family of operating systems. (They are also multiprocessor operating systems, which means that they can make effective use of computers that have more than a single CPU.)

Multiple processes exist for virtually the entire duration of a Linux session, even if no user application programs are running. The only exception is a very brief period during booting (i.e., starting up of a computer), when init, which is the first process to be created on a newly booted system, has not yet spawned additional processes.

Multitasking can be easily observed in Unix-like operating systems when the X Window System (i.e., the standard system for managing GUIs on single computers and on networks of computers) is used. That is, multiple windows can be simultaneously open on the display screen, each with an application program running independently of the others. The independence of these applications is evidenced by the fact that, as experienced Linux users are well aware, even if one of the applications crashes, it is very rare that it will cause other applications to malfunction or cause the system as a whole to crash (and thus require rebooting).

While not quite as obvious, especially to new users, multitasking is also occurring when a Unix-like system is operating in console (i.e., text only) mode. That is, different programs can be operating on different virtual consoles. Moreover, multiple programs can also operate on a single console or terminal window (i.e., a window in a GUI that emulates console mode) by having one program run in the foreground while others are running in the background.
The full extent of processes currently residing on a can be seen by using the ps command with its -a, -u and -x options, i.e.,

ps -aux | less

As the number of processes can be quite long and occupy more than a single screen, this command uses a pipe (represented by the vertical bar) to transfer the output of ps -aux to the less command so that that it can be viewed one screenful at a time. The list of processes can be advanced one screen forward by pressing the SPACE bar and one screen backward by pressing the b key. An alternative way to view the processes is with the pstree command, which presents them in a tree diagram.

Several instances of a single program may be visible in the output from either of these commands. If they are not, a simple way to start two instances of a single program is to open a second terminal window. This results in another shell process being started. Repeating the above command will then show the processes for both instances of bash (which is the default shell on Linux) or whatever shell is being used.

Daemon Definition

A daemon is a type of program on Unix-like operating systems that runs unobtrusively in the background, rather than under the direct control of a user, waiting to be activated by the occurance of a specific event or condition.

Unix-like systems typically run numerous daemons, mainly to accommodate requests for services from other computers on a network, but also to respond to other programs and to hardware activity. Examples of actions or conditions that can trigger daemons into activity are a specific time or date, passage of a specified time interval, a file landing in a particular directory, receipt of an e-mail or a Web request made through a particular communication line. It is not necessary that the perpetrator of the action or condition be aware that a daemon is listening, although programs frequently will perform an action only because they are aware that they will implicitly arouse a daemon.

Daemons are usually instantiated as processes. A process is an executing (i.e., running) instance of a program. Processes are managed by the kernel (i.e., the core of the operating system), which assigns each a unique process identification number (PID).

There are three basic types of processes in Linux: interactive, batch and daemon. Interactive processes are run interactively by a user at the command line (i.e., all-text mode). Batch processes are submitted from a queue of processes and are not associated with the command line; they are well suited for performing recurring tasks when system usage is otherwise low.

Daemons are recognized by the system as any processes whose parent process has a PID of one, which always represents the process init. init is always the first process that is started when a Linux computer is booted up (i.e., started), and it remains on the system until the computer is turned off. init adopts any process whose parent process dies (i.e., terminates) without waiting for the child process's status. Thus, the common method for launching a daemon involves forking (i.e., dividing) once or twice, and making the parent (and grandparent) processes die while the child (or grandchild) process begins performing its normal function.

Some daemons are launched via System V init scripts, which are scripts (i.e., short programs) that are run automatically when the system is booting up. They may either survive for the duration of the session or be regenerated at intervals.

Many daemons are now started only as required and by a single daemon, xinetd (which has replaced inetd in newer systems), rather than running continuously. xinetd, which is referred to as a TCP/IP super server, itself is started at boot time, and it listens to the ports assigned to the processes listed in the /etc/inetd.conf or in /etc/xinetd.conf configuration file. Examples of daemons that it starts include crond (which runs scheduled tasks), ftpd (file transfer), lpd (laser printing), rlogind (remote login), rshd (remote command execution) and telnetd (telnet).

In addition to being launched by the operating system and by application programs, some daemons can also be started manually. Examples of commands that launch daemons include binlogd (which logs binary events to specified files), mysqld (the MySQL databse server) and apache (the Apache web server).

In many Unix-like operating systems, including Linux, each daemon has a single script (i.e., short program) with which it can be terminated, restarted or have its status checked. The handling of these scripts is based on runlevels. A runlevel is a configuration or operating state of the system that only allows certain selected processes to exist. Booting into a different runlevel can help solve certain problems, including repairing system errors.

The term daemon is derived from the daemons of Greek mythology, which were supernatural beings that ranked between gods and mortals and which possessed special knowledge and power1. For example, Socrates claimed to have a daemon that gave him warnings and advice but never coerced him into following it. He also claimed that his daemon exhibited greater accuracy than any of the forms of divination practiced at the time.

The word daemon was first used in a computer context at the pioneering Project MAC (which later became the MIT Laboratory for Computer Science) using the IBM 7094 in 1963. This usage was inspired by Maxwell's daemon of physics and thermodynamics, which was an imaginary agent that helped sort molecules of different speeds and worked tirelessly in the background. The term was then used to describe background processes which worked tirelessly to perform system chores. The first computer daemon was a program that automatically made tape backups. After the term was adopted for computer use, it was rationalized as an acronym for Disk And Execution MONitor.

On the Microsoft Windows operating systems, programs called services perform the functions of daemons, although the term daemon is now sometimes being used with regard to those systems as well.

________
1 A daemon should be distinguished from a demon, which is an evil spirit in some religions.

vmlinuz Definition

vmlinuz is the name of the Linux kernel executable.

A kernel is a program that constitutes the central core of a computer operating system. It is the first thing that is loaded into memory (which physically consists of RAM chips) when a computer is booted up (i.e., started), and it remains in memory for the entire time that the computer is in operation. An executable, also called an executable file, is a file that can be run as a program.

vmlinuz is a compressed Linux kernel, and it is bootable. Bootable means that it is capable of loading the operating system into memory so that the computer becomes usable and application programs can be run.

vmlinuz should not be confused with vmlinux, which is the kernel in a non-compressed and non-bootable form. vmlinux is generally just an intermediate step to producing vmlinuz.

vmlinuz is located in the /boot directory, which is the directory that contains the files needed to begin booting the system. The file named vmlinuz might be the actual kernel executable itself, or it could be a link to the kernel executable, which might bear a name such as /boot/vmlinuz-2.4.18-19.8.0 (i.e., the name of the specific version of the kernel). This can be easily determined by using the ls command (whose purpose is to list the contents of a specified directory) with its -l option (which tells ls to provide detailed information about each object in the specified directory) as follows:

ls -l /boot

If vmlinuz is an ordinary file (including an executable), the information about it in the first column will begin with a hyphen. If it is a link, it will begin with the letter l.

The Linux kernel is compiled by issuing the following command:

make bzImage

This results in the creation of a file named bzImage in a directory such as /usr/src/linux/arch/i386/linux/boot/.

Compilation is the conversion the kernel's source code (i.e., the original form in which the kernel is written by a human) into object code (which is understandable directly by a computer's processor). It is performed by a specialized program called a compiler, usually one in the GCC (GNU Compiler Collection).

bzImage is then copied using the cp (i.e., copy) command to the /boot directory and simultaneously renamed vmlinuz with a command such as

cp /usr/src/linux/arch/i386/linux/boot/bzImage /boot/vmlinuz

vmlinuz is not merely a compressed image. It also has gzip decompressor code built into it. gzip is one of the most popular compression utilities on Unix-like operating systems.

A compiled kernel named zImage file is created on some older systems and is retained on newer ones for backward compatibility. Both zImage and bzImage are compressed with gzip. The difference is that zImage decompresses into low memory (i.e., the first 640kB), and bzImage decompresses into high memory (more than 1MB). There is a common misconception that bzImage is compressed with the bzip2 utility; actually, the b just stands for big.

The name vmlinuz is largely an accident of history. The kernel binary on the original UNIX as developed at Bell Labs was called unix. When a new kernel containing support for virtual memory was subsequently written at the University of California at Berkeley (UCB), the kernel binary was renamed vmunix.

Virtual memory is the use of space on a hard disk drive (HDD) to simulate additional RAM (random access memory) capacity. It was supported by the Linux kernel almost from Linux's inception, in contrast to some other popular operating systems in use at the time, such as MS-DOS.

Thus, it was a natural progression for the Linux kernel to be called vmlinux. And because the Linux kernel executable was made into a compressed file and compressed files typically have a z or gz extension on Unix-like systems, the name of the compressed kernel executable became vmlinuz.