sys v shared memory von kernel module zu user space process

Question

ich bin neu in linux kernel modul developement und ich bin auf der Suche nach der Freigabe eines Speichersegments von Kernel-Modul zu User-Space-Prozess zu entkommen Latenz des Kopierens von Daten.

Ich verwende die sys v shared memory API, wenn ich Speicher zwischen zwei Prozess teilen ist es funktioniert gut, aber ich bin nicht in der Lage, Speicher zwischen Prozess und Kernel-Modul zu teilen.

unten ist mein Code des Kernel-Moduls und dem User-Space App

Server-Seite: Modul

#include <linux/module.h> // init_module, cleanup_module // 
#include <linux/kernel.h> // KERN_INFO // 
#include <linux/types.h> // uint64_t // 
#include <linux/kthread.h> // kthread_run, kthread_stop // 
#include <linux/delay.h> // msleep_interruptible // 
#include <linux/syscalls.h> // sys_shmget // 

#define BUFSIZE 100 
#define SHMSZ BUFSIZE*sizeof(char) 
key_t KEY = 5678; 

static struct task_struct *shm_task = NULL; 


static char *shm = NULL; 
static int shmid; 

static int run_thread(void *data) 
{ 
    char strAux[BUFSIZE]; 
    shmid = sys_shmget(KEY, SHMSZ, IPC_CREAT | 0666); 
    if(shmid < 0) 
    { 
     printk(KERN_INFO "SERVER : Unable to obtain shmid\n"); 
     return -1; 
    } 
    shm = sys_shmat(shmid, NULL, 0); 
    if(!shm) 
    { 
     printk(KERN_INFO "SERVER : Unable to attach to memory\n"); 
     return -1; 
    } 
    strncpy(strAux, "hello world from kernel module", BUFSIZE); 
    memcpy(shm, strAux, BUFSIZE); 
    return 0; 
} 

int init_module() 
{ 
    printk(KERN_INFO "SERVER : Initializing shm_server\n"); 
    shm_task = kthread_run(run_thread, NULL, "shm_server"); 
    return 0; 
} 

void cleanup_module() 
{ 
    int result; 
    printk(KERN_INFO "SERVER : Cleaning up shm_server\n"); 
    result = kthread_stop(shm_task); 
    if(result < 0) 
    { 
     printk(KERN_INFO "SERVER : Unable to stop shm_task\n"); 
    } 
    result = sys_shmctl(shmid, IPC_RMID, NULL); 
    if(result < 0) 
    { 
     printk(KERN_INFO 
     "SERVER : Unable to remove shared memory from system\n"); 
    } 

} 


MODULE_LICENSE("GPL"); 
MODULE_AUTHOR(" MBA"); 
MODULE_DESCRIPTION("Shared memory server"); 

Client-Seite: Prozess

#include <sys/ipc.h> // IPC_CREAT, ftok // 
#include <sys/shm.h> // shmget, ... // 
#include <sys/sem.h> // semget, semop // 
#include <stdio.h> // printf // 
#include <string.h> // strcpy // 
#include <stdint.h> // uint64_t // 

#define BUFSIZE 4096 
key_t KEY = 5678; 

int main(int argc, char *argv[]) { 
    int shmid, result; 
    char *shm = NULL; 

    shmid = shmget(KEY, BUFSIZE, 0666); 
    if (shmid == -1) { 
     perror("shmget"); 
     exit(-1); 
    } 
    shm = shmat(shmid, NULL, 0); 
    if (!shm) { 
     perror("shmat"); 
     exit(-1); 
    } 

    printf("%s\n", shm); 
    result = shmdt(shm); 
    if (result < 0) { 
     perror("shmdt"); 
     exit(-1); 
    } 
} 

jede Anregung oder Dokument helfen können.

Answer 1

Systemaufrufe sind nicht für die Verwendung durch den Kernel gedacht: Sie sind nur für Benutzerprogramme gedacht. Außerdem ist es unwahrscheinlich, dass die sys v-Speicherfreigabe für Kernel-Threads funktioniert.

Kernel und Kernel-Module haben ihren eigenen Mechanismus für Interact mit Benutzer Raum. Für die gemeinsame Nutzung von Arbeitsspeicher kann Ihr Kernel-Modul das Zeichengerät und die Methode mmap implementieren, die den dem Kernel zugewiesenen Speicher dem Benutzer zuordnet. Siehe Beispiel einer solchen mmap Implementierung in Linux-Gerätetreiber (3d Edition), Kapitel 15.