2. Linux From Scratch 12.0
3. Search

Filters

• Untranslated strings • state:empty
• Unfinished strings • state:<translated
• Translated strings • state:>=translated
• Strings marked for edit • state:needs-editing
• Strings with suggestions • has:suggestion
• Strings with variants • has:variant
• Strings with screenshots • has:screenshot
• Strings with labels • has:label
• Strings with context • has:context
• Unfinished strings without suggestions • state:<translated AND NOT has:suggestion
• Strings with comments • has:comment
• Strings with any failing checks • has:check
• Approved strings • state:approved
• Strings waiting for review • state:translated

state:<translated

Position and priority

• Position and priority
• Position
• Priority
• Labels
• Source string
• Target string
• String age
• Last updated
• Number of words
• Number of comments
• Number of failing checks
• Key
• String location

	Translation	Source string	Target string
	Linux From Scratch 12.0/chapter06_bash — Greek	&bash-url;
	Linux From Scratch 12.0/chapter06_patch — Greek	&patch-url;
	Linux From Scratch 12.0/chapter06_gcc-pass2 — Greek	gcc-pass2
	Linux From Scratch 12.0/chapter06_gawk — Greek	&gawk-url;
	Linux From Scratch 12.0/chapter06_m4 — Greek	&m4-url;
	Linux From Scratch 12.0/chapter06_tar — Greek	&tar-url;
	Linux From Scratch 12.0/chapter06_file — Greek	&file-url;
	Linux From Scratch 12.0/chapter05_gcc-pass1 — Greek	gcc-pass1
	Linux From Scratch 12.0/chapter05_libstdc__ — Greek	&gcc-url;
	Linux From Scratch 12.0/chapter05_binutils-pass1 — Greek	&binutils-url;
	Linux From Scratch 12.0/chapter03_introduction — Greek	Introduction
	Linux From Scratch 12.0/chapter02_mounting — Chinese (Simplified Han script)	Now that a file system has been created, the partition must be mounted so the host system can access it. This book assumes that the file system is mounted at the directory specified by the <envar>LFS</envar> environment variable described in the previous section.	我们已经在分区上建立了文件系统，为了访问分区，我们需要把分区挂载到选定的挂载点上。正如前一节所述，本书假设将文件系统挂载到 <envar>LFS</envar> 环境变量指定的目录中。
	Linux From Scratch 12.0/chapter02_stages — Chinese (Simplified Han script)	LFS is designed to be built in one session. That is, the instructions assume that the system will not be shut down during the process. This does not mean that the system has to be built in one sitting. The issue is that certain procedures must be repeated after a reboot when resuming LFS at different points.	LFS 被设计为在一次会话中构建完成。换句话说，本书的指令假设，在整个编译过程中，系统不会关闭或重启。当然，构建过程不需要严格地一气呵成，只要注意在重新启动后，继续编译 LFS 时，根据构建进度的不同，可能需要再次进行某些操作。
	Linux From Scratch 12.0/chapter07_introduction — Chinese (Simplified Han script)	This chapter shows how to build the last missing bits of the temporary system: the tools needed to build the various packages. Now that all circular dependencies have been resolved, a <quote>chroot</quote> environment, completely isolated from the host operating system (except for the running kernel), can be used for the build.	本章展示如何构建临时系统最后缺失的部分：首先，安装一些软件包的构建机制所必须的工具，然后安装三个用于运行测试的软件包。这样，就解决了所有的循环依赖问题，我们可以使用<quote>chroot</quote>环境进行构建，它与宿主系统除正在运行的内核外完全隔离。
	Linux From Scratch 12.0/chapter02_hostreqs — Chinese (Simplified Han script)	Hardware
	Linux From Scratch 12.0/chapter07_cleanup — Chinese (Simplified Han script)	Cleaning
	Linux From Scratch 12.0/chapter02_creatingfilesystem — Chinese (Simplified Han script)	A partition is just a range of sectors on a disk drive, delimited by boundaries set in a partition table. Before the operating system can use a partition to store any files, the partition must be formatted to contain a file system, typically consisting of a label, directory blocks, data blocks, and an indexing scheme to locate a particular file on demand. The file system also helps the OS keep track of free space on the partition, reserve the needed sectors when a new file is created or an existing file is extended, and recycle the free data segments created when files are deleted. It may also provide support for data redundancy, and for error recovery.
	Linux From Scratch 12.0/chapter07_chroot — Chinese (Simplified Han script)	Now that all the packages which are required to build the rest of the needed tools are on the system, it is time to enter the chroot environment and finish installing the temporary tools. This environment will also be used to install the final system. As user <systemitem class="username">root</systemitem>, run the following command to enter the environment that is, at the moment, populated with nothing but temporary tools:	现在已经准备好了所有继续构建其余工具时必要的软件包，可以进入 chroot 环境并完成剩余临时工具的安装。在安装最终的系统时，会继续使用这个 chroot 环境。以 <systemitem class="username">root</systemitem> 用户身份，运行以下命令以进入当前只包含临时工具的 chroot 环境：
	Linux From Scratch 12.0/chapter07_creatingdirs — Chinese (Simplified Han script)	It is time to create the full directory structure in the LFS file system.	现在可以在 LFS 文件系统中创建完整的目录结构。
	Linux From Scratch 12.0/chapter02_aboutlfs — Chinese (Simplified Han script)	Throughout this book, the environment variable <envar>LFS</envar> will be used several times. You should ensure that this variable is always defined throughout the LFS build process. It should be set to the name of the directory where you will be building your LFS system - we will use <filename class="directory">/mnt/lfs</filename> as an example, but you may choose any directory name you want. If you are building LFS on a separate partition, this directory will be the mount point for the partition. Choose a directory location and set the variable with the following command:	在本书中，我们经常使用环境变量 <envar>LFS</envar>。您应该保证，在构建 LFS 的全过程中，该变量都被定义且设置为您构建 LFS 使用的目录 —— 我们使用 <filename class="directory">/mnt/lfs</filename> 作为例子，但您可以选择其他目录。如果您在一个独立的分区上构建 LFS，那么这个目录将成为该分区的挂载点。选择一个目录，然后用以下命令设置环境变量：
	Linux From Scratch 12.0/chapter10_kernel_sysv — Chinese (Simplified Han script)	<placeholder type="screen" id="0"/>
	Linux From Scratch 12.0/chapter10_kernel_nvme — Chinese (Simplified Han script)	<placeholder type="screen" id="0"/>
	Linux From Scratch 12.0/chapter10_kernel_highmem — Chinese (Simplified Han script)	<placeholder type="screen" id="0"/>
	Linux From Scratch 12.0/chapter10_kernel_x2apic — Chinese (Simplified Han script)	<placeholder type="screen" id="0"/>
	Linux From Scratch 12.0/chapter10_kernel_systemd — Chinese (Simplified Han script)	<placeholder type="screen" id="0"/>
	Linux From Scratch 12.0/chapter04_introduction — Chinese (Simplified Han script)	In this chapter, we will perform a few additional tasks to prepare for building the temporary system. We will create a set of directories in <filename class="directory">$LFS</filename> (in which we will install the temporary tools), add an unprivileged user, and create an appropriate build environment for that user. We will also explain the units of time (<quote>SBUs</quote>) we use to measure how long it takes to build LFS packages, and provide some information about package test suites.	在本章中，我们将为构建临时系统进行一些额外的准备工作。我们将在 <filename class="directory">$LFS</filename> 中创建一些用于安装临时工具的目录，增加一个非特权用户以降低风险，并为该用户建立合适的构建环境。我们还将解释 LFS 软件包构建时间长度的测量单位，即 <quote>SBU</quote> 的概念，并给出关于软件包测试套件的一些信息。
	Linux From Scratch 12.0/chapter04_creatingminlayout — Chinese (Simplified Han script)	In this section, we begin populating the LFS filesystem with the pieces that will constitute the final Linux system. The first step is to create a limited directory hierarchy, so that the programs compiled in <xref linkend="chapter-temporary-tools"/> (as well as glibc and libstdc++ in <xref linkend="chapter-cross-tools"/>) can be installed in their final location. We do this so those temporary programs will be overwritten when the final versions are built in <xref linkend="chapter-building-system"/>.	在 LFS 分区中需要进行的第一项任务是，创建一个有限的目录树，使得在<xref linkend="chapter-temporary-tools"/>中编译的程序可以被安装到它们的最终位置。这样，在<xref linkend="chapter-building-system"/>中重新构建它们时，就能直接覆盖这些临时程序。
	Linux From Scratch 12.0/chapter04_aboutsbus — Chinese (Simplified Han script)	Many people would like to know beforehand approximately how long it takes to compile and install each package. Because Linux From Scratch can be built on many different systems, it is impossible to provide absolute time estimates. The biggest package (gcc) will take approximately 5 minutes on the fastest systems, but could take days on slower systems! Instead of providing actual times, the Standard Build Unit (SBU) measure will be used instead.	许多人想在编译和安装各个软件包之前，了解这一过程大概需要多少时间。由于 Linux From Scratch 可以在许多不同系统上构建，我们无法直接给出估计时间。例如，最大的软件包 (Glibc) 在最快的系统上只要大约 20 分钟就能构建好，而在一些较慢的系统上需要 3 天！因此，我们不提供实际时间，而是以标准构建单位 (SBU) 衡量时间。
	Linux From Scratch 12.0/chapter04_addinguser — Chinese (Simplified Han script)	When logged in as user <systemitem class="username">root</systemitem>, making a single mistake can damage or destroy a system. Therefore, the packages in the next two chapters are built as an unprivileged user. You could use your own user name, but to make it easier to set up a clean working environment, we will create a new user called <systemitem class="username">lfs</systemitem> as a member of a new group (also named <systemitem class="groupname">lfs</systemitem>) and run commands as &lfs-user; during the installation process. As <systemitem class="username">root</systemitem>, issue the following commands to add the new user:	在作为 <systemitem class="username">root</systemitem> 用户登录时，一个微小的错误就可能损坏甚至摧毁整个系统。因此，我们建议在后续两章中，以非特权用户身份编译软件包。您可以使用自己的系统用户，但为了更容易地建立一个干净的工作环境，最好创建一个名为 <systemitem class="username">lfs</systemitem> 的新用户，以及它从属于的一个新组 (组名也是 <systemitem class="groupname">lfs</systemitem>)，以便我们在安装过程中使用。为了创建新用户，以 <systemitem class="username">root</systemitem> 身份执行以下命令：
	Linux From Scratch 12.0/chapter08_wheel — Chinese (Simplified Han script)	<productname>wheel</productname> <productnumber>&wheel-version;</productnumber> <placeholder type="address" id="0"/>
	Linux From Scratch 12.0/chapter08_udev — Chinese (Simplified Han script)	<productname>udev</productname> <productnumber>&systemd-version;</productnumber> <placeholder type="address" id="0"/>
	Linux From Scratch 12.0/chapter08_cleanup — Chinese (Simplified Han script)	Finally, clean up some extra files left over from running tests:
	Linux From Scratch 12.0/chapter08_tcl — Chinese (Simplified Han script)	4.2.3	4.2.0
	Linux From Scratch 12.0/chapter08_pkgconf — Chinese (Simplified Han script)	<productname>pkgconf</productname> <productnumber>&pkgconf-version;</productnumber> <placeholder type="address" id="0"/>
	Linux From Scratch 12.0/chapter08_stripping — Chinese (Simplified Han script)	This section is optional. If the intended user is not a programmer and does not plan to do any debugging of the system software, the system's size can be decreased by some 2 GB by removing the debugging symbols, and some unnecessary symbol table entries, from binaries and libraries. This causes no real inconvenience for a typical Linux user.
	Linux From Scratch 12.0/chapter08_markupsafe — Chinese (Simplified Han script)	<productname>markupsafe</productname> <productnumber>&markupsafe-version;</productnumber> <placeholder type="address" id="0"/>
	Linux From Scratch 12.0/chapter08_jinja2 — Chinese (Simplified Han script)	<productname>jinja2</productname> <productnumber>&jinja2-version;</productnumber> <placeholder type="address" id="0"/>
	Linux From Scratch 12.0/chapter08_libxcrypt — Chinese (Simplified Han script)	<productname>libxcrypt</productname> <productnumber>&libxcrypt-version;</productnumber> <placeholder type="address" id="0"/>
	Linux From Scratch 12.0/chapter08_flit-core — Chinese (Simplified Han script)	<productname>flit-core</productname> <productnumber>&flit-core-version;</productnumber> <placeholder type="address" id="0"/>
	Linux From Scratch 12.0/chapter08_pkgmgt — Chinese (Simplified Han script)	Package Management is an often requested addition to the LFS Book. A Package Manager tracks the installation of files, making it easier to remove and upgrade packages. A good package manager will also handle the configuration files specially to keep the user configuration when the package is reinstalled or upgraded. Before you begin to wonder, NO&mdash;this section will not talk about nor recommend any particular package manager. What it does provide is a roundup of the more popular techniques and how they work. The perfect package manager for you may be among these techniques, or it may be a combination of two or more of these techniques. This section briefly mentions issues that may arise when upgrading packages.	经常有人请求将软件包管理加入 LFS 手册。包管理器可以跟踪文件的安装过程，简化移除或升级软件包的工作。如同处理二进制程序和库文件一样，包管理器也会处理配置文件的安装过程。在您开始想入非非前，不 —— 本节不会讨论或者推荐任何一个特定的包管理器。本节对软件包管理的流行技术及其工作原理进行综述。对您来说，完美的包管理器可能是其中的某个技术，也可能是几个技术的结合。本节还会简要介绍在升级软件包时可能遇到的问题。
	Linux From Scratch 12.0/prologue_prerequisites — Chinese (Simplified Han script)	Building an LFS system is not a simple task. It requires a certain level of existing knowledge of Unix system administration in order to resolve problems and correctly execute the commands listed. In particular, as an absolute minimum, you should already know how to use the command line (shell) to copy or move files and directories, list directory and file contents, and change the current directory. It is also expected that you know how to use and install Linux software.	构建 LFS 系统不是一项简单的任务。它需要您运用足够丰富的 Unix 系统管理知识来解决构建过程中的问题，并正确执行本书给出的命令。特别是，您至少需要拥有使用命令行 (shell) 来复制或移动文件和目录，列出目录或文件的内容，以及切换当前工作目录的能力。另外，我们希望您能够拥有一定水平的使用和安装 Linux 软件的知识。
	Linux From Scratch 12.0/prologue_why — Chinese (Simplified Han script)	The goal of LFS is to build a complete and usable foundation-level system&mdash;including all the packages needed to replicate itself&mdash;and providing a relatively minimal base from which to customize a more complete system based on the user's choices. This does not mean that LFS is the smallest system possible. Several important packages are included that are not, strictly speaking, required. The list below documents the reasons each package in the book has been included.	我们之前指出，LFS 的目标是构建一个完整且基本可用的系统。这包含所有重复构建 LFS 系统所需的软件包，以及在 LFS 提供的相对小的基础上根据用户需求，继续定制更完备的系统所必须的软件包。因此，LFS 并不是最小可用系统。LFS 中一些重要的软件包甚至不是必须安装的。下面列出了选择每个软件包的理由。
	Linux From Scratch 12.0/prologue_architecture — Chinese (Simplified Han script)	The primary target architectures of LFS are the AMD/Intel x86 (32-bit) and x86_64 (64-bit) CPUs. On the other hand, the instructions in this book are also known to work, with some modifications, with the Power PC and ARM CPUs. To build a system that utilizes one of these alternative CPUs, the main prerequisite, in addition to those on the next page, is an existing Linux system such as an earlier LFS installation, Ubuntu, Red Hat/Fedora, SuSE, or some other distribution that targets that architecture. (Note that a 32-bit distribution can be installed and used as a host system on a 64-bit AMD/Intel computer.)	LFS 的主要目标架构是 AMD/Intel 的 x86 (32 位) 和 x86_64 (64 位) CPU。此外，如果对本书中的一些指令作适当的修改，它们也应该适用于 Power PC 和 ARM 架构的 CPU。无论在其中哪种 CPU 上，构建 LFS 都至少需要一个现有的 Linux 系统，例如已经构建好的 LFS 系统，Ubuntu，Rad Hat/Fedora，SuSE，或者其他支持您的硬件架构的发行版，后文中还会介绍其他前提条件。另外，32 位发行版也能在 64 位的 AMD/Intel 计算机上正常运行，并作为 LFS 的构建环境。
	Linux From Scratch 12.0/prologue_errata — Chinese (Simplified Han script)	The software used to create an LFS system is constantly being updated and enhanced. Security warnings and bug fixes may become available after the LFS book has been released. To check whether the package versions or instructions in this release of LFS need any modifications&mdash;to repair security vulnerabilities or to fix other bugs&mdash;please visit <ulink url="&errata;"/> before proceeding with your build. You should note any changes shown and apply them to the relevant sections of the book as you build the LFS system.	用于构建 LFS 系统的软件处于不断更新和改进的过程中。在本书发布后，一些软件可能公布安全警告和漏洞修复补丁。为了确认本书提供的软件包版本或者构建命令是否需要修正，以反映最新的安全补丁或其他漏洞修复，请在开始构建 LFS 之前阅读 <ulink revision="sysv" url="&errata;"/> <ulink revision="systemd" url="&erratad;"/>。您应该关注勘误表列出的所有修正项，并在构建过程中注意对本书的相关章节进行修正。
	Linux From Scratch 12.0/chapter09_introduction — Chinese (Simplified Han script)	Booting a Linux system involves several tasks. The process must mount both virtual and real file systems, initialize devices, check file systems for integrity, mount and activate any swap partitions or files, set the system clock, bring up networking, start any daemons required by the system, and accomplish any other custom tasks specified by the user. This process must be organized to ensure the tasks are performed in the correct order and executed as quickly as possible.	引导 Linux 系统需要完成若干任务。引导过程必须挂载虚拟和真实文件系统、初始化设备、启用交换、检查文件系统完整性、挂载所有交换分区或文件、设定系统时钟、启用网络、启动系统需要的守护进程，并完成用户自定义的其他工作。引导过程必须被组织好，以保证这些任务以正确顺序进行，并以尽量快的速度完成。
	Linux From Scratch 12.0/chapter11_reboot — Chinese (Simplified Han script)	Now that all of the software has been installed, it is time to reboot your computer. However, there are still a few things to check. Here are some suggestions:
	Linux From Scratch 12.0/chapter11_afterlfs — Chinese (Simplified Han script)	Deciding what to do next
	Linux From Scratch 12.0/chapter03_packages — Chinese (Simplified Han script)	Read the <ulink url='&secadv;'>security advisories</ulink> before downloading packages to figure out if a newer version of any package should be used to avoid security vulnerabilities.
	Linux From Scratch 12.0/chapter03_introduction — Chinese (Simplified Han script)	This chapter includes a list of packages that need to be downloaded in order to build a basic Linux system. The listed version numbers correspond to versions of the software that are known to work, and this book is based on their use. We highly recommend against using different versions, because the build commands for one version may not work with a different version, unless the different version is specified by an LFS erratum or security advisory. The newest package versions may also have problems that require work-arounds. These work-arounds will be developed and stabilized in the development version of the book.	本章包含了构建基本的 Linux 系统时需要下载的软件包列表。我们给出的版本号对应于已经确定可以正常工作的版本，本书是基于这些版本编写的。我们强烈反对使用更新的版本，因为特定版本可用的构建命令未必适用于新版本。最新版本的软件包可能有需要排查的问题，我们会在本书的开发过程中进行排查，将解决方案找到并固定下来。
	Linux From Scratch 12.0/chapter01_how — Chinese (Simplified Han script)	The LFS system will be built by using an already installed Linux distribution (such as Debian, OpenMandriva, Fedora, or openSUSE). This existing Linux system (the host) will be used as a starting point to provide necessary programs, including a compiler, linker, and shell, to build the new system. Select the <quote>development</quote> option during the distribution installation to include these tools.	LFS 系统必须在一个已经安装好的 Linux 发行版 (如 Debian、OpenMandriva、Fedora 或者 openSUSE) 中构建。这个安装好的 Linux 系统 (称为宿主) 提供包括编译器、链接器和 shell 在内的必要程序，作为构建新系统的起点。请在安装发行版的过程中选择<quote>development</quote> (开发) 选项，以使用这些工具。
	Linux From Scratch 12.0/chapter01_changelog — Chinese (Simplified Han script)	This is version &version; of the Linux From Scratch book, dated &releasedate;. If this book is more than six months old, a newer and better version is probably already available. To find out, please check one of the mirrors via <ulink url="&lfs-root;mirrors.html"/>.	这是 Linux From Scratch 手册的 <phrase revision="sysv">&version;</phrase> <phrase revision="systemd">&versiond;</phrase> 版本，发布于 &releasedate;。如果该版本已经发布了六个月或更久，可能已经发布了更好的新版本。如果要查询是否有新版本，通过 <ulink url="&lfs-root;mirrors.html"/> 访问一个 LFS 镜像站。
	Linux From Scratch 12.0/chapter01_whatsnew — Chinese (Simplified Han script)	Here is a list of the packages updated since the previous release of LFS.	以下是自本书上一次发布之后，发生变化的软件包的清单。
	Linux From Scratch 12.0/chapter01_askforhelp — Chinese (Simplified Han script)	In case you've hit an issue building one package with the LFS instruction, we strongly discourage posting the issue directly onto the upstream support channel before discussing via a LFS support channel listed in <xref linkend="ch-intro-resources"/>. Doing so is often quite inefficient because the upstream maintainers are rarely familiar with LFS building procedure. Even if you've really hit an upstream issue, the LFS community can still help to isolate the information wanted by the upstream maintainers and make a proper report.
	Linux From Scratch 12.0/part3intro_introduction — Chinese (Simplified Han script)	This part is divided into three stages: first, building a cross compiler and its associated libraries; second, using this cross toolchain to build several utilities in a way that isolates them from the host distribution; and third, entering the chroot environment (which further improves host isolation) and constructing the remaining tools needed to build the final system.	本书的这一部分被分为三个阶段：首先构建一个交叉编译器和与之相关的库；然后使用这个交叉工具链构建一些工具，构建方法保证它们和宿主系统分离；最后进入 chroot 环境，以进一步提高与宿主的隔离度，并构建剩余的，在构建最终的系统时必须的工具。
	Linux From Scratch 12.0/part3intro_generalinstructions — Chinese (Simplified Han script)	Here are some things you should know about building each package:
	Linux From Scratch 12.0/part3intro_toolchaintechnotes — Chinese (Simplified Han script)	This section explains some of the rationale and technical details behind the overall build method. Don't try to immediately understand everything in this section. Most of this information will be clearer after performing an actual build. Come back and re-read this chapter at any time during the build process.	本节综合地解释构建方法中的逻辑和技术细节。您现在并不需要立刻理解本节的所有内容，在实际进行构建的过程中，可以更清晰地理解本节的信息。在整个构建过程中，您随时可以回来翻阅本节。
	Linux From Scratch 12.0/chapter08_groff — Greek	<productname>groff</productname> <productnumber>&groff-version;</productnumber> <placeholder type="address" id="0"/>
	Linux From Scratch 12.0/chapter08_file — Greek	<productname>file</productname> <productnumber>&file-version;</productnumber> <placeholder type="address" id="0"/>
	Linux From Scratch 12.0/chapter08_libcap — Greek	<productname>libcap</productname> <productnumber>&libcap-version;</productnumber> <placeholder type="address" id="0"/>
	Linux From Scratch 12.0/chapter08_iana-etc — Greek	<productname>iana-etc</productname> <productnumber>&iana-etc-version;</productnumber> <placeholder type="address" id="0"/>
	Linux From Scratch 12.0/chapter08_diffutils — Greek	<productname>diffutils</productname> <productnumber>&diffutils-version;</productnumber> <placeholder type="address" id="0"/>
	Linux From Scratch 12.0/prologue_why — Greek	The goal of LFS is to build a complete and usable foundation-level system&mdash;including all the packages needed to replicate itself&mdash;and providing a relatively minimal base from which to customize a more complete system based on the user's choices. This does not mean that LFS is the smallest system possible. Several important packages are included that are not, strictly speaking, required. The list below documents the reasons each package in the book has been included.
	Linux From Scratch 12.0/prologue_audience — Greek	There are many reasons why you would want to read this book. One of the questions many people raise is, <quote>why go through all the hassle of manually building a Linux system from scratch when you can just download and install an existing one?</quote>
	Linux From Scratch 12.0/prologue_standards — Greek	The structure of LFS follows Linux standards as closely as possible. The primary standards are:
	Linux From Scratch 12.0/prologue_architecture — Greek	The primary target architectures of LFS are the AMD/Intel x86 (32-bit) and x86_64 (64-bit) CPUs. On the other hand, the instructions in this book are also known to work, with some modifications, with the Power PC and ARM CPUs. To build a system that utilizes one of these alternative CPUs, the main prerequisite, in addition to those on the next page, is an existing Linux system such as an earlier LFS installation, Ubuntu, Red Hat/Fedora, SuSE, or some other distribution that targets that architecture. (Note that a 32-bit distribution can be installed and used as a host system on a 64-bit AMD/Intel computer.)
	Linux From Scratch 12.0/prologue_foreword — Greek	My journey to learn and better understand Linux began back in 1998. I had just installed my first Linux distribution and had quickly become intrigued with the whole concept and philosophy behind Linux.
	Linux From Scratch 12.0/prologue_organization — Greek	This book is divided into the following parts.
	Linux From Scratch 12.0/prologue_bookinfo — Greek	Version &version;
	Linux From Scratch 12.0/chapter09_networkd — Greek	network
	Linux From Scratch 12.0/chapter09_introduction — Greek	Booting a Linux system involves several tasks. The process must mount both virtual and real file systems, initialize devices, check file systems for integrity, mount and activate any swap partitions or files, set the system clock, bring up networking, start any daemons required by the system, and accomplish any other custom tasks specified by the user. This process must be organized to ensure the tasks are performed in the correct order and executed as quickly as possible.
	Linux From Scratch 12.0/chapter09_consoled — Greek	console
	Linux From Scratch 12.0/chapter09_inputrc — Greek	/etc/inputrc
	Linux From Scratch 12.0/chapter09_udev — Greek	Udev
	Linux From Scratch 12.0/chapter09_clock — Greek	clock
	Linux From Scratch 12.0/chapter09_introductiond — Greek	This chapter discusses configuration files and systemd services. First, the general configuration files needed to set up networking are presented.
	Linux From Scratch 12.0/chapter09_etcshells — Greek	/etc/shells
	Linux From Scratch 12.0/chapter09_usage — Greek	Bootscripts
	Linux From Scratch 12.0/chapter09_network — Greek	network
	Linux From Scratch 12.0/chapter09_locale — Greek	/etc/locale.conf
	Linux From Scratch 12.0/chapter09_profile — Greek	/etc/profile
	Linux From Scratch 12.0/chapter09_bootscripts — Greek	<productname>bootscripts</productname> <productnumber>&lfs-bootscripts-version;</productnumber> <placeholder type="address" id="0"/>
	Linux From Scratch 12.0/chapter09_systemd-custom — Greek	Systemd Customization
	Linux From Scratch 12.0/chapter06_binutils-pass2 — Greek	<productname>binutils-pass2</productname> <productnumber>&binutils-version;</productnumber> <placeholder type="address" id="0"/>
	Linux From Scratch 12.0/chapter06_introduction — Greek	This chapter shows how to cross-compile basic utilities using the just built cross-toolchain. Those utilities are installed into their final location, but cannot be used yet. Basic tasks still rely on the host's tools. Nevertheless, the installed libraries are used when linking.
	Linux From Scratch 12.0/chapter06_sed — Greek	<productname>sed</productname> <productnumber>&sed-version;</productnumber> <placeholder type="address" id="0"/>
	Linux From Scratch 12.0/chapter06_gzip — Greek	<productname>gzip</productname> <productnumber>&gzip-version;</productnumber> <placeholder type="address" id="0"/>
	Linux From Scratch 12.0/chapter06_grep — Greek	<productname>grep</productname> <productnumber>&grep-version;</productnumber> <placeholder type="address" id="0"/>
	Linux From Scratch 12.0/chapter06_diffutils — Greek	<productname>diffutils</productname> <productnumber>&diffutils-version;</productnumber> <placeholder type="address" id="0"/>
	Linux From Scratch 12.0/chapter06_chapter06 — Greek	Cross Compiling Temporary Tools
	Linux From Scratch 12.0/chapter11_whatnow — Greek	Thank you for reading this LFS book. We hope that you have found this book helpful and have learned more about the system creation process.
	Linux From Scratch 12.0/chapter11_reboot — Greek	Now that all of the software has been installed, it is time to reboot your computer. However, there are still a few things to check. Here are some suggestions:
	Linux From Scratch 12.0/chapter11_afterlfs — Greek	Deciding what to do next
	Linux From Scratch 12.0/chapter11_theend — Greek	/etc/lfs-release
	Linux From Scratch 12.0/chapter05_introduction — Greek	This chapter shows how to build a cross-compiler and its associated tools. Although here cross-compilation is faked, the principles are the same as for a real cross-toolchain.
	Linux From Scratch 12.0/chapter05_linux-headers — Greek	<productname>linux-headers</productname> <productnumber>&linux-version;</productnumber> <placeholder type="address" id="0"/>
	Linux From Scratch 12.0/chapter05_chapter05 — Greek	Compiling a Cross-Toolchain
	Linux From Scratch 12.0/chapter03_packages — Greek	Read the <ulink url='&secadv;'>security advisories</ulink> before downloading packages to figure out if a newer version of any package should be used to avoid security vulnerabilities.
	Linux From Scratch 12.0/chapter03_chapter03 — Greek	Packages and Patches
	Linux From Scratch 12.0/chapter03_patches — Greek	In addition to the packages, several patches are also required. These patches correct any mistakes in the packages that should be fixed by the maintainer. The patches also make small modifications to make the packages easier to work with. The following patches will be needed to build an LFS system:
	Linux From Scratch 12.0/part3intro_introduction — Greek	This part is divided into three stages: first, building a cross compiler and its associated libraries; second, using this cross toolchain to build several utilities in a way that isolates them from the host distribution; and third, entering the chroot environment (which further improves host isolation) and constructing the remaining tools needed to build the final system.

• 3 / 99
  / 99