Secrets du système de fichiers racine Linux

Linux est un système d'exploitation open source, portable et personnalisable, largement utilisé dans divers domaines, tels que les serveurs, les ordinateurs de bureau, les appareils embarqués, etc. Le cœur de Linux est le noyau, chargé de gérer les ressources matérielles et de fournir les services de base. Cependant, le noyau n'est pas une entité indépendante et nécessite un système de fichiers pour stocker et accéder à diverses données et programmes. Un système de fichiers est une méthode d'organisation et de gestion de fichiers. Il définit le nom, l'emplacement, les attributs, les autorisations et d'autres informations du fichier. Sous Linux, il existe de nombreux types de systèmes de fichiers, tels que ext4, xfs, btrfs, etc., chacun ayant ses propres caractéristiques et avantages. Cependant, parmi tous les systèmes de fichiers, il existe un système de fichiers spécial, qui constitue la base et le cœur du système Linux, à savoir le système de fichiers racine (rootfs). Alors, quel est le système de fichiers racine ? Qu'est ce que ça fait? Comment est-il créé et géré ? Cet article répondra aux questions sous les aspects suivants :

1. Système de fichiers racine

Un système de fichiers est une structure de répertoires incluse dans un disque (y compris les disques optiques, les disquettes, les disques flash et autres périphériques de stockage) ou dans des partitions ; un périphérique de disque applicable peut contenir un ou plusieurs systèmes de fichiers si vous souhaitez accéder à un système de fichiers ; , La première chose que vous devez faire est de monter le système de fichiers ; pour monter le système de fichiers, vous devez spécifier un point de montage.

Remarque : pour le développement de notre application, lors de l'achat d'une carte de développement, le fabricant fournira un système de fichiers racine prêt à l'emploi et un BootLoader. Si nécessaire, nous pouvons modifier les commandes sans créer un nouveau système de fichiers racine à partir de zéro. Cependant, le processus de production ici peut nous permettre de mieux comprendre le système de fichiers Linux.

2. Système de fichiers racine principal

* Sous Linux, rootfs est indispensable. Le PC implémente principalement le disque virtuel et monte directement le système de fichiers racine sur le disque dur (disque dur, disque dur) ; les systèmes embarqués ne démarrent généralement pas à partir du disque dur, mais à partir de Flash. La méthode la plus simple consiste à charger les rootfs sur le disque RAM de la RAM. la première consiste à lire Cramfs directement à partir de Flash, et la plus compliquée consiste à partitionner sur Flash et à créer un système de fichiers tel que JFFS2.

* RAMDisk compresse le rootfs préparé et l'écrit dans Flash. Au démarrage, le chargeur de démarrage le charge dans la RAM, le décompresse, puis le monte sur /. Cette méthode est simple à utiliser, mais le système de fichiers en RAM n'est pas compressé, elle nécessite donc de la RAM, une ressource rare dans de nombreux systèmes embarqués.

ramdisk utilise l'espace mémoire pour simuler les partitions du disque dur. Ramdisk utilise généralement la compression du système de fichiers disque et est stocké en flash lors de l'initialisation du système, il est décompressé en SDRAM et monté avec le système de fichiers racine. Dans les systèmes Linux, il existe deux types de fichiers. ramdisk , l'un est qu'il peut être formaté et chargé, et est déjà pris en charge dans le noyau Linux 2.0/2.2. Son inconvénient est que la taille est fixe ; l'autre n'est pris en charge que par le noyau 2.4 et est implémenté via ramfs. être formaté. Mais il est facile à utiliser et sa taille augmente ou diminue avec l'espace requis. Il s'agit d'une technologie de disque virtuel couramment utilisée sous Linux à l'heure actuelle.

* initrd est le format de RAMDisk. Avant le noyau 2.4, c'était image-initrd. Le noyau 2.5 introduisait cpio-initrd, ce qui simplifiait grandement le processus de démarrage de Linux et était conforme à la philosophie de base de Linux : restez simple, stupide (KISS). Cependant, en tant que nouveau format, cpio-initrd n'a pas été testé de manière approfondie. Il est principalement utilisé dans Linux embarqué.

* Cramfs est un système de fichiers très simple écrit par Linus. Il a une bonne compression et peut également être exécuté directement à partir de Flash sans chargement dans la RAM, économisant ainsi de la RAM. Cependant, Cramfs est en lecture seule, ce qui n'est pas pratique pour les répertoires qui doivent être modifiés au moment de l'exécution (tels que /etc, /var, /tmp). Par conséquent, ces répertoires sont généralement transformés en fs inscriptibles tels que ramfs.

* SquashFS est une amélioration de Cramfs. Brisant certaines limitations de Cramfs, il présente également des avantages en termes d'utilisation du Flash et de la RAM. Cependant, selon les développeurs, il pourrait ne pas être aussi performant que Cramfs en termes de performances. Il s'agit également d'une nouvelle approche qui nécessitera davantage de tests avant d'être adoptée dans les systèmes embarqués.

3.Production de disque RAM

Comment créer un RAMDisk est le suivant :
(1) Dans l'environnement du système d'exploitation Linux du PC, générez un fichier qui peut être virtualisé dans un périphérique bloc. Supposons que le nom du fichier soit init.img.

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

où bs*count est la taille du périphérique bloc (unité : octets). Après avoir généré le fichier init.img, le fichier doit également être formaté.

$ mke2fs –m0 –F init.img

(2) Créez un nouveau dossier ram et attachez init.img au répertoire ram.

$ 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

Grâce à l'analyse ci-dessus, nous pouvons voir que le système de fichiers racine est une partie importante du système Linux. Il contient les fichiers et répertoires clés nécessaires au démarrage et au fonctionnement du système Linux. Le système de fichiers racine est généralement monté sous le répertoire / (racine) et peut contenir des points de montage pour d'autres systèmes de fichiers. Les systèmes de fichiers racine peuvent utiliser différents types de formats de système de fichiers et peuvent être créés et gérés via un certain nombre d'outils. Par exemple, nous pouvons utiliser la commande mkfs pour formater une partition ou un périphérique en tant que système de fichiers racine, nous pouvons utiliser la commande mount pour monter ou démonter un système de fichiers racine, nous pouvons utiliser la commande df pour afficher l'utilisation d'un fichier racine. système, etc En bref, le système de fichiers racine est le secret du système Linux, qui fournit une base stable et flexible au système Linux.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!