Linux kernels without Network Support
Very old Linux kernels, or non-standard packages, may not have networking compiled into the kernel.
In this case, the kernel will not detect ethernet devices or other network interfaces. You must rebuild the kernel (or obtain a newer release) to use networking.
Nowadays, it is hard to imagine a Linux kernel that does not provide network support.
Overview of Operating Systems and Kernels
Because of the ever-growing feature set and ill design of some modern commercial operating systems, the notion of what precisely defines an operating system is not universal.
Many users consider whatever they see on the screen to be the operating system. Technically speaking, and in this book, the operating system is considered the parts of the system responsible for basic use and administration.
This includes the kernel and device drivers, boot loader, command shell or other user interface, and basic file and system utilities. It is the stuff you need, not a web browser or music players. The term system refers to the operating system and all the applications running on top of it. Of course, the topic of this book is the kernel. Whereas the user interface is the outermost
portion of the operating system, the kernel is the innermost. It is the core internals; the software that provides basic services for all other parts of the system, manages hardware, and distributes system resources.
The kernel is sometimes referred to as the supervisor, core, or internals of the operating system.Typical components of a kernel are interrupt handlers to service interrupt requests, a scheduler to share processor time
among multiple processes, a memory management system to manage process address spaces, and system services such as networking and interprocess communication.
On modern systems with protected memory management units, the kernel typically resides in an elevated system state compared to normal user applications.
This includes a protected memory space and full access to the hardware. This system state and memory space is collectively referred to as kernel-space. Conversely, user applications execute in user-space.
They see a subset of the machine's available resources and can perform certain system functions, directly access hardware, access memory outside of that allotted them by the kernel, or otherwise misbehave.
When executing kernel code, the system is in kernel-space executing in kernel mode. When running a regular process, the system is in user-space executing in user mode.
Applications running on the system communicate with the kernel via system calls. An application typically calls functions in a library.
For example, the C library, which relies on the system call interface to instruct the kernel to carry out tasks on the application's behalf.
Some library calls provide many features not found in the system call, and thus, calling into the kernel is just one step in an otherwise large function.
For example, consider the familiar
printf() function. It provides formatting and buffering of the data; only one step in its work is invoking write() to write the data to the console.
Conversely, some library calls have a one-to-one relationship with the kernel. For example, the open() library function does little except call the open() system call.
Still other C library functions, such as
strcpy(), should (one hopes) make no direct use of the kernel at all.When an application executes a system call, we say that the kernel is executing on behalf of the application.
Furthermore, the application is said to be executing a system call in kernel-space, and the kernel is running in process context.
This relationship, that applications call into the kernel via the system call interface is the fundamental manner in which applications get work done.