The book “Linux Internals. Linux internals Linux internals

Current page: 1 (book has 30 pages total) [available reading passage: 17 pages]

Brian Ward

Linux Internals

Translator S. Chernikov

Technical editor N. Grinchik

Literary editor O. Andrievich

Artists A. Bartsevich, V. Shimkevich

Proofreaders T. Kuryanovich, E. Pavlovich

Layout A. Bartsevich

Brian Ward

Linux Internals. – St. Petersburg: Peter, 2015.

ISBN 978-5-496-01952-1

Preface

I wrote this book with the belief that to be successful and efficient, you must understand how your computer software works and works.

The Linux operating system is great for learning because most of the system configuration is stored in simple files that are fairly easy to read. You just have to figure out what each part is responsible for, and then put everything together. This is what this book is dedicated to.

Interest in the design of the Linux operating system can be caused by various reasons. Information technology professionals and Linux software developers will find in this book virtually everything they need to know to get the most out of the operating system. Researchers and students, who often have to customize the system for themselves, will find here practical explanations of why things work the way they do. There are also “entertainers” - users who like to spend time on the computer for fun, profit, or both.

Want to know why some things work and others don't? Are you wondering what will happen if you change something? Then you are one of the “entertainers”.

The necessary conditions

You don't have to be a programmer to read this book. You will only need basic computer user skills: you must navigate the graphical interface (when installing and configuring the system interface), as well as have an understanding of files and directories (folders). You should also be prepared to search your system and online for additional documentation. As noted above, the most important thing is your willingness and desire to explore your computer.

When it comes to technical subjects, conveying all the necessary knowledge is not an easy task. On the one hand, the reader gets bogged down in unnecessary details and has difficulty grasping the essence, since the human mind simply cannot process a large number of new concepts at the same time. On the other hand, the lack of details leads to the fact that the reader receives only a vague idea of the subject and is not ready to assimilate further material.

In this book I have simplified the presentation and structured the material. In most chapters, important information that is needed for further work is presented first. As you read the chapter, you will encounter additional material in it. Do you need to immediately grasp these particulars? In most cases I think not. If your eyes begin to glaze over the amount of detail related to the material you just learned, don't hesitate to move on to the next chapter or take a break. Other important things await you.

Practical approach

To work you will need a computer with the Linux operating system. You may prefer a virtual installation—I used VirtualBox to test most of the material in this book. You must have superuser (root) access, although you should use a standard user account most of the time. You will work primarily at the command line, terminal window, or remote session. If you haven't worked in this environment often, that's okay; you'll learn more about it in Chapter 2.

Typically the commands will look like this:

Enter text that is highlighted in bold; The response text that the machine will produce is shown in normal font. The $ symbol is a prompt for a user with a regular account. If you see a # symbol at the prompt, you should be using the superuser account (more on this in Chapter 2).

How is this book organized?

The book begins with an overview of the Linux system and then provides a series of hands-on exercises with the tools you'll need to get started with the system. Next, you'll explore each part of the system in detail, from hardware management to network configuration, following the normal order in which the system starts up. Finally, you'll gain an understanding of some of the details of a working system, learn some important skills, and become familiar with the tools programmers use.

Most of the early chapters (except Chapter 2) focus heavily on the Linux kernel, but as you progress through the book you'll also work in your user space. If you don't understand what I'm talking about now, don't worry, explanations will be given in Chapter 1.

The material is presented whenever possible without reference to any system distribution. It would be boring to describe all the system variants, so I tried to talk about the two main families of distributions: Debian (including Ubuntu) and RHEL/Fedora/CentOS. The emphasis is on server and workstation versions. Embedded systems such as Android and OpenWRT are also represented, but learning the differences between these platforms is left to you.

What's new in the second edition

The first edition of this book dealt mainly with the user side of working on a Linux system. The main focus was on the design of its parts and how to make them function. At that time, many elements of the system were difficult to install and configure correctly.

Thanks to the hard work of software developers and Linux distribution creators, this has changed. I've reviewed the first edition's material for updates, paying particular attention to the system's boot process and how it manages hardware, and removing outdated material (such as a detailed explanation of the printing process) to expand the discussion of the role of the Linux kernel in each distribution. You probably interact with the kernel more often than you realize, and I've specifically noted the times when this happens.

I have also reordered the book's presentation to suit the interests and needs of today's readers. The only thing that hasn't changed is the length of the book.

I wanted to provide you with the information you need to get started quickly. They will take some effort to master, but I do not intend to make you a “weightlifter” so that you can overcome this book. Once you understand the important points outlined here, it will be easy for you to find the details and understand them.

I have removed some historical details that were in the first edition, mainly to focus your attention. If you are interested in the Linux system and its relationship to the history of the Unix system, check out the book by Peter H. Salus The Daemon, the Gnu, and the Penguin(Reed Media Services, 2008) - It talks about how the software we use has evolved.

A note on terminology

Currently, there is debate about the names of some elements of operating systems. Even the name of the Linux system is involved - should it be called Linux or GNU/Linux (to reflect the use of some elements of the GNU project)? In the book, I tried to use the most common and least cumbersome names possible.

Acknowledgments

I thank everyone who helped me work on the first edition. These are James Duncan, Douglas N. Arnold, Bill Fenner, Ken Hornstein, Scott Dickson, Dan Ehrlich, Felix Lee Felix Lee, Scott Schwartz, Gregory P. Smith, Dan Sully, Karol Jurado and Gina Steele. For this edition, I especially thank Jordi Gutiérrez Hermoso for his excellent technical review; his suggestions and clarifications are invaluable. Thanks also to Dominique Poulain and Donald Karon for their quick response in the early stages of the work, and to Hsinju Hsieh, who patiently worked with me to revise this book.

I'd also like to thank my development editor, Bill Pollock, and production editor, Laurel Chun. Serena Yang, Alison Law, and everyone at No Starch Press have, as always, done a wonderful job producing this new edition of the book.

From the publisher

Please send your comments, suggestions and questions by email [email protected](Peter publishing house, computer edition).

We'd love to hear your opinion!

On the publishing house website http://www.piter.com you will find detailed information about our books.

1. The big picture

At first glance, a modern operating system, such as Linux, is quite complex and consists of a large number of parts that simultaneously function and interact with each other. Thus, a web server can communicate with a database server, which in turn uses a shared library that is used by many other programs. How does it all work?

You can most effectively understand the structure of the operating system using abstractions is a neat way of saying that you ignore most of the details. For example, when you drive a car, you usually don't have to think about details like the mounting bolts that hold the engine inside the car or the people who pave the road and maintain it. If you're riding in a car as a passenger, all you need to know is what the car is designed to do (it takes you somewhere) and some basic rules for using it (how to handle the door and seat belt).

If you drive a car, you need to know more. You will need to become familiar with the controls (such as the steering wheel and gas pedal) and what to do in the event of a malfunction.

Suppose the car is moving jerkily. You can break down the abstraction of “a car driving on the road” into three parts: the car, the road, and your driving style. This will help determine the cause. If the road is bumpy, you don't have to blame the car or yourself. Instead, you can try to figure out why the road deteriorated, or, if the road is new, why its builders did such a terrible job.

Software developers use abstraction as a tool when creating operating systems and applications. There are many terms for abstracted areas of computer software, including subsystem, module And plastic bag. However, we will use the term in this chapter component because it is simple. When creating a software component, developers typically don't care much about the internal structure of the other components, but they do have to think about which components they can use and how they can use them.

This chapter provides a general overview of the components that make up a Linux system. Although each of them has an incredible amount of technical details related to the internal structure, we will not pay attention to them and focus on what these components do in relation to the system as a whole.

1.1. Levels and layers of abstraction in the Linux operating system

Using abstractions to break down computer systems into components makes them easier to understand, but does no good if there is no structure. We will arrange the components into layers, or levels. Layer, or level, is a way of classifying (or grouping) components according to their location between the user and the hardware. Browsers, games, etc. are located on the top layer; on the bottom layer we see the computer's memory: zeros and ones. The operating system occupies the largest number of layers between these two.

There are three main levels in the Linux operating system. In Fig. Figure 1.1 shows the levels, as well as some of the components within each of them. At the base are located hardware. They include memory and one or more central processing units (CPUs) that perform calculations and requests to read from and write to memory. Devices such as hard drives and network interfaces are also considered hardware.

The level above is located core, which is the core of the operating system. The kernel is a program located in the computer's memory and gives instructions to the central processor. The kernel manages the hardware and acts primarily as an interface between the hardware and any running program.

Processes—running programs managed by the kernel—collectively make up the top level of the system, called user space.

Note

A more precise term than "process" is the term "user process", regardless of whether the user interacts with that process directly. For example, all web servers run as user processes.

There is an important difference between how kernel processes and user processes are started: the kernel is started in kernel mode, and user processes - in user mode. Code running in kernel mode has unlimited access to the processor and RAM. This is a powerful advantage, but it can be dangerous because it allows kernel processes to easily disrupt the entire system. The area that is accessible only to the kernel is called core space.

In user mode, by comparison, only a limited (usually small) amount of memory is available and only safe processor instructions are allowed. User space are areas of RAM that can be accessed by user processes. If a process fails, the consequences will be limited and the kernel will be able to clean it up. This means that if, for example, your browser crashes, the scientific calculations you've been running in the background for a few days won't be disrupted.

Rice. 1.1. General structure of the Linux operating system

Theoretically, an uncontrolled user process is not capable of causing significant harm to the system. It really depends on what you consider a "substantial harm" and the special privileges of the process, since some processes are allowed to do more than others. For example, can a user process completely destroy data on a hard drive? If you configure the permissions properly, it can, and it will be extremely dangerous for you. There are safeguards in place to prevent this, and most processes simply will not be allowed to cause havoc in this manner.

1.2. Hardware: RAM

Of all the computer hardware RAM is perhaps the most important. In its most raw form, RAM is just a huge store of strings of ones and zeros. Each zero or one is called bit. This is where the running kernel and processes are located - they are just large collections of bits. All input and output data from peripheral devices pass through RAM also in the form of sets of bits. The CPU simply operates on memory: it reads instructions and data from it, and then writes the data back into memory.

You will often come across the term "state", which will refer to memory, processes, kernel and other parts of a computer system. Strictly speaking, a state is any ordered arrangement of bits. For example, if there are four bits in memory, then the sequences 0110, 0001 and 1011 represent three different states.

When you consider that a process can easily consist of millions of bits of memory, it is often easier to use abstract terms when talking about states. Instead of describing a state using bits, you talk about what happened or is happening at the moment. For example, you can say "this process is waiting for input" or "the process is performing the second step of its startup procedure."

NOTE

Because states are typically described using abstract concepts rather than actual bits, the term "image" is used to refer to any physical arrangement of bits.

1.3. Core

Almost everything the kernel does involves RAM. One of the kernel's jobs is to distribute memory into several subsections, after which the kernel must constantly maintain information about the state of these subsections in order. Each process uses an area of memory allocated to it, and the kernel must ensure that processes stick to their areas.

The kernel is responsible for managing tasks in four main areas of the system.

Processes. The kernel is responsible for which processes are allowed access to the central processor.

Memory. The kernel needs to keep track of the state of all memory: what portion is currently allocated to certain processes, what can be allocated for sharing between processes, and what portion is free.

Device drivers. The kernel acts as an interface between hardware (such as a hard drive) and processes. Typically, hardware management is performed by the kernel.

System callsAndsupport. Processes typically use system calls to communicate with the kernel.

We will now look briefly at each of these areas.

NOTE

For more information on how the kernel works, see Operating System Concepts, 9th Edition, by Abraham Silberschatz, Peter B. Galvin, and Greg Gann. Gagne (Wiley, 2012) and Modern Operating Systems, 4th edition by Andrew S. Tanenbaum and Herbert Bos (Prentice Hall, 2014).

1.3.1. Process management

Process management describes the starting, stopping, resuming, and termination of processes. The concepts behind starting and stopping processes are quite simple. It's a little more difficult to describe how a process uses the CPU during normal operation.

In any modern operating system, several processes function "simultaneously". For example, you can launch a browser on your computer and open a spreadsheet at the same time. However, in reality, things are not as they appear: the processes that are responsible for these applications usually do not start Vaccuracy at one point in time.

Consider a system with one central processor. Multiple processes can use it, but at any given time only one process can actually use the processor. In practice, each process uses the CPU for a small fraction of a second and then pauses; after that, another process uses the processor for a small fraction of a second; then comes the turn of the third process, etc. The action in which a process transfers control of the processor to another process is called context switching.

Every period of time quantum of time– gives the process enough time to perform significant computation (and, of course, the process often completes its current task within one quantum). Since time slices are so small, a person does not perceive them and it seems to him that several processes are running simultaneously in the system (this possibility is known as "multitasking").

The kernel is responsible for context switching. To understand how this works, imagine a situation in which a process is running in user mode, but its time slice is running out. This is what happens.

1. The processor (real hardware) interrupts the current process using an internal timer, switches to kernel mode and returns control to it.

2. The kernel records the current state of the processor and memory, which will be needed to resume the just interrupted process.

3. The kernel performs any tasks that may have appeared during the previous time slice (for example, data collection or I/O operations).

4. The kernel is now ready to start another process. It analyzes the list of processes that are ready to run and selects one of them.

5. The kernel prepares memory for the new process and then prepares the processor.

6. The kernel tells the processor how long the time slice for the new process will last.

7. The kernel puts the processor into user mode and transfers control to the processor.

Context switching answers an important question: When is the kernel running? The answer is: the kernel is working between time slices allocated for processes when a context switch occurs.

On a system with multiple processors, things are a little more complicated, since the kernel does not need to stop controlling the current processor to allow some process to run on another processor. And yet, in order to get the most out of all available processors, the kernel still does this (and can use certain tricks to gain additional processor time).

1.3.2. Memory management

Because the kernel must manage memory during context switches, it is equipped with this complex function. The operation of the kernel is complex because the following conditions must be taken into account:

The kernel must have its own memory area that cannot be accessed by user processes;

Each user process needs its own memory area;

Any user process must not have access to memory allocated to another process;

User processes can share memory;

Some memory for user processes may be read-only;

The system can use more memory than is available by using disk space as an auxiliary device.

The kernel has a helper. Modern processors contain memory management module(MMU), which activates a memory access circuit called "virtual memory". When using virtual memory, a process does not access memory directly from its physical location in the hardware. Instead, the kernel configures each process as if it had control over the entire machine. When a process accesses memory, the MMU intercepts the request and uses a memory address map to translate the memory location learned from the process to a physical memory location on the computer. However, the kernel must still initialize, continuously maintain, and modify this address map. For example, during a context switch, the kernel must change the map after the departing process and prepare it for the upcoming one.

Note

The implementation of a memory address map is called a page table.

You'll learn how to monitor memory performance in Chapter 8.

1.3.3. Device drivers and management

The kernel's job with respect to devices is quite simple. Typically, devices are only accessible in kernel mode, since incorrect access (for example, when a user process tries to turn off power) can cause the computer to crash. Another problem is that different devices rarely have the same software interface, even if they perform the same task: for example, two different network cards. For this reason, device drivers are traditionally part of the kernel and strive to provide a unified interface to user processes to make the work of software developers easier.

1.3.4. System calls and support

There are other types of kernel functions available to user processes. For example, system calls perform special tasks that a user process cannot perform well or at all on its own. Thus, all actions related to opening, reading and writing files involve system calls.

Two system calls, fork() and exec(), are important for understanding how processes are launched:

Fork(). When a process calls fork(), the kernel creates a nearly identical copy of the process;

Exec(). When a process calls exec( program), the kernel runs the program program, which replaces the current process.

With the exception of the init process (Chapter 6), All user processes on a Linux system start as the result of a fork() call, and in most cases an exec() call is made to start a new program rather than a copy of an existing process. A simple example is any program that you run from the command line, such as the ls command that displays the contents of a directory. When you enter the ls command in a terminal window, the shell running inside the terminal window calls fork() to create a copy of the shell, and then that new copy of the shell calls exec(ls) to run the ls command. In Fig. Figure 1.2 shows the sequence of processes and system calls to run programs such as ls.

Rice. 1.2. Starting a new process

NOTE

System calls are usually denoted using parentheses. In the example shown in Fig. 1.2, a process that requests the kernel to create another process must issue the fork() system call. This designation comes from the way calls are written in the C programming language. You do not need to know C to understand this book. Just remember that a system call is an interaction between a process and the kernel. Moreover, this book simplifies some groups of system calls. For example, the exec() call denotes a whole family of system calls that perform a similar task but differ in their software implementation.

The kernel also supports user processes whose functions differ from traditional system calls. The most famous of them are pseudo devices. From the point of view of user processes, pseudo-devices look like regular devices, but they are implemented entirely in software. In fact, they should not formally be in the kernel, but they are still present in it for practical reasons. For example, a device that generates random numbers (/dev/random) would be difficult to implement with the required degree of security using a user process.

note

Technically, a user process that accesses a pseudo-device is still forced to make a system call to open that device. Thus, processes cannot completely avoid system calls.

1.4. User space

The area of RAM that the kernel allocates for user processes is called user space. Since a process is just a state (or image) in memory, user space also accesses the memory of the entire collection of running processes. You may also come across the term "userland", which is used instead of user space.

Most of the real action of a Linux system occurs in user space. Although all processes are the same from the kernel's point of view, they perform different tasks for users. System components that represent user processes are organized into an elementary structure - a service layer (or layer). In Fig. Figure 1.3 shows an approximate set of components interconnected and interacting with the Linux system. Simple services are located at the bottom level (closest to the kernel), utility programs are in the middle, and applications that the user works with are located at the top. Figure 1.3 is an extremely simplified diagram as only six components are shown, but you can notice that the top components are closest to the user (the user interface and the browser); middle tier components have a mail server that uses a browser; There are several small components present at the bottom.

The lower level usually consists of small components that perform simple tasks. The middle tier contains larger components such as the mail service, print server, and database. Top-level components perform complex tasks that are often directly controlled by the user. If one component wants to use another, then that second component is either at the same service level or lower.

Figure 1.3 only roughly shows the user space layout. In reality, there are no rules in user space. For example, most applications and services record diagnostic messages called magazines. Most programs use the standard syslog service to log messages, but some choose to do the logging themselves.

Rice. 1.3. Types of Processes and Interactions

Additionally, some user space components may be difficult to categorize. Server-side components, such as a web server or a database server, can be considered very high-level applications because they perform quite complex tasks. Such applications can be placed at the top of the figure. 1.3. At the same time, user applications may depend on server applications to perform tasks that they cannot handle on their own. In this case, the server components should be placed at the middle level.

1.5. Users

The Linux kernel supports the traditional concept of a Unix system user. User is an entity that can run processes and own files. Associated with user Username. For example, the system may have a user called billyjoe. However, the kernel does not deal with usernames, instead it identifies the user using a simple numeric user ID(Chapter 7 talks about how IDs map to usernames).

We are recruiting a release group for our tracker .
Payment is negotiable.
Applications are accepted by mail [email protected], possible through feedback
Please tell us briefly about yourself, how much time you can devote to our site and your expected earnings.

Bandicam allows you to record a specific area on the PC screen, or in a program that uses DirectX/OpenGL graphics technologies. Bandicam helps you record highly compressed video....

Description:Wondershare Filmora is a convenient video editor containing all the necessary tools for video editing. You can create high-quality films with titles, ...

EmEditor Professional- a professional version of a powerful text editor for programmers, web developers and ordinary users with syntax highlighting and Unicode support. The editor has...

Driver Reviver is an application that will scan your system for outdated drivers and offer to update them. Scanning is carried out against one of the largest driver databases, which guarantees....

Skype- a free program for text, voice and video communication with friends around the world. The Skype network uses P2P technology to connect with other users and is of high quality....

Bandizip is a fast and reliable program that supports working with WinZip, 7-Zip, and WinRAR formats, and other similar archives. It uses a very fast algorithm for compression and decompression....

Opera is a new Chromium browser from Opera Software. Opera has abandoned its classic browser and is now developing a new browser based on Google's Chromium project....

Description: A program for working with PDF documents that provides a collection of tools and utilities for modifying and optimizing PDF files and their content. Thanks to...

Snappy Driver Installer (SDI) is a portable program for installing and updating drivers that does not require an Internet connection. It is a reworking of the original SDIO program from Glenn Delahoy....

Mirillis Action! - the program allows you to record screen images in real time into video files of various formats. You can record web player video, gameplay, insert live audio commentary....

Linux Internals Brian Ward

(No ratings yet)

Title: Linux Internals

About the book Linux Internals by Brian Ward

The Linux operating system is a worthy alternative to Windows, some versions of which are not very convenient and are too “heavy” for computer resources. Brian Ward has written an amazing self-help book that is suitable for anyone who wants to get acquainted with this system and its rich capabilities almost from scratch. Reading the book “Linux Internals” is recommended for those who want to delve into all the mechanisms of the Linux kernel, understand its internal structure and philosophy. This work is not suitable for a superficial study of operating principles and transferring template schemes from one operating system to another.

This book will be of interest to a wide range of readers - both computer scientists and beginners. You don't have to be a programming professional to read this work, just basic computer skills. If you understand what a graphical interface of an operating system is and know how to work with folders and directories, the book will be understandable to you.

The computer work “Linux Internals” is very detailed and is divided into 17 chapters. In the first four sections, the author talks about the general concepts of this system and the principle of its operation: the structure of the kernel and shell, basic commands and directory structure, and the functionality of file and disk systems. Next comes more information on getting started with this system: how to load the Linux kernel and start user space. Subsequent chapters delve deeper into Linux workflows and resource utilization. In addition, Brian Ward touched on the issues of shell script programming and working with the C language. From general material, the author gradually delves into details that are of interest to software developers.

The book is not only an overview of the Linux system, but also contains practical tasks that will allow the reader to create his own user space and acquire skills in working in this shell.

Brian Ward presented the material in accessible language with many examples and explanations. The book is well structured and can be used as a reference book. The author confirms that the Linux shell is convenient and functional, and reveals the possibilities of how you can adjust it to your needs. For those who are interested in the structure of certain programs, this book will be an excellent find, because it reveals the mechanisms of computer processes and demonstrates the cause-and-effect relationships between them.

On our website about books, you can download the site for free without registration or read online the book “Linux Internals” by Brian Ward in epub, fb2, txt, rtf, pdf formats for iPad, iPhone, Android and Kindle. The book will give you a lot of pleasant moments and real pleasure from reading. You can buy the full version from our partner. Also, here you will find the latest news from the literary world, learn the biography of your favorite authors. For aspiring writers, there is a separate section with useful tips and tricks, interesting articles, thanks to which you yourself can try your hand at literary crafts.

Download free book “Linux Internals” by Brian Ward

In format fb2: Download
In format rtf: Download
In format epub: Download
In format txt:

We have published a book by Brian Ward, which has already become a bestseller in the West. It describes all the intricacies of working with the Linux operating system, system administration, and deep mechanisms that provide low-level Linux functionality. On the pages of this publication you will acquire basic knowledge of working with the Linux kernel and the principles of proper operation of computer networks. The book also touches on the issues of programming shell scripts and handling the C language, covers topics of information security, virtualization and other irreplaceable things.

Who should read the book

The necessary conditions

How to read a book

When it comes to technical topics, conveying all the necessary knowledge is not an easy task. On the one hand, the reader gets bogged down in unnecessary details and has difficulty grasping the essence, since the human mind simply cannot process a large number of new concepts at the same time. On the other hand, the lack of details leads to the fact that the reader receives only a vague idea of the subject and is not ready to assimilate further material.

In this book, the author simplified the presentation and structured the material. In most chapters, important information that is needed for further work is presented first. As you read the chapter, you will encounter additional material in it. Do you need to immediately grasp these particulars? In most cases, the author believes not. If your eyes begin to glaze over the amount of detail related to the material you just learned, don't hesitate to move on to the next chapter or take a break. Other important things await you.

How is this book organized?

Most of the early chapters (except Chapter 2) focus heavily on the Linux kernel, but as you progress through the book you'll also work in your user space. If you do not understand what the author is talking about now, do not worry, explanations will be given in Chapter 1. The material is presented, whenever possible, without reference to any system distribution. It would be boring to describe all the variants of the system, so Ward tried to talk about the two main families of distributions: Debian (including Ubuntu) and RHEL/Fedora/CentOS. The emphasis is on server and workstation versions. Embedded systems such as Android and OpenWRT are also represented, but learning the differences between these platforms is left to you.

What's new in the second edition

Thanks to the hard work of software developers and Linux distribution creators, this has changed. Ward revised the first edition's material for updates, paying particular attention to the system's boot process and how it manages hardware, and removing outdated material (such as a detailed explanation of the printing process) to expand the discussion of the role of the Linux kernel in each distribution. You probably interact with the kernel much more often than you realize, and the author has specifically noted the times when this happens.

Ward also rearranged the book's presentation to suit the interests and needs of modern readers. The only thing that hasn't changed is the length of the book.

The author wanted to provide you with the information you need to get started quickly. They will take some effort to master, but Ward does not intend to make you a "weightlifter" so that you can overcome this book. Once you understand the important points outlined here, it will be easy for you to find the details and understand them.

The author has removed some historical details that were in the first edition, mainly to focus your attention. If you are interested in the Linux system and its relationship to the history of the Unix system, see Peter H. Salus's book The Daemon, the Gnu, and the Penguin (Reed Media Services, 2008) - it tells how the used us software.

More details about the book can be found at

Brian Ward's book, which has already become a bestseller in the West. It describes all the intricacies of working with the Linux OS, system administration, and deep mechanisms that provide low-level Linux functionality. On the pages of the manual, you will acquire basic knowledge about working with the Linux kernel and the principles of proper operation of computer networks, not only based on Open-source solutions. The book also touches on issues of script programming and handling the C language, covers topics of information security, virtualization and other irreplaceable things.
Who should read the book:
Interest in the design of the Linux operating system can be caused by various reasons. Information technology professionals and Linux software developers will find in this book virtually everything they need to know to get the most out of the operating system. Researchers and students, who often have to customize the system for themselves, will find here practical explanations of why things work the way they do. There are also “entertainers” - users who like to spend time on the computer for fun, profit, or both. Want to know why some things work and others don't? Are you wondering what will happen if you change something? Then you are one of the “entertainers”.
The necessary conditions:
You don't need to be a programmer to read this book. Only basic PC user skills are required: you must navigate the graphical interface (when installing and configuring the system interface), as well as have an understanding of files and directories (folders). You should also be prepared to search the Internet for additional documentation. The main thing is your willingness and desire to explore your computer.

Title: Linux Internals
Author: Brian Ward
Publisher: Peter
Year: 2016
Format: PDF, FB2, EPUB
Russian language
Pages: 384
Size: 12.9 MB

Linux Internals / Brian Ward / 2016. Download for free without registration

2016-07-24T17:16:55+00:00 adminAdministration Literature Guides Linux, Administration, Security, Brian Ward, Books, Literature, Manuals, System Administration, scripts, Command references

[email protected] Administrator LINUX Tutorial