Geheimnisse des Linux-Root-Dateisystems

Linux ist ein tragbares, anpassbares Open-Source-Betriebssystem, das in verschiedenen Bereichen wie Servern, Desktops, eingebetteten Geräten usw. weit verbreitet ist. Der Kern von Linux ist der Kernel, der für die Verwaltung der Hardwareressourcen und die Bereitstellung grundlegender Dienste verantwortlich ist. Der Kernel ist jedoch keine unabhängige Einheit und benötigt ein Dateisystem, um verschiedene Daten und Programme zu speichern und darauf zuzugreifen. Ein Dateisystem ist eine Methode zum Organisieren und Verwalten von Dateien. Es definiert den Namen, den Speicherort, die Attribute, Berechtigungen und andere Informationen der Datei. Unter Linux gibt es viele verschiedene Arten von Dateisystemen, wie z. B. ext4, xfs, btrfs usw., von denen jedes seine eigenen Eigenschaften und Vorteile hat. Unter allen Dateisystemen gibt es jedoch ein spezielles Dateisystem, das die Grundlage und den Kern des Linux-Systems bildet, nämlich das Root-Dateisystem (rootfs). Was ist also das Root-Dateisystem? Was tut es? Wie wird es erstellt und verwaltet? In diesem Artikel werden die Fragen unter folgenden Gesichtspunkten beantwortet:

1. Root-Dateisystem

Ein Dateisystem ist eine Verzeichnisstruktur, die in einer Festplatte (einschließlich optischer Festplatten, Disketten, Flash-Festplatten und anderen Speichergeräten) enthalten ist. Ein entsprechendes Festplattengerät kann ein oder mehrere Dateisysteme enthalten , Als Erstes müssen Sie das Dateisystem mounten. Um das Dateisystem zu mounten, müssen Sie einen Mountpunkt angeben.

Hinweis: Für unsere Anwendungsentwicklung stellt der Hersteller beim Kauf eines Entwicklungsboards ein vorgefertigtes Root-Dateisystem und BootLoader zur Verfügung. Bei Bedarf können wir die Befehle ändern, ohne ein neues Root-Dateisystem zu erstellen. Der Produktionsprozess hier kann uns jedoch ein tieferes Verständnis des Linux-Dateisystems vermitteln.

2. Haupt-Root-Dateisystem

* Unter Linux ist rootfs unerlässlich. Der PC implementiert hauptsächlich Ramdisk und mountet das Root-Dateisystem im Allgemeinen nicht von HD, sondern von Flash. Die einfachste Methode besteht darin, Rootfs in die RAMDisk zu laden Eine besteht darin, Cramfs direkt aus Flash zu lesen, und die kompliziertere Möglichkeit besteht darin, auf Flash zu partitionieren und ein Dateisystem wie JFFS2 zu erstellen.

* RAMDisk komprimiert die vorbereiteten Rootfs und schreibt sie in Flash. Beim Start lädt der Bootloader sie in den RAM, dekomprimiert sie und mountet sie dann in /. Diese Methode ist einfach zu bedienen, aber das Dateisystem im RAM ist nicht komprimiert und erfordert daher RAM, eine knappe Ressource in vielen eingebetteten Systemen.

ramdisk verwendet Speicherplatz, um Festplattenpartitionen zu simulieren und wird während der Systeminitialisierung im SDRAM gespeichert. In Linux-Systemen gibt es zwei Arten von ramdisk: Zum einen kann es formatiert und geladen werden und wird bereits im Linux-Kernel 2.0/2.2 unterstützt. Das andere ist, dass die Größe nur vom 2.4-Kernel unterstützt wird und nicht über ramfs implementiert werden kann Aber es ist einfach zu verwenden und seine Größe vergrößert oder verkleinert sich je nach benötigtem Speicherplatz. Es handelt sich derzeit um eine häufig verwendete Ramdisk-Technologie.

* initrd ist das Format von RAMDisk. Mit image-initrd wurde in Kernel 2.5 cpio-initrd eingeführt, was den Linux-Startvorgang erheblich vereinfachte und der Grundphilosophie von Linux entsprach: Keep it simple, dump (KISS). Allerdings wurde cpio-initrd als neues Format hauptsächlich in eingebettetem Linux verwendet.

* Cramfs ist ein sehr einfaches Dateisystem, das von Linus geschrieben wurde. Es verfügt über eine gute Komprimierung und kann auch direkt aus Flash ausgeführt werden, ohne in den RAM zu laden, wodurch RAM gespart wird. Allerdings ist Cramfs schreibgeschützt, was für Verzeichnisse, die zur Laufzeit geändert werden müssen (z. B. /etc, /var, /tmp), unpraktisch ist. Daher werden diese Verzeichnisse im Allgemeinen in beschreibbare FS umgewandelt, z. B. ramfs.

* SquashFS ist eine Erweiterung zu Cramfs. Es durchbricht einige Einschränkungen von Cramfs und bietet auch Vorteile hinsichtlich der Flash- und RAM-Nutzung. Den Entwicklern zufolge ist es jedoch hinsichtlich der Leistung möglicherweise nicht so gut wie Cramfs. Dies ist auch ein neuer Ansatz, der vor der Einführung in eingebetteten Systemen weitere Tests erfordert.

3.Ramdisk-Produktion

So erstellen Sie eine RAMDisk:
(1) Generieren Sie in der Linux-Betriebssystemumgebung des PCs eine Datei, die in ein Blockgerät virtualisiert werden kann. Gehen Sie davon aus, dass der Dateiname init.img lautet.

$ dd if=/dev/zero of=init.img bs=4096 count=1024

wobei bs*count die Blockgerätegröße ist (Einheit: Bytes). Nach dem Generieren der init.img-Datei muss die Datei auch formatiert werden.

$ mke2fs –m0 –F init.img

(2) Erstellen Sie einen neuen Ordner ram und hängen Sie init.img an das ram-Verzeichnis an.

$ mkdir ram
$ mount init.img ram/ -o loop

这时，读写ram目录，等效于读写init.img文件。用户可以将根文系统所需的文件写入到ram目录中。往ram目录写完文件以后，还需要使用umount ram命令卸载init.img，才能将已写入的文件保存到init.img中。

（3）添加完毕，需要umount ram

4.Cramfs制作

CramFS(Compressed Rom File System)是Linux Torvalds在Transmeta任职时，所参与开发的文件系统。它是针对Linux内核2.4之后的版本所设计的一种新型只读文件系统，采用了zlib 压缩，压缩比一般可以达到1：2，但仍可以作到高效的随机读取，Linux系统中，通常把不需要经常修改的目录压缩存放，并在系统引导的时候再将压缩文件 解开。因为Cramfs不会影响系统的读取文件的速度，而且是一个高度压缩的文件系统。因此非常广泛应用于嵌入式系统中。

在嵌入式的 环境之下，内存和外存资源都需要节约使用。如果使用RAMDISK方式来使用文件系统，那么在系统运行之后，首先要把Flash上的映像文件解压缩到内存 中，构造起RAMDISK环境，才可以开始运行程序。但是它也有很致命的弱点。在正常情况下，同样的代码不仅在Flash中占据了空间(以压缩后的形式存 在)，而且还在内存中占用了更大的空间(以解压缩之后的形式存在)，这违背了嵌入式环境下尽量节省资源的要求。

使用CramFS文件 系统就是一种解决这个问题的方式。CramFS是一个压缩格式的文件系统，它并不需要一次性地将文件系统中的所有内容都解压缩到内存之中，而只是在系统需 要访问某个位置的数据的时候，马上计算出该数据在CramFS中的位置，将它实时地解压缩到内存之中，然后通过对内存的访问来获取文件系统中需要读取的数 据。CramFS中的解压缩以及解压缩之后的内存中数据存放位置都是由CramFS文件系统本身进行维护的，用户并不需要了解具体的实现过程，因此这种方 式增强了透明度，对开发人员来说，既方便，又节省了存储空间。

但是Cramfs也有其缺点：延迟、小于16MB、不支持写，只支持PAGE_CREATE_SIZE=4096的内核。

制作的命令：（root文件夹中存放着文件系统）

#mkcramfs root cramfs.img

5.其他根文件系统的制作

制作yaffs文件系统： mkyaffsimage myroots myroots.img
制作squashfs： mksquashfs $(FS_DIR) $(FS_NAME) -noappend -be -lzma -no-fragments –noI

6.BusyBox编译制作

建立目标板空根目录文件夹及根目录下的文件夹：

[root@190 friendly-arm]# mkdir myroots
[root@190 friendly-arm]#pwd
/friendly-arm/myroots
[root@190 friendly-arm]#cd myroots
[root@190 myroots]# mkdir bin sbin usr lib dev mnt opt root etc home proc tmp var
[root@190 myroots]# mkdir etc/init.d

进入etc/init.d目录下，建立一个脚本文件，并命名为rcS，用gedit打开，添加如下内容：

#! /bin/sh
PATH=/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/bin:
runlevel=S
prevlevel=N
umask 022
export PATH runlevel prevlevel
#
# Trap CTRL-C &c only in this shell so we can interrupt subprocesses.
#
trap ":" INT QUIT TSTP

创建 dev 中的节点
如果使用“linux 2.6.xx”的内核，应该事先创建节点“console”、“null”。否则在系统启动时内容会提示以下错误：

Warning: unable to open an initial console.
Kernel panic - not syncing: Attempted to kill init!

创建节点的命令如下：

# mknod dev/console c 5 1
# mknod dev/null c 1 3 移植Busybox：

进入到压缩文件存放的目录下，并解压。然后进入解压后的busybox目录文件夹，随后配置busybox 。

[root@190 busybox-1.2.0]# make menuconfig

由于每个版本的配置选项组织有所不同。不管怎样，我们注意以下选项就行了：

1) Support for devfs
2) Build BusyBox as a static binary ( no shared libs ) //将busybox编译成静态链接
3) Do you want to build busybox with a Cross Compile?
(/usr/local/arm/3.3.2/bin/arm-linux-) Cross Compile prefix //指定交叉编译器
4) init
5) Support reading an inittab file //支持init读取/etc/inittab 配置文件
6) (X) ash选中ash //建立的rcS脚本才能执行
7）ash
8）cp cat ls mkdir mv //可执行命令工具的选择，自己看着办吧，需要用到的就选上
9) mount
10) umount
11) Support loopback mounts
12) Support for the old /etc/mtab file
13) insmod
14) Support version 2.2.x to 2.4.x Linux kernels
15) Support version 2.6.x Linux kernels
16) vi
17)don’t use user

以上内容必须选上，其他可按默认值；如果要支持其他功能，如网络支持等，可按需选择，英语不是很烂的话，这些都没有问题。
配置好之后，保存退出。然后对其编译和安装到刚才建立的根文件系统目录下：

[root@190 busybox-1.2.0] make TARGET_ARCH=arm CROSS=arm-linux- \ PREFIX=/friendly-arm/myroots/ all install

安装好之后，将相应的二进制文件拷贝到根文件系统相应的目录下：
拷贝一些管理员控制程序到/sbin目录下，最重要的就是要包含一个init命令；
拷贝应用程序运行时所需要的库到/lib，库文件可以从PC机上的交叉编译工具安装目录下拷贝，如libc-2.2.2.so、libcryt-2.2.2.so、libm-2.2.2.so、libutil-2.2.2.so等，为部分相应库建立快捷方式，提供一些应用程序按快 捷方式名称调用。值得注意的是C库要采用C库的版本glibc, glibc位于/lib/libc.so.6

Anhand der obigen Analyse können wir erkennen, dass das Root-Dateisystem ein wichtiger Teil des Linux-Systems ist. Es enthält wichtige Dateien und Verzeichnisse, die für den Start und Betrieb des Linux-Systems erforderlich sind. Das Root-Dateisystem wird normalerweise im Verzeichnis / (Root) gemountet und kann Mountpunkte für andere Dateisysteme enthalten. Root-Dateisysteme können verschiedene Arten von Dateisystemformaten verwenden und mit einer Reihe von Tools erstellt und verwaltet werden. Beispielsweise können wir den Befehl mkfs verwenden, um eine Partition oder ein Gerät als Root-Dateisystem zu formatieren, wir können den Befehl mount verwenden, um ein Root-Dateisystem zu mounten oder die Bereitstellung aufzuheben, und wir können den Befehl df verwenden, um die Nutzung einer Root-Datei anzuzeigen System usw. Kurz gesagt, das Root-Dateisystem ist das Geheimnis des Linux-Systems und bietet eine stabile und flexible Grundlage für das Linux-System.

Das obige ist der detaillierte Inhalt vonGeheimnisse des Linux-Root-Dateisystems. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!