Shulou(Shulou.com)06/01 Report--

This article mainly explains the "introduction of the kernel and file permissions of Linux". The content of the explanation in the article is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "the kernel and file permissions of Linux".

What is Linux?

If you've never been to Linux before, it's probably not clear why there are so many different Linux distributions. When looking at Linux packages, you must have been confused by terms like distribution, LiveCD, and GNU. Entering the Linux world for the first time makes people feel less comfortable. Before you start learning commands and scripts, this chapter will slightly unravel the mysteries of the Linux system. First, Linux can be divided into the following four parts:

↪ Linux kernel

↪ GNU tool chain

↪ GUI Desktop Environment

↪ application software.

| |-| APPS | Application Software |-| GUI Desktop Environment | GUI |-| GNU | GNU tool chain |-| -| | kernel | Linux kernel |-| hardware | computer hardware--

one。 Linux kernel

The core of the Linux system is the kernel. The kernel controls all the hardware and software on the computer system, allocates the hardware when necessary, and executes the software as needed.

System memory management

Application management

Hardware equipment management

File system management

1. System memory management

One of the main functions of the operating system kernel is memory management. The kernel not only manages the physical memory available on the server, but also creates and manages virtual memory (that is, memory that does not actually exist).

The kernel implements virtual memory through the storage space on the hard disk, which is called swap space. The kernel constantly swaps the contents of virtual memory between swap space and actual physical memory. This makes the system think that it has more available memory than physical memory.

Linux system memory mapping

| |-|-| physical memory | /-| | Virtual memory |-| Kernel |-| | |\-| Exchange space | |-|-|

two。 Application management

The Linux operating system calls running programs processes. The process can be run in the foreground, the output can be displayed on the screen, or it can be run in the background, hidden behind the scenes. The kernel controls how the Linux system manages all processes running on the system.

The kernel creates * processes (called init processes) to start all other processes on the system. When the kernel starts, it loads the init process into virtual memory. When the kernel starts any other process, it allocates a proprietary area to the new process in virtual memory to store the data and code used by the process.

The Linux operating system has five startup runlevels

At run level 1, only the basic system process and one console terminal process are started. We call it single-user mode. Single-user mode is usually used for emergency file system maintenance when there is a problem with the system. Obviously, in this mode, only one person (usually a system administrator) can log in to the system and manipulate the data.

The standard startup run level is 3. At this runtime level, most applications, such as network support programs, start.

The common runlevel in Linux is 5. At this runtime level, the system starts the graphical X Window system, allowing users to log in to the system through a graphical desktop window.

3. Hardware equipment management

Another responsibility of the kernel is to manage hardware devices. Any device with which a Linux system needs to communicate needs to include its driver code in the kernel code. The driver code acts as a middleman between the application and the hardware device, allowing data to be exchanged between the kernel and the device. There are two ways to insert device driver code in the Linux kernel:

Device driver code compiled into the kernel

Device driver module that can be plugged into the kernel

Previously, the only way to insert device driver code was to recompile the kernel. Every time a new device is added to the system, the kernel code is recompiled. As the Linux kernel supports more and more hardware devices, this process becomes less and less efficient. Fortunately, Linux developers have devised a better way to insert driver code into a running kernel.

Developers put forward the concept of kernel module. It allows driver code to be inserted into the running kernel without having to recompile the kernel. At the same time, kernel modules can be removed from the kernel when the device is no longer in use. This approach greatly simplifies and expands the use of hardware devices on Linux.

Linux system treats hardware devices as special files, which are called device files. There are three categories of device files:

Character device file

A character device file is a device that can only process one character at a time when processing data. Most types of modems and terminals are created as character device files.

Block device file

Block device files are devices that can handle large chunks of data at a time when processing data, such as a hard disk.

Network device file

Network device files refer to the devices that use data packets to send and receive data, including various network cards and a special loopback device. This loopback device allows the Linux system to communicate with itself using common network programming protocols.

Linux creates a special file called a node for each device on the system. All communication with the device is done through the device node. Each node has a unique numerical pair for the Linux kernel to identify it. The value pair includes a major number and a secondary number. The devices of the class are classified under the same primary device number. The secondary device number is used to identify a specific device under the primary device group.

4. File system management

Unlike some other operating systems, the Linux kernel supports reading and writing data from the hard disk through different types of file systems. Except

In addition to many of its own file systems, Linux also supports files taken from other operating systems, such as Microsoft Windows

Read and write data in the system. The kernel must add support for all possible file systems at compile time. Table 1-1 lists

A standard file system used by Linux systems to read and write data.

Ext | Linux extended file system, the earliest Linux file system ext2 | the second extended file system, which provides more features on the basis of ext. Ext3 | the third extended file system supports the logging function ext4 | the fourth extended file system Support advanced logging function hpfs | OS/2 high performance file system jfs | IBM log file system iso9660 | ISO 9660 file system (CD-ROM) minix | MINIX file system msdos | Microsoft FAT16 ncp | Netware file system nfs | Network file system ntfs | support Microsoft NT file system proc | access system information ReiserFS | Advanced Linux file system Can provide better performance and hard disk recovery function smb | Samba SMB file system sysv that supports network access | earlier Unix file system ufs | BSD file system umsdos | Unix-like file system vfat built on msdos | Windows 95 file system (FAT32) XFS | High performance 64-bit journal file system

All hard drives accessed by the Linux server must be formatted into one of the file system types listed in Table 1-1.

The Linux kernel uses virtual file system (Virtual File System,VFS) as the interface to interact with each file system. This provides a standard interface for the Linux kernel to communicate with any type of file system. When each file system is mounted and used, VFS caches the information in memory.

2. GNU tool chain

The GNU organization (GNU is short for GNU's Not Unix) has developed a complete set of Unix tools, but there is no kernel system that can run them. These tools are developed under a software concept called open source software (open source software,OSS).

The concept of open source software allows programmers to develop software and distribute it for free. Anyone can use, modify, or integrate the software into their own system without paying any licensing fees. The integration of Linus's Linux kernel and GNU operating system tools produces a complete, feature-rich, free operating system.

Although the combination of the Linux kernel and GNU tools is usually called Linux, you will also see on the Internet that some Linux purists call it the GNU/Linux system, paying tribute to the contributions made by the GNU organization.

Core GNU tool

The GNU coreutils package consists of three parts:

Tools for processing documents

Tools for manipulating text

Tools for managing processes

Shell

GNU/Linux shell is a special interactive tool. It provides users with a way to start programs, manage files in the file system, and processes running on Linux systems. At the heart of shell is the command line prompt. The command prompt is the part that shell is responsible for interacting with. It allows you to enter text commands, then interpret them, and execute them in the kernel.

The commands we enter on the command line are provided by the GNU tool chain, not the Linux kernel

The default shell for all Linux distributions is bash shell. Bash shell was developed by the GNU project and is used as an alternative to the standard Unix shell--Bourne shell (named after the creator).

Several different shell commonly used in Linux

Bash | developed by the GNU project and used as a standard shellash | simple lightweight shell running in a memory-constrained environment, but fully compatible with bash shell | Bourne shell-compatible programming shell, but supports some advanced programming features such as associative arrays and floating-point operations tcsh | introduce some elements of C into the shellzsh of shell scripts | combine the features of bash, tcsh and korn Advanced shell that also provides advanced programming features, shared history files, and themed prompts

3. Linux desktop environment

In the early days of Linux (in the early 1990s), all that was available was a simple Linux operating system text interface. This text interface allows the system administrator to run the program, control the execution of the program, and move files in the system.

With the popularity of Microsoft Windows, computer users are no longer satisfied with working on the old-fashioned text interface. This promotes more development activities in the OSS community, and the Linux graphical desktop environment arises at the historic moment.

X Window system

There are two basic elements that determine the video environment: the video card and the monitor. To display gorgeous pictures on a computer, Linux software needs to know how to communicate with the two. X Window system is the core part of graphic display.

X Window system is the underlying program that directly deals with graphics cards and monitors on PC. It controls how Linux programs display beautiful windows and graphics on the computer.

Now popular desktop environments include Unity GNOME Cinnamon Xfce and so on.

Linux distribution

Now that you know the four key components needed to build a complete Linux system, you may be thinking about how to put them into a Linux system. Fortunately, someone has already done this for you.

Core Linux distribution

The core Linux distribution contains the kernel, one or more graphical desktop environments, and precompiled almost all visible Linux applications. It provides an one-stop full Linux installation

Slackware | one of the earliest Linux distributions, Redhat is popular among Linux geeks | Gentoo is mainly used for commercial distributions of Internet servers | distributions designed for advanced Linux users contain only Linux source code openSUSE | Debian for commercial and household distributions | popular distributions among Linux experts and commercial Linux products

System catalog

|-- bin # binary directory to store user-level GNU tools (bash command) |-- boot # startup directory to store various files used for system boot |-- dev # device directory, store hardware devices, create device nodes |-- etc # system configuration file directory Store system management and configuration files |-- home # home directory of ordinary users |-- lib # library directory, which stores dynamic link libraries for systems and applications |-- lost+found # this directory is usually empty "homeless" files left behind due to abnormal shutdown of the system |-- media # media directory, a common mount point for removable media devices |-- mnt # mount directory, another common mount point for removable media devices |-- opt # optional directory, often used to store third-party software packages and data files |-- proc # process directory Store information about existing hardware and current processes Is a mapping of system memory. You can access this directory directly to get system information |-- root # superuser's home directory |-- run # run directory, which stores the runtime data when the system is running |-- sbin # system binary directory, which stores many GNU administrator-level tools |-- srv # service directory. Store files related to local services |-- sys # system directory, store files related to system hardware information |-- tmp # temporary directory, you can create and delete temporary working files in this directory, and empty them after restart |-- usr # user binary directory A large number of user-level GNU tools and data files are stored here |-- bin # contains executable programs installed by the system. Usually, this directory contains many programs | |-- games # | |-- include # header files needed to write programs | |-- lib # contains shared libraries used by programs in the / usr/bin directory |-- local # is the installation directory of programs that are shipped with non-system distributions but are intended to be used by the system. Usually, programs compiled by source code are installed in the / usr/local/bin directory | |-- sbin # contains many hypervisors | |-- share # stores help documents and shared files | |-- src # |-- var # variable directory to store frequently changed files, such as log files

File permissions-permissions

Command line execution: ls-l

Drwxr-xr-x # File type belongs to primary permissions, member permissions, other user rights drwxr-xr-x |-- File type | |-- # file | |-- d # folder | |-- l # link | |-- c # character device | |-- b # block device | |-- n # network | Device | |-- r # readable permission |-- w # writable permission |-- x # executable permission

File system

Ext

The earliest file system introduced in the Linux operating system is called the extended file system (extended filesystem, abbreviated as ext). It provides a basic Unix-like file system for Linux: use virtual directories to manipulate hardware devices and store data in fixed-length blocks on physical devices.

The ext file system uses a system called an index node to store information about files stored in a virtual directory. The Inode system creates a separate table (called an Inode table) in each physical device to store information about these files. Each file stored in the virtual directory has an entry in the index node table. The extended part of the ext file system name comes from the extra data for each file it tracks

-File name-file size-owner of the file-group of the file-access to the file-pointer to each hard disk block where the file data is stored

Linux refers to each index node in the index node table by a unique numeric value (called the index node number), which is assigned by the file system when the file is created. The file system identifies the file by the Inode number rather than the full name and path of the file.

Ext2

The earliest ext file systems had many limitations, such as a file size of no more than 2 GB. Shortly after the advent of Linux, the ext file system was upgraded to a second-generation extended file system, called ext2

Log file system

The journaling file system adds a layer of security to the Linux system. Instead of writing data directly to the storage device and then updating the index node table, it first writes changes to the file to a temporary file (called log, journal).

Delete the corresponding log entries after the data is successfully written to the storage device and the index node table. If the system crashes or is powered off before the data is written to the storage device, the log file system will read the log file next time and process the unwritten data left last time

Ext3

In 2001, the ext3 file system was introduced into the Linux kernel and until recently was the default file system for almost all Linux distributions. It uses the same index node table structure as the ext2 file system, but adds a log file to each storage device to log the data to be written to the storage device first.

Ext4

The ext4 file system was officially supported by the Linux kernel in 2008 and is now the default file system adopted by most popular Linux distributions

In addition to supporting data compression and encryption, the ext4 file system supports a feature called extent. The section allocates space by block on the storage device, but only the location of the starting block is saved in the index node table. Since it does not need to list all the data blocks used to store data in the file, it can save some space in the index node table.

Ext4 also introduces block pre-allocation technology (block preallocation). If you want to reserve space on a storage device for a file that you know is going to get bigger, the ext4 file system can allocate all the blocks needed for the file, not just those that are already used. The ext4 file system fills reserved blocks with 0 and does not assign them to other files

LVM in Linux

Linux LVM was developed by Heinz Mauelshagen and released to the Linux community in 1998. It allows you to manage a complete logical volume management environment with simple command-line commands on Linux

LVM1

The original LVM package was released in 1998 and can only be used in version 2.4 of the Linux kernel. It only provides basic logic.

LVM2

A newer version of LVM, available for version 2.6 of the Linux kernel. It provides additional functionality in addition to the standard LVM1 functionality.

Snapshot

The original Linux LVM allows you to copy a logical volume to another device while it is online. This feature is called Snapshot. Snapshots are very powerful when backing up important data that cannot be locked due to high reliability requirements. Traditional backup methods usually lock files when copying files to backup media. Snapshots allow you to keep Web servers or database servers running critical tasks working while you replicate. Unfortunately, LVM1 only allows you to create read-only snapshots. Once a snapshot is created, you can no longer write

LVM2 allows you to create read-write snapshots of online logical volumes. With a read-write snapshot, you can delete the previous logical volume and mount the snapshot as an alternative. This feature is useful for rapid failover or program trials that involve modifying data (if it fails, you need to recover the modified data).

Striping

Another compelling feature provided by LVM2 is striping. With striping, logical volumes can be created across multiple physical hard disks. When Linux LVM writes a file to a logical volume, the blocks in the file are scattered across multiple hard drives. Each subsequent data block is written to the next hard disk. Striping helps improve the performance of a hard disk because Linux can write multiple blocks of a file to multiple hard drives at the same time without waiting for a single hard disk to move its read / write head to multiple different locations. This improvement also applies to reading sequentially accessed files because LVM can read data from multiple hard drives at the same time.

Mirror image

Mounting a file system through LVM does not mean that there will be no problems with the file system. Like physical partitions, LVM logical volumes are vulnerable to power outages and disk failures. Once the file system is corrupted, it may never be recovered.

The LVM Snapshot feature provides some comfort that you can create backup copies of logical volumes at any time, but it may not be enough for some environments. For systems that involve a large number of data changes, such as database servers, hundreds of records may have to be stored since the last snapshot.

One solution to this problem is LVM mirroring. A mirror is a complete copy of a logical volume that is updated in real time. When you create a mirrored logical volume, LVM synchronizes the original logical volume to the mirrored copy. Depending on the size of the original logical volume, this may take some time to complete.

Once the original synchronization is complete, LVM performs two writes for each write to the file system-once to the primary logic volume and once to the mirrored replica. As you can imagine, this process will degrade the write performance of the system. Even if the original logical volume is damaged for some reason, you already have a complete copy on hand!

Thank you for your reading, the above is the content of "introduction of Linux kernel and file permissions". After the study of this article, I believe you have a deeper understanding of the introduction of Linux kernel and file permissions, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.