没有合适的资源?快使用搜索试试~ 我知道了~
首页Linux-Kernel官方文档.pdf
资源详情
资源评论
资源推荐

» zhouhehe_test v1.0 文档
The Linux Kernel documentation
This is the top level of the kernel’s documentaon tree. Kernel documentaon, like the kernel itself,
is very much a work in progress; that is especially true as we work to integrate our many scaered
documents into a coherent whole. Please note that improvements to the documentaon are
welcome; join the linux-doc list at vger.kernel.org if you want to help out.
Licensing documentation
The following describes the license of the Linux kernel source code (GPLv2), how to properly mark
the license of individual files in the source tree, as well as links to the full license text.
Linux kernel licensing rules
User-oriented documentation
The following manuals are wrien for users of the kernel — those who are trying to get it to work
opmally on a given system.
The Linux kernel user’s and administrator’s guide
The following is a collecon of user-oriented documents that have been added to the kernel over
me. There is, as yet, lile overall order or organizaon here — this material was not wrien to be a
single, coherent document! With luck things will improve quickly over me.
This inial secon contains overall informaon, including the README file describing the kernel as
a whole, documentaon on kernel parameters, etc.
Linux kernel release 5.x <http://kernel.org/>
These are the release notes for Linux version 5. Read them carefully, as they tell you what this is all
about, explain how to install the kernel, and what to do if something goes wrong.
What is Linux?
Linux is a clone of the operang system Unix, wrien from scratch by Linus Torvalds with
assistance from a loosely-knit team of hackers across the Net. It aims towards POSIX and Single
UNIX Specificaon compliance.
It has all the features you would expect in a modern fully-fledged Unix, including true
multasking, virtual memory, shared libraries, demand loading, shared copy-on-write
executables, proper memory management, and mulstack networking including IPv4 and IPv6.
It is distributed under the GNU General Public License v2 - see the accompanying COPYING file
for more details.
On what hardware does it run?
Although originally developed first for 32-bit x86-based PCs (386 or higher), today Linux also
runs on (at least) the Compaq Alpha AXP, Sun SPARC and UltraSPARC, Motorola 68000,
PowerPC, PowerPC64, ARM, Hitachi SuperH, Cell, IBM S/390, MIPS, HP PA-RISC, Intel IA-64,
DEC VAX, AMD x86-64 Xtensa, and ARC architectures.
Linux is easily portable to most general-purpose 32- or 64-bit architectures as long as they have
a paged memory management unit (PMMU) and a port of the GNU C compiler (gcc) (part of The
GNU Compiler Collecon, GCC). Linux has also been ported to a number of architectures
without a PMMU, although funconality is then obviously somewhat limited. Linux has also
been ported to itself. You can now run the kernel as a userspace applicaon - this is called
UserMode Linux (UML).
Documentation

There is a lot of documentaon available both in electronic form on the Internet and in
books, both Linux-specific and pertaining to general UNIX quesons. I’d recommend looking
into the documentaon subdirectories on any Linux FTP site for the LDP (Linux
Documentaon Project) books. This README is not meant to be documentaon on the
system: there are much beer sources available.
There are various README files in the Documentaon/ subdirectory: these typically contain
kernel-specific installaon notes for some drivers for example. Please read the
Documentaon/process/changes.rst file, as it contains informaon about the problems,
which may result by upgrading your kernel.
Installing the kernel source
If you install the full sources, put the kernel tarball in a directory where you have permissions
(e.g. your home directory) and unpack it:
xz -cd linux-5.x.tar.xz | tar xvf -
Replace “X” with the version number of the latest kernel.
Do NOT use the /usr/src/linux area! This area has a (usually incomplete) set of kernel
headers that are used by the library header files. They should match the library, and not get
messed up by whatever the kernel-du-jour happens to be.
You can also upgrade between 5.x releases by patching. Patches are distributed in the xz
format. To install by patching, get all the newer patch files, enter the top level directory of
the kernel source (linux-5.x) and execute:
xz -cd ../patch-5.x.xz | patch -p1
Replace “x” for all versions bigger than the version “x” of your current source tree, in_order,
and you should be ok. You may want to remove the backup files (some-file-name~ or some-
file-name.orig), and make sure that there are no failed patches (some-file-name# or some-
file-name.rej). If there are, either you or I have made a mistake.
Unlike patches for the 5.x kernels, patches for the 5.x.y kernels (also known as the -stable
kernels) are not incremental but instead apply directly to the base 5.x kernel. For example, if
your base kernel is 5.0 and you want to apply the 5.0.3 patch, you must not first apply the
5.0.1 and 5.0.2 patches. Similarly, if you are running kernel version 5.0.2 and want to jump to
5.0.3, you must first reverse the 5.0.2 patch (that is, patch -R) before applying the 5.0.3
patch. You can read more on this in Documentaon/process/applying-patches.rst.
Alternavely, the script patch-kernel can be used to automate this process. It determines the
current kernel version and applies any patches found:
linux/scripts/patch-kernel linux
The first argument in the command above is the locaon of the kernel source. Patches are
applied from the current directory, but an alternave directory can be specified as the
second argument.
Make sure you have no stale .o files and dependencies lying around:
cd linux
make mrproper
You should now have the sources correctly installed.
Software requirements
Compiling and running the 5.x kernels requires up-to-date versions of various soware
packages. Consult Documentaon/process/changes.rst for the minimum version numbers
required and how to get updates for these packages. Beware that using excessively old versions
of these packages can cause indirect errors that are very difficult to track down, so don’t
assume that you can just update packages when obvious problems arise during build or
operaon.
Build directory for the kernel

When compiling the kernel, all output files will per default be stored together with the kernel
source code. Using the opon make O=output/dir allows you to specify an alternate place for the
output files (including .config). Example:
kernel source code: /usr/src/linux-5.x
build directory: /home/name/build/kernel
To configure and build the kernel, use:
cd /usr/src/linux-5.x
make O=/home/name/build/kernel menuconfig
make O=/home/name/build/kernel
sudo make O=/home/name/build/kernel modules_install install
Please note: If the O=output/dir opon is used, then it must be used for all invocaons of make.
Configuring the kernel

Do not skip this step even if you are only upgrading one minor version. New configuraon
opons are added in each release, and odd problems will turn up if the configuraon files are
not set up as expected. If you want to carry your exisng configuraon to a new version
with minimal work, use make oldconfig , which will only ask you for the answers to new
quesons.
Alternave configuraon commands are:
"make config" Plain text interface.
"make menuconfig" Text based color menus, radiolists & dialogs.
"make nconfig" Enhanced text based color menus.
"make xconfig" Qt based configuration tool.
"make gconfig" GTK+ based configuration tool.
"make oldconfig" Default all questions based on the contents of
your existing ./.config file and asking about
new config symbols.
"make olddefconfig"
Like above, but sets new symbols to their default
values without prompting.
"make defconfig" Create a ./.config file by using the default
symbol values from either arch/$ARCH/defconfig
or arch/$ARCH/configs/${PLATFORM}_defconfig,
depending on the architecture.
"make ${PLATFORM}_defconfig"
Create a ./.config file by using the default
symbol values from
arch/$ARCH/configs/${PLATFORM}_defconfig.
Use "make help" to get a list of all available
platforms of your architecture.
"make allyesconfig"
Create a ./.config file by setting symbol
values to 'y' as much as possible.
"make allmodconfig"
Create a ./.config file by setting symbol
values to 'm' as much as possible.
"make allnoconfig" Create a ./.config file by setting symbol
values to 'n' as much as possible.
"make randconfig" Create a ./.config file by setting symbol
values to random values.
"make localmodconfig" Create a config based on current config and
loaded modules (lsmod). Disables any module
option that is not needed for the loaded modules.
To create a localmodconfig for another machine,
store the lsmod of that machine into a file
and pass it in as a LSMOD parameter.
Also, you can preserve modules in certain folders
or kconfig files by specifying their paths in
parameter LMC_KEEP.
target$ lsmod > /tmp/mylsmod
target$ scp /tmp/mylsmod host:/tmp
host$ make LSMOD=/tmp/mylsmod \
LMC_KEEP="drivers/usb:drivers/gpu:fs" \
localmodconfig
The above also works when cross compiling.
"make localyesconfig" Similar to localmodconfig, except it will convert
all module options to built in (=y) options. You can
also preserve modules by LMC_KEEP.
"make kvmconfig" Enable additional options for kvm guest kernel support.
"make xenconfig" Enable additional options for xen dom0 guest kernel
support.
"make tinyconfig" Configure the tiniest possible kernel.
You can find more informaon on using the Linux kernel config tools in
Documentaon/kbuild/kconfig.rst.
NOTES on make config :

Having unnecessary drivers will make the kernel bigger, and can under some
circumstances lead to problems: probing for a nonexistent controller card may
confuse your other controllers.
A kernel with math-emulaon compiled in will sll use the coprocessor if one is
present: the math emulaon will just never get used in that case. The kernel will be
slightly larger, but will work on different machines regardless of whether they have a
math coprocessor or not.
The “kernel hacking” configuraon details usually result in a bigger or slower kernel
(or both), and can even make the kernel less stable by configuring some rounes to
acvely try to break bad code to find kernel problems (kmalloc()). Thus you should
probably answer ‘n’ to the quesons for “development”, “experimental”, or
“debugging” features.
Compiling the kernel
剩余3881页未读,继续阅读

















安全验证
文档复制为VIP权益,开通VIP直接复制

评论0