Lire / écrire des fichiers dans un module de noyau Linux

Je connais toutes les discussions sur les raisons pour lesquelles il ne faut pas lire / écrire des fichiers à partir du noyau, mais comment utiliser / proc ou netlink pour le faire. Je veux quand même lire / écrire. J'ai aussi lu Driving Me Nuts - Ce que vous ne devriez jamais faire dans le noyau .

Cependant, le problème est que 2.6.30 n'exporte pas sys_read(). C'est plutôt enveloppé SYSCALL_DEFINE3. Donc, si je l'utilise dans mon module, j'obtiens les avertissements suivants:

WARNING: "sys_read" [xxx.ko] undefined!
WARNING: "sys_open" [xxx.ko] undefined!

Impossible de insmodcharger le module car la liaison ne se fait pas correctement.

Des questions:

• Comment lire / écrire dans le noyau après 2.6.22 (où sys_read()/ sys_open()ne sont pas exportés)?
• En général, comment utiliser les appels système enveloppés dans une macro à SYSCALL_DEFINEn()partir du noyau?

Vous devez être conscient que vous devez éviter les E / S de fichiers depuis le noyau Linux lorsque cela est possible. L'idée principale est d'aller "d'un niveau plus profond" et d'appeler directement les fonctions de niveau VFS au lieu du gestionnaire d'appel système:

Comprend:

#include <linux/fs.h>
#include <asm/segment.h>
#include <asm/uaccess.h>
#include <linux/buffer_head.h>

Ouverture d'un fichier (similaire à ouvrir):

struct file *file_open(const char *path, int flags, int rights) 
{
    struct file *filp = NULL;
    mm_segment_t oldfs;
    int err = 0;

    oldfs = get_fs();
    set_fs(get_ds());
    filp = filp_open(path, flags, rights);
    set_fs(oldfs);
    if (IS_ERR(filp)) {
        err = PTR_ERR(filp);
        return NULL;
    }
    return filp;
}

Fermer un fichier (similaire à fermer):

void file_close(struct file *file) 
{
    filp_close(file, NULL);
}

Lecture des données d'un fichier (similaire à la lecture préalable):

int file_read(struct file *file, unsigned long long offset, unsigned char *data, unsigned int size) 
{
    mm_segment_t oldfs;
    int ret;

    oldfs = get_fs();
    set_fs(get_ds());

    ret = vfs_read(file, data, size, &offset);

    set_fs(oldfs);
    return ret;
}   

Ecrire des données dans un fichier (similaire à pwrite):

int file_write(struct file *file, unsigned long long offset, unsigned char *data, unsigned int size) 
{
    mm_segment_t oldfs;
    int ret;

    oldfs = get_fs();
    set_fs(get_ds());

    ret = vfs_write(file, data, size, &offset);

    set_fs(oldfs);
    return ret;
}

La synchronisation modifie un fichier (similaire à fsync):

int file_sync(struct file *file) 
{
    vfs_fsync(file, 0);
    return 0;
}

[Modifier] À l'origine, j'ai proposé d'utiliser file_fsync, qui a disparu dans les nouvelles versions du noyau. Merci au pauvre type qui a suggéré le changement, mais dont le changement a été rejeté. La modification a été rejetée avant que je puisse l'examiner.

Depuis la version 4.14 du noyau Linux, vfs_readet les vfs_writefonctions sont pas exportées plus pour une utilisation dans des modules. Au lieu de cela, des fonctions exclusivement pour l'accès aux fichiers du noyau sont fournies:

# Read the file from the kernel space.
ssize_t kernel_read(struct file *file, void *buf, size_t count, loff_t *pos);

# Write the file from the kernel space.
ssize_t kernel_write(struct file *file, const void *buf, size_t count,
            loff_t *pos);

De filp_openplus, n'accepte plus la chaîne d'espace utilisateur, elle peut donc être utilisée pour l'accès au noyau directement (sans danse avec set_fs).