Maison > Article > Tutoriel système > E/S de fichiers Linux : principes et méthodes
E/S de fichiers Linux : principes et méthodes
- PHPzavant
- 2024-02-09 18:27:27801parcourir
Les fichiers constituent la méthode de stockage de données la plus basique et la plus couramment utilisée dans les systèmes Linux. Il peut s'agir de fichiers texte, de fichiers binaires, de fichiers de périphérique, de fichiers de répertoire, etc. La lecture et l'écriture de fichiers sont l'une des opérations les plus importantes de la programmation Linux. Elle implique des concepts tels que les descripteurs de fichiers, les tampons, les appels système et les fonctions de bibliothèque. Dans cet article, nous présenterons les principes et méthodes de base des E/S de fichiers Linux, notamment l'ouverture, la fermeture, la lecture, l'écriture, le positionnement, la troncature, la synchronisation et d'autres opérations, et donnerons des exemples pour illustrer leur utilisation et leurs précautions.
Descripteur de fichier
un petit entier non négatif à utiliser dans les appels système ultérieurs (read(2), write(2), lseek(2), fcntl(2), etc.) ($man 2 open). il y a généralement 3 descripteurs de fichiers ouverts :
- 0 : STDIN_FIFLENO, entrée standard stdin
- 1 : STDOUT_FILENO, sortie standard stdout
- 2 : STDERR_FILENO, erreur standard stderror
principe fd
- fd commence à 0, recherche le plus petit descripteur inutilisé et établit une relation correspondante entre le pointeur de la table de fichiers et le descripteur de la table de fichiers (VS pid continue d'augmenter et revient lorsqu'il est plein)
- Le descripteur de fichier est un entier, utilisé pour représenter un fichier ouvert, mais les informations de gestion du fichier ne peuvent pas être stockées dans le descripteur de fichier. Lors de l'utilisation de la fonction open() pour ouvrir un fichier, le système d'exploitation chargera les informations pertinentes du fichier. fichier dans Cependant, en raison de facteurs tels que la sécurité et l'efficacité, les structures de données telles que les tables de fichiers ne sont pas adaptées à une opération directe. Au lieu de cela, un numéro est attribué à la structure et le numéro est utilisé pour les opérations.
- Le système d'exploitation maintiendra une table principale de descripteur de fichier en interne pour chaque processus. Lorsqu'un nouveau descripteur de fichier est nécessaire, il recherchera le plus petit descripteur inutilisé dans la table principale et le renverra. Bien que le descripteur de fichier soit de type int, Mais il s'agit en fait d'un entier non négatif, c'est-à-dire 0~OPEN_MAX (1024 dans le système actuel), dont 0, 1 et 2 ont été occupés par le système, représentant respectivement stdin, stdout et stderror
- Lors de l'utilisation de close() pour fermer un fd, la correspondance entre le fd et la structure de la table de fichiers est supprimée de la table totale, mais la structure de la table de fichiers ne sera pas nécessairement supprimée, uniquement lorsque la table de fichiers ne correspond à aucun autre fd. (c'est-à-dire qu'une table de fichiers peut correspondre à plusieurs fds en même temps) avant que la table de fichiers ne soit supprimée, close() ne modifiera pas la valeur entière du descripteur de fichier lui-même, cela rendra seulement le descripteur de fichier incapable de représenter un fichier
- duplicate fdVS copy fd:dup copie le pointeur de table de fichiers correspondant à old_fd vers new_fd, au lieu de int new_fd=old_fd
-
UNIX utilise trois structures de données pour décrire les fichiers ouverts : la table de descripteur de fichier utilisée pour décrire le fichier ouvert par le processus en cours dans chaque processus, la table d'identification de l'état du fichier représentant l'état actuel du fichier et le fichier i-node utilisé pour trouver la Table de nœuds V
du fichier (nœud d'index). Cette structure de nœud V n'est pas utilisée sous Linux. Il s'agit plutôt d'une structure d'inode générale, mais il n'y a pas de différence essentielle. le système de fichiers lors de la lecture d'un fichier. Emplacement du fichier
Drapeau de descripteur de fichier
close-on-execLe système actuel n'a qu'un seul indicateur de descripteur de fichier
- Généralement, nous appellerons exec pour exécuter un autre programme. À ce stade, le texte, les données, le tas et la pile du processus enfant seront remplacés par un nouveau programme. À ce stade, bien sûr, la variable qui contient le descripteur de fichier n'existe plus et nous ne pouvons pas fermer le descripteur de fichier inutile. Donc, généralement, nous forçons le processus enfant et exécutons directement close dans le processus enfant pour désactiver les descripteurs de fichiers inutiles, puis exécutons exec. Cependant, dans les systèmes complexes, nous ne savons parfois plus combien de descripteurs de fichiers (y compris les handles de socket, etc.) sont ouverts lorsque nous forçons le processus enfant. À ce stade, il est vraiment difficile de nettoyer un par un. Ce que nous attendons, c'est de le spécifier lors de l'ouverture d'un descripteur de fichier avant de bifurquer le processus enfant : je fermerai ce handle lors de l'exécution de exec après avoir bifurqué le processus enfant. " Il y a donc close-on-exec
- Chaque descripteur de fichier possède un indicateur de fermeture à l'exécution. Par défaut du système, le dernier bit de cet indicateur est défini sur 0. Ce drapeau est désactivé. Ensuite, lorsque le processus enfant appelle la fonction exec, le processus enfant ne fermera pas le descripteur de fichier. À ce stade, les processus parent et enfant partageront le fichier. Ils ont la même entrée de table de fichiers et le même décalage de fichier.
-
fcntl()的FD_CLOEXEC和open()的O_CLOEXEC用来设置文件的close-on-execLorsque l'indicateur close-on-exec est défini sur 1, cet indicateur est activé. À ce moment, avant que le processus enfant n'appelle la fonction exec, le système a déjà demandé au processus enfant de fermer le descripteur de fichier.
Remarque : Bien que la nouvelle version prenne en charge la définition de CLOEXEC lors de l'ouverture, une erreur sera toujours affichée lors de la compilation – erreur : 'O_CLOEXEC' non déclaré (première utilisation dans cette fonction). Cette fonction doit être activée en définissant la macro (_GNU_SOURCE).
#define _GNU_SOURCE //在源代码中加入 -D_GNU_SOURCE //在编译参数中加入
Drapeau d'état du fichier
Les indicateurs d'état de fichier sont utilisés pour représenter les attributs d'un fichier ouvert. L'indicateur d'état de fichier peut partager l'état du même fichier ouvert en dupliquant un descripteur de fichier, mais pas l'indicateur de descripteur de fichier.
- Modes d'accès : Spécifiez le mode d'accès au fichier : lecture seule, écriture seule, lecture-écriture. Défini par open(), renvoyé par fcntl(), mais ne peut pas être modifié
- Drapeaux d'ouverture : Indique l'opération lorsque open() est exécuté. Cet indicateur ne sera pas enregistré après l'exécution de open().
- Modes de fonctionnement : Affecte les opérations de lecture et d'écriture, définies via open(), mais peut être lu ou modifié avec fcntl()
ouvert()
//给定一个文件路径名，按照相应的选项打开文件，就是将一个fd和文件连接到一起，成功返回文件描述符，失败返
回-1设errno
#include
int open(const char *pathname, int flags)
int open(const char *pathname, int flags, mode_t mode)//不是函数重载,C中没有重载, 是可变长参数列
表
//pathname:文件或设备路径
//flags :file status flags=Access mode+Open-time flags+Operating Modes、
/*Access Mode(必选一个):
O_RDONLY：0
O_WRONLY：1
O_RDWR：2
*/
/*Open-time Flags(Bitwise Or):
O_CLOEXEC ：为新打开的文件描述符使能close-on-exec。可以避免程序再用fcntl()的F_SETFD来设置
FD_CLOEXEC
O_CREAT ：如果文件不存在就创建文件，并返回它的文件描述符，如果文件存在就忽略这个选项，必须在保护模式
下使用，eg：0664
O_DIRECTORY ：如果opendir()在一个FIFO或tape中调用的话，这个选项可以避免denial-of-service问题， 如
果路径指向的不是一个目录，就会打开失败。
O_EXCL ：确保open()能够穿件一个文件，如果文件已经存在，则会导致打开失败，总是和O_CREAT一同使用。
O_NOCTTY ：如果路径指向一个终端设备，那么这个设备不会成为这个进程的控制终端，即使这个进程没有一个控制
终端
O_NOFOLLOW ：如果路径是一个符号链接，就打开它链接的文
件//If pathname is a symbolic link, then the open fails.
O_TMPFILE ：创建一个无名的临时文件，文件系统中会创建一个无名的inode，当最后一个文件描述符被关闭的时
候，所有写入这个文件的内容都会丢失，除非在此之前给了它一个名字
O_TRUNC ：清空文件
O_TTY_INIT
*/
/*Operating Modes(Bitwise Or)
O_APPEND ：以追加的方式打开文件, 默认写入结尾，在当下的Unix/Linux系统中，这个选项已经被定义为一个原
子操作
O_ASYNC ：使能signal-driven I/O
O_DIRECT ：试图最小化来自I/O和这个文件的
cache effect//Try to minimize cache effects of the I/O to and from this file.
O_DSYNC ：每次写操作都会等待I/O操作的完成，但如果文件属性的更新不影响读取刚刚写入的数据的话，就不会
等待文件属性的更新 。
O_LARGEFILE ：允许打开一个大小超过off_t(但没超过off64_t)表示范围的文件
O_NOATIME ：不更改文件的st_time(last access time)
O_NONBLOCK /O_NDELAY ：如果可能的话，用nonblock模式打开文件
O_SYNC ：每次写操作都会等待I/O操作的完成，包括write()引起的文件属性的更新。
O_PATH ：获得一个能表示文件在文件系统中位置的文件描述符
#include
#include
int fd=open("b.txt",O_RDWR|O_CREAT|O_EXCL,0664);
if(-1==fd)
perror("open"),exit(-1);
FQ :Pourquoi Bitwise ORed :
FA : On suppose qu'il existe le modèle suivant : utilisez une chaîne de chaînes où un bit vaut 1 et les autres sont tous 0 pour représenter une option, et les options peuvent être "AND au niveau du bit" pour obtenir une chaîne 0/1, représente l'état de l'ensemble des drapeaux. Remarque : les trois chiffres inférieurs représentent le mode d'accès
créer()
Équivaut à appeler open() avec le drapeau O_WRONLY |O_TRUNC|O_CREAT
#include int creat(const char *pathname, mode_t mode);
dup()、dup2()、dup3()
//复制一个文件描述符的指向，新的文件描述符的flags和原来的一样，成功返回new_file_descriptor, 失败返
回-1并设errno
#include
int dup(int oldfd); //使用未被占用的最小的文件描述符编号作为新的文件描述符
int dup2(int oldfd, int newfd);
#include
#include
int dup3(int oldfd, int newfd, int flags);
#include
#include
int res=dup2(fd,fd2);
if(-1==res){
perror("dup2"),exit(-1);
read()
//从fd对应的文件中读count个byte的数据到以buf开头的缓冲区中，成功返回成功读取到的byte的数目，失败返回-1设errno
#include
ssize_t read(int fd, void *buf, size_t count);
#include
#include
int res=read(fd,buf,6);
if(-1==fd)
perror("read"),exit(-1);
write()
//从buf指向的缓冲区中读取count个byte的数据写入到fd对应的文件中，成功返回成功写入的byte数目，文件的位置指针会向前移动这个数目，失败返回-1设errno
#include
ssize_t write(int fd, const void *buf, size_t count);//不需要对buf操作, 所以有const, VS read()没有const
#include
#include
int res=write(fd,"hello",sizeof("hello"));
if(-1==res)
perror("write"),exit(-1);
Note: 上例中即使只有一个字符’A’,也要写”A”,因为”A”才是地址,’A’只是个int
lseek()
l 表示long int, 历史原因
//根据移动基准whence和移动距离offset对文件的位置指针进行重新定位，返回移动后的位置指针与文件开头的距离，失败返回-1设errno
#include
#include
off_t lseek(int fd, off_t offset, int whence);
/*whence:
SEEK_SET：以文件开头为基准进行偏移，0一般不能向前偏
SEEK_CUR：以当前位置指针的位置为基准进行偏移，1向前向后均可
SEEK_END：以文件的结尾为基准进行偏移，2向前向后均可向后形成”文件空洞”
#include
#include
int len=lseek(fd,-3,SEEK_SET);
if(-1==len){
perror("lseek"),exit(-1);
fcntl()
//对fd进行各种操作，成功返回0,失败返回-1设errno
#include
#include
int fcntl(int fd, int cmd, ... ); //...表示可变长参数
/*cmd:
Adversory record locking:
F_SETLK(struct flock*) //设建议锁
F_SETLKW(struct flock*) //设建议锁，如果文件上有冲突的锁，且在等待的时候捕获了一个信号，则调用被打断并在信号捕获之后立即返回一个错误，如果等待期间没有信号，则一直等待
F_GETLK(struct flock*) //尝试放锁，如果能放锁，则不会放锁，而是返回一个含有F_UNLCK而其他不变的l_type类型，如果不能放锁，那么fcntl()会将新类型的锁加在文件上，并把当前PID留在锁上
Duplicating a file descriptor:
F_DUPFD (int) //找到>=arg的最小的可以使用的文件描述符，并把这个文件描述符用作fd的一个副本
F_DUPFD_CLOEXEC(int)//和F_DUPFD一样，除了会在新的文件描述符上设置close-on-exec
F_GETFD (void) //读取fd的flag，忽略arg的值
F_SETFD (int) //将fd的flags设置成arg的值.
F_GETFL (void) //读取fd的Access Mode和其他的file status flags; 忽略arg
F_SETFL (long) //设置file status flags为arg
F_GETOWN(void) //返回fd上接受SIGIO和SIGURG的PID或进程组ID
F_SETOWN(int) //设置fd上接受SIGIO和SIGURG的PID或进程组ID为arg
F_GETOWN_EX(struct f_owner_ex*) //返回当前文件被之前的F_SETOWN_EX操作定义的文件描述符R
F_SETOWN_EX(struct f_owner_ex*) //和F_SETOWN类似，允许调用程序将fd的I/O信号处理权限直接交给一个线程，进程或进程组
F_GETSIG(void) //当文件的输入输出可用时返回一个信号
F_SETSIG(int) //当文件的输入输出可用时发送arg指定的信号
*/
/*…:
可选参素，是否需要得看cmd，如果是加锁，这里应是struct flock*
struct flock {
short l_type; //%d Type of lock: F_RDLCK(读锁), F_WRLCK(写锁), F_UNLCK(解锁)
short l_whence; //%d How to interpret l_start, 加锁的位置参考标准:SEEK_SET, SEEK_CUR, SEEK_END
off_t l_start; //%ld Starting offset for lock, 加锁的起始位置
off_t l_len; //%ld Number of bytes to lock , 锁定的字节数
pid_t l_pid; // PID of process blocking our lock, (F_GETLK only)加锁的进程号,,默认给-1
};
*/
建议锁(Adversory Lock)
限制加锁,但不限制读写, 所以只对加锁成功才读写的程序有效,用来解决不同的进程 同时对同一个文件的同一个位置 “写”导致的冲突问题
读锁是一把共享锁(S锁):共享锁+共享锁+共享锁+共享锁+共享锁+共享锁
写锁是一把排他锁(X锁):永远孤苦伶仃
释放锁的方法(逐级提高):
- 将锁的类型改为:F_UNLCK, 再使用fcntl()函数重新设置
- close()关闭fd时, 调用进程在该fd上加的所有锁都会自动释放
- 进程结束时会自动释放所有该进程加过的文件锁
Q:为什么加了写锁还能gedit或vim写???
A:可以写, 锁只可以控制能否加锁成功, 不能控制对文件的读写, 所以叫”建议”锁, 我加了锁就是不想让你写, 你非要写我也没办法. vim/gedit不通过能否加锁成功来决定是否读写, 所以可以直接上
Q: So如何实现文件锁控制文件的读写操作????
A:可以在读操作前尝试加读锁, 写操作前尝试加写锁, 根据能否加锁成功决定能否进行读写操作
int fd=open("./a.txt",O_RDWR); //得到fd
if(-1==fd)
perror("open"),exit(-1);
struct flock lock={F_RDLCK,SEEK_SET,2,5,-1}; //设置锁 //此处从第3个byte开始(包含第三)锁5byte
int res=fcntl(fd,F_SETLK,&lock); //给fd加锁
if(-1==res)
perror("fcntl"),exit(-1);
ioct1()
这个函数可以实现其他文件操作函数所没有的功能，大多数情况下都用在设备驱动程序里，每个设备驱动程序可以定义自己专用的一组ioctl命令，系统则为不同种类的设备提供通用的ioctl命令
//操作特殊文件的设备参数，成功返回0,失败返回-1设errno #include int ioctl(int d, int request, ...); //d：an open file descriptor. //request： a device-dependent request code
close()
//关闭fd，这样这个fd就可以重新用于连接其他文件，成功返回0,失败返回-1设errno
#include
int close(int fd);
#include
#include
int res=close(fd);
if(-1==res)
perror("close"),exit(-1);
通过本文，我们了解了Linux文件I/O的基本原理和方法，它们可以满足我们对文件的各种操作需求。我们应该根据实际需求选择合适的方法，并遵循一些基本原则，如关闭不用的文件描述符，检查错误返回值，使用合适的缓冲区大小等。文件I/O是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!