IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

Réécriture d'un VFS Linux


Sujet :

C

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre confirmé
    Profil pro
    Inscrit en
    Novembre 2005
    Messages
    156
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2005
    Messages : 156
    Par défaut Réécriture d'un VFS Linux
    Bonjour,

    J'ai un système de fichiers virtuel stocké dans une base de données et j'aimerai pouvoir le monter en tant que filesystem Linux. J'ai regardé quelques tutoriels et j'ai trouvé comment développer les bases de son propre VFS sous Linux. J'ai à peu près réussi à me débrouiller pour adapter les tutos que j'ai trouvé au kernel 3.16 (http://kukuruku.co/hub/nix/writing-a...n-linux-kernel et https://github.com/psankar/simplefs). J'ai donc pu écrire un module qui gère un filesystem qui affiche "ls called" dans le log quand je tape ls. Sauf que maintenant j'aimerai bien qu'il affiche des données et là j'ai un peu plus de mal.

    Toutes les implémentations que j'ai trouvé travaillent avec des structures qui représentent inodes, des superblocs et des trucs comme ça. Je me suis dit que je pouvais m'en passer (puisque je ne stocke pas mes données sur le disque mais dans une base) mais je ne vois pas trop comment renvoyer mes données.

    L'exemple que j'ai trouvé fait ça:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
     
    /********************* implementation of iterate ******************************/
     
    /*
     * routine called when the VFS needs to read the directory contents
     *
     * @file: the VFS file structure of the directory
     * @ctx: directory context
     *
     * return: 0 on success, error code otherwise
     */
    static int wtfs_iterate(struct file * file, struct dir_context * ctx)
    {
    	struct inode * dir_vi = file_inode(file);
    	struct super_block * vsb = dir_vi->i_sb;
    	struct wtfs_inode_info * info = WTFS_INODE_INFO(dir_vi);
    	struct wtfs_dir_block * block = NULL;
    	struct buffer_head * bh = NULL;
    	uint64_t count, offset, next, inode_no;
    	char * filename = NULL;
    	int i, j, k;
    	int ret = -EINVAL;
     
    	/* calculate how many entries we have counted, including null entries */
    	count = ctx->pos / sizeof(struct wtfs_dentry);
    	offset = ctx->pos % sizeof(struct wtfs_dentry);
    	if (offset != 0) {
    		wtfs_error("bad position %llu at %s:%lu\n", ctx->pos,
    			dir_vi->i_sb->s_id, dir_vi->i_ino);
    		goto error;
    	}
     
    	/* do iterate */
    	next = info->first_block;
    	i = 0; /* valid entry counter */
    	j = 0; /* total entry counter, including null ones */
    	while (next != 0) {
    		if ((bh = sb_bread(vsb, next)) == NULL) {
    			wtfs_error("unable to read the block %llu\n", next);
    			goto error;
    		}
    		block = (struct wtfs_dir_block *)bh->b_data;
    		for (k = 0; k < WTFS_DENTRY_COUNT_PER_BLOCK; ++k) {
    			inode_no = wtfs64_to_cpu(block->entries[k].inode_no);
    			filename = block->entries[k].filename;
    			if (inode_no != 0) {
    				if (j >= count && i < info->dir_entry_count) {
    					wtfs_debug("emitting entry '%s' of "
    						"inode %llu\n",
    						filename, inode_no);
     
    					if (dir_emit(ctx, filename,
    						strnlen(filename,
    							WTFS_FILENAME_MAX),
    						inode_no, DT_UNKNOWN) == 0) {
    						brelse(bh);
    						return 0;
    					}
    				}
    				++i;
    			}
    			++j;
    			ctx->pos += sizeof(struct wtfs_dentry);
    		}
    		next = wtfs64_to_cpu(block->next);
    		brelse(bh);
    	}
    	return 0;
     
    error:
    	if (bh != NULL) {
    		brelse(bh);
    	}
    	return ret;
    }
    Mais j'ai l'impression que la partie qui renvoie le contenu du répertoire c'est juste ça

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    dir_emit(ctx, filename, strnlen(filename, WTFS_FILENAME_MAX), inode_no, DT_UNKNOWN)
    Mon gros problème (enfin en dehors du fait que je n'ai plus fait de C depuis 10 ans) c'est que je ne sais pas ce que fait cette fonction dir_emit() et que je ne trouve pas de doc.

    Est ce que quelqu'un qui à un peu l'habitude du développement des VFS sous Linux pourrait m'aiguiller un peu et m'indiquer ou je peux trouver la doc de ces fonctions?

    Merci.

  2. #2
    Expert éminent

    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2007
    Messages
    5 202
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2007
    Messages : 5 202
    Par défaut
    J'ai l'impression que tu fais fausse route en voulant te passer de la structure inode.

    Je n'ai jamais travaillé dans un VFS, mais j'imagine qu'ils doivent être manipulés comme tout file system par le système.
    Du coup, quelle est l'interface requise pour qu'un VFS servent à quelque chose?

  3. #3
    Membre confirmé
    Profil pro
    Inscrit en
    Novembre 2005
    Messages
    156
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2005
    Messages : 156
    Par défaut
    C'est possible que je fasse fausse route. Mais je pars du principe que quand on monte une partition en FAT on n'a pas d'inode. Donc à moins que le driver fasse une conversion à la volée, ce n'est peut-être pas indispensable. (?)

  4. #4
    Responsable Systèmes


    Homme Profil pro
    Gestion de parcs informatique
    Inscrit en
    Août 2011
    Messages
    18 256
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Gestion de parcs informatique
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Août 2011
    Messages : 18 256
    Par défaut
    Linux VFS s'adapte au modèle de fichier natif Linux6, mettons ext2 pour fixer les idées. Les abstractions fondamentales de Linux VFS sont donc :

    soit inspirées de la structure du système ext2, comme par exemple les objets superblock et inode ;
    soit calquées sur les objets qui permettent à Linux de manipuler le système ext2, avec les objets dentry et file.

    Cela permet à Linux de faire fonctionner ses systèmes de fichiers natifs avec le minimum de médiation.
    Wikipedia.

    Pour une 1-re approche : https://fr.wikipedia.org/wiki/Virtual_File_System
    J'ai aussi retrouvé le pdf ci-joint dans mes données.
    Images attachées Images attachées
    • Type de fichier : pdf vfs.pdf (273,2 Ko, 416 affichages)
    Ma page sur developpez.com : http://chrtophe.developpez.com/ (avec mes articles)
    Mon article sur le P2V, mon article sur le cloud
    Consultez nos FAQ : Windows, Linux, Virtualisation

  5. #5
    Membre très actif
    Avatar de sambia39
    Homme Profil pro
    No Comment
    Inscrit en
    Mai 2010
    Messages
    548
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Loiret (Centre)

    Informations professionnelles :
    Activité : No Comment
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Mai 2010
    Messages : 548
    Par défaut
    Bonsoir,
    Je vais essayer d’apporter quelques éléments.

    Pour faire simple VFS est une couche logicielle (module) insérée dans le noyau Linux pour faciliter l’accès à de différents systèmes de fichiers de façon uniforme et transparente. En clair elle permettre au noyau Linux de supporter d’autres types de systèmes de gestion de fichiers en plus du sien exemple :NTFS, HFS+, HPFS, FAT12, FAT32, etc.. C’est donc un modèle commun capable de support tous les systèmes de gestion de fichiers pris en charge ou compatible Linux et donc pour chaque système de fichiers, il faut traduire l’organisation physique de celui-ci dans le modèle VFS afin de faciliter les accès et la manipulation. Donc, vous ne pouvez pas vous passer des noeuds d’informations, et ce pour les raisons suivantes: les noeud d’informations (inode) ont pour rôle, d’enregistrer toutes les informations correspondant à un fichier (les informations sur la nature du fichier et ses droits d’accès, etc.. ) et chaque fichier dans VFS est décrit comme un noeud d’informations . (VFS effectue pas mal d’opérations vérifications de paramètre, des permissions, effectue des conversions de non de fichier en numéro de périphérique et numéro inodes, effectue des appels aux fonctions spécifiques au (ou) à votre système de gestion de fichier concerné. Sans oublier la gestion des caches.)


    Citation Envoyé par neuromencien Voir le message
    C'est possible que je fasse fausse route. Mais je pars du principe que quand on monte une partition en FAT on n'a pas d'inode. Donc à moins que le driver fasse une conversion à la volée, ce n'est peut-être pas indispensable. (?)
    C’est parce qu'il traduit ou transforme son organisation interne "physique" (Allocation par liste chaînée indexée) en Model VFS afin que le système est accès.


    Citation Envoyé par neuromencien Voir le message
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    dir_emit(ctx, filename, strnlen(filename, WTFS_FILENAME_MAX), inode_no, DT_UNKNOWN)
    ......
    Mon gros problème (enfin en dehors du fait que je n'ai plus fait de C depuis 10 ans) c'est que je ne sais pas ce que fait cette fonction dir_emit() et que je ne trouve pas de doc.
    À quoi correspond static inline bool dir_emit(struct dir_context *ctx, const char *name, int namelen, u64 ino, unsigned type) ?. C’est une fonction qui permet de mettre à jour les données d’entrée inode (dirent, etc. ). Pour faire simple elle est utilisée par readdir() ou encore ceph_readdir etc. et permet au noyau de spécifier quelle est la bonne configuration que la structure "dirent" doit avoir. (si je ne me trompe pas) cela permet également au noyau de connaître les répertoires/fichiers qui se trouvent dans l'espace kernel. Elle est également utilisée pour connaître les différentes informations de dirent en fonction des fichiers qui s’y trouve.

    à bientôt

  6. #6
    Membre confirmé
    Profil pro
    Inscrit en
    Novembre 2005
    Messages
    156
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2005
    Messages : 156
    Par défaut
    Merci à vous 2 pour vos réponses.

    @chrtophe, j'ai parcouru le pdf rapidement (pour le moment) et il semble expliquer plus de choses que les articles que j'ai lu jusque là qui eux se basaient sur beaucoup de prérequis. Je le lirais attentivement ce soir.

    @sambia39, merci pour la réponse sur la fonction. Est-ce qu'il y a une doc de référence quelque par qui explique à quoi servent ces fonction proches du système? Je n'ai pas réussi à en trouver pour le moment. Ça m'intéresse plus pour ma culture personnelle (et peut-être des futurs projets) car on m'a parlé ce matin de FUSE qui semble répondre tout à fait à mes besoins et semble surtout beaucoup plus accessible pour quelqu'un qui n'a jamais fais de programmation kernel.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. [Article] Introduction à VFS sous Linux 2.6.30
    Par Zenol dans le forum Linux
    Réponses: 2
    Dernier message: 06/12/2015, 04h59
  2. Débat : quelle distribution Linux choisir pour débuter ?
    Par Anonymous dans le forum Distributions
    Réponses: 227
    Dernier message: 18/02/2015, 10h09
  3. Confusion arborescence linux et VFS
    Par Algernon2 dans le forum Linux
    Réponses: 1
    Dernier message: 25/10/2013, 21h44
  4. Je ne peux établir une connexion cliente sous Linux.
    Par Anonymous dans le forum CORBA
    Réponses: 5
    Dernier message: 16/04/2002, 15h57

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo