Sous Linux, fuse fait référence au système de fichiers de l'espace utilisateur, qui est un module de noyau utilisé pour prendre en charge les systèmes de fichiers de l'espace utilisateur ; fuse est un cadre de système de fichiers implémenté dans l'espace utilisateur avec la prise en charge du module de noyau FUSE. les utilisateurs n'ont qu'à L'interface fournie par fuse peut implémenter un système de fichiers en implémentant des opérations de fichiers spécifiques.
L'environnement d'exploitation de ce tutoriel : système linux7.3, ordinateur Dell G3.
linux Qu'est-ce que fuse
Le module du noyau utilisé par Linux pour prendre en charge le système de fichiers de l'espace utilisateur est appelé FUSE. Le terme FUSE fait parfois référence spécifiquement au système de fichiers de l'espace utilisateur sous Linux.
est une partie importante d'un système d'exploitation général. Les systèmes d'exploitation assurent traditionnellement la prise en charge des systèmes de fichiers au niveau du noyau. Généralement, le code en mode noyau est difficile à déboguer et a une faible productivité.
Linux prend en charge l'implémentation de systèmes de fichiers dans l'espace utilisateur via le module FUSE à partir de la version 2.6.14.
La mise en œuvre de systèmes de fichiers dans l'espace utilisateur peut considérablement améliorer la productivité et simplifier la charge de travail liée à la fourniture de nouveaux systèmes de fichiers pour le système d'exploitation. Elle est particulièrement adaptée à divers systèmes de fichiers virtuels et systèmes de fichiers réseau. Les ZFS et glusterfs mentionnés ci-dessus sont tous deux des systèmes de fichiers réseau. Cependant, l'implémentation d'un système de fichiers en mode utilisateur introduira inévitablement une surcharge supplémentaire causée par le changement de mode noyau/mode utilisateur, ce qui aura un certain impact sur les performances.
Les principales fonctions de fuse : Surveiller les modifications dans un fichier ou un dossier et ajouter des informations personnalisées à ce que les autres processus écrivent ou lisent dans ce dossier ou ce fichier.
Résumé :
FUSE (système de fichiers en mode utilisateur) est un cadre de système de fichiers implémenté dans l'espace utilisateur Avec la prise en charge du module du noyau FUSE, les utilisateurs n'ont qu'à implémenter des opérations de fichiers spécifiques en fonction de l'interface fournie par fuse. Un système de fichiers.
FUSE se compose de trois parties, le module du noyau FUSE, la bibliothèque FUSE et quelques outils suspendus. Le module du noyau FUSE implémente l'amarrage avec VFS. Il ressemble à un module de système de fichiers ordinaire. De plus, le module du noyau FUSE implémente un périphérique qui peut être ouvert par un processus de l'espace utilisateur. Lorsque VFS envoie une demande d'opération de fichier, il le convertit. dans un format spécifique et transmettez-le au processus de l'espace utilisateur via le périphérique. Après avoir traité la demande, le processus de l'espace utilisateur renvoie le résultat au module du noyau FUSE. Le module du noyau le restaure ensuite au format requis par le noyau Linux et le renvoie. à VFS.
La bibliothèque FUSE est responsable de la communication avec l'espace noyau. Elle reçoit les requêtes de /dev/fuse, les convertit en une série d'appels de fonction et écrit les résultats dans /dev/fuse.
struct fuse_operations {
int (*getattr) (const char *, struct stat *, struct fuse_file_info *fi);
int (* readlink) (const char *, char *, size_t);
int (*mknod) (const char *, mode_t, dev_t);
int (*mkdir) (const char *, mode_t);
int (* unlink) (const char *);
int (*rmdir) (const char *); int (*symlink) (const char *, const char *); unsigned int);
int (*link) (const char *, const char *);
int (*chmod) (const char *, mode_t, struct fuse_file_info *fi);
int (* chown) (const char *, uid_t, gid_t, struct fuse_file_info *fi);
int (*truncate) (const char *, off_t, struct fuse_file_info *fi);
int (*open) (const char *, struct fuse_file_info *);
int (*read) (const char *, char *, size_t, off_t, struct fuse_file_info *);
int (*write) (const char *, const char *, size_t, off_t, struct fuse_file_info *);
int (*statfs) (const char *, struct statvfs *);
int (*flush) (const char *, struct fuse_file_info *);
int (*release) (const char *, struct fuse_file_info *);
int (*fsync) (const char *, int, struct fuse_file_info *);
int (*setxattr) (const char *, const char * , const char *, size_t, int);
int (*getxattr) (const char *, const char *, char *, size_t);
int (*listxattr) (const char *, char *, size_t);
int (*removexattr) (const char *, const char *);
int (*opendir) (const char *, struct fuse_file_info *);
int (*readdir) (const char *, void *, fuse_fill_dir_t , off_t,
struct fuse_file_info *, enum fuse_readdir_flags);
int (*releasedir) (const char *, struct fuse_file_info *);
int (*fsyncdir) (const char *, int, struct fuse_file_info *);
void (init) (struct fuse_conn_info *conn,struct fuse_config *cfg);
void (*destroy) (void *);
int (*access) (const char *,
int ( *create) (const char *, mode_t, struct fuse_file_info *);
int (*lock) (const char *, struct fuse_file_info *, int cmd,struct flock *);
int (*utimens) (const char * , const struct timespec tv[2], struct fuse_file_info *fi);
int (*bmap) (const char *, size_t blocksize, uint64_t *idx);
int (*ioctl) (const char *, int cmd, void *arg,
struct fuse_file_info *, unsigned int flags, void *data);
int (*poll) (const char *, struct fuse_file_info *,
struct fuse_pollhandle *ph, unsigned *reventsp);
int (*write_buf) (const char *, struct fuse_bufvec *buf, off_t off,struct fuse_file_info *);
int (*read_buf) (const char *, struct fuse_bufvec **bufp,
size_t size, off_t off, struct fuse_file_info *);
int (*flock) (const char *, struct fuse_file_info *, int op);
int (*fallocate) (const char *, int, off_t, off_t,struct fuse_file_info *);
};
1.安装：
（1）./configure --prefix=/usr
（2）make
（3）make install
2.加载驱动
加载fusible .ko模块« fusible modprobe »内核源码/fs/fuse
（2）fuse_dev_init(); Il y a un fusible_req, un fusible, un fusible, un fusible. init(); Il y a/sys/fs pour fuse_ctl_init(); 2. Fuse t;
（1）fuse_ctl_cleanup(); 注销fuse控制文件系统
（2）fuse_sysfs_cleanup(); 移除fuse、connections节点。
（3）fuse_fs_cleanup(); Il s'agit de fuse_inode.
（4）fuse_dev_cleanup(); Il n'y a pas de problème avec fuse_req.
3. fuse_conn
4. Le champ connecté de fuse_conn est utilisé pour indiquer l'état de la connexion. Il est 1 après un montage réussi, lorsque le système de fichiers est démonté, la connexion est interrompue ou le pilote de périphérique est libéré, le champ est 0. cette fois, la connexion (bloquée) Le système de fichiers chargé) ne peut pas fournir de services normaux. Ce champ sera vérifié dans fuse_request_send et la demande ne sera envoyée que lorsque le système de fichiers fuse normal sera connecté.
5. Chaque requête dans fuse est représentée par une structure fuse_req
6. Les paramètres d'entrée et de sortie de chaque fusible prennent en charge trois paramètres. Voir la définition des structures fuse_in et fuse_out
7. Une fois que le système de fichiers fuse a défini les paramètres d'entrée et de sortie de la requête, toutes les interfaces appelleront enfin fuse_request_send pour définir l'indicateur d'état de la structure fuse_req représentant cette requête sur FUSE_REQ_PENDING, ajouteront la requête à la liste chaînée en attente de fuse_conn, et call request_wait_answer Attendez que la demande soit terminée (une fois la file d'attente réveillée, vous devez vérifier si le statut de la demande est FUSE_REQ_FINISHED). Lorsque cette demande reçoit une réponse, le résultat a été stocké dans la variable locale outarg et fuse effectue le traitement correspondant pour renvoyer le résultat à la couche supérieure.
8. Chaque structure de requête fuse_req contient un champ waitq de wait_queue_head_t. Après que chaque requête soit émise, elle réveillera d'abord la file d'attente waitq de fuse_conn et indiquera au démon du mode utilisateur qu'une requête est arrivée, puis elle appellera wait_event_interruptible ; Dormez sur waitq de req et attendez que la condition FUSE_REQ_FINISHED devienne vraie.
9. Le pilote de périphérique Fuse est un simple pilote de périphérique en bloc, utilisé par Fuse pour échanger des données entre le mode utilisateur et le mode noyau. Fuse contient un démon d'espace utilisateur, qui s'exécute en boucle. Sa tâche principale est d'appeler read from fuse. Lisez la requête sur l'appareil. Lorsqu'il n'y a pas de requête, il se mettra en veille et attendra le waitq de fuse_conn (correspondant à la file d'attente waitq de fuse_conn qui se réveille après l'émission de la requête dans le paragraphe précédent). requête, il retire la première de la file d'attente en attente de fuse_conn. Une requête (correspondant à la liste liée en attente ajoutée à fuse_conn après l'émission de la requête dans le paragraphe précédent) et déplace la requête vers la file d'attente de traitement après le démon. lit les informations pertinentes de fuse_req dans l'état utilisateur, il appelle le rappel implémenté dans l'état utilisateur en fonction de la fonction de requête et écrit le résultat dans le pilote de périphérique fuse via fuse_dev_write. Une fois la requête en mode utilisateur terminée, recherchez le fuse_req correspondant. à partir de la file d'attente de traitement, copiez le résultat dans le paramètre out de fuse_req, définissez l'état de fuse_req sur FUSE_REQ_FINISHED, puis réveillez fuse_req Le waitq. À ce stade, fuse_req est traité et le système de fichiers fuse revient à la couche supérieure.
Recommandations associées : "Tutoriel vidé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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
