un exemple de copy_from_user() ? noyau et l'espace utilisateur

Je suis à la recherche de la copie PID valeur à partir de l'espace Utilisateur espace Noyau vers l'espace, voici mon code s'enclenche.

Module De Noyau:

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <asm/siginfo.h>
#include <linux/rcupdate.h>
#include <linux/sched.h>
#include <linux/uaccess.h>
#include <linux/signal.h>
MODULE_LICENSE ("GPL");

struct siginfo sinfo;
pid_t pid;
struct task_struct *task;
int init_module () {
memset(&sinfo, 0, sizeof(struct siginfo));
sinfo.si_signo = SIGIO;
sinfo.si_code = SI_USER;
pid = 5218; //Everytime a new PID 
//task = find_task_by_vpid(pid); //I am also working on new and old version of UBUNTU so thats why this is here
task = pid_task(find_vpid(pid), PIDTYPE_PID); 
printk("%d .\n", task);
if(task == NULL) {
printk("Cannot find PID from user program\r\n");
return 0;
}
send_sig_info(SIGIO, &sinfo, task);
return 0;
}
void cleanup_module () {
printk(KERN_ALERT"\nGoodBye World\n\n");
}

De L'Espace Utilisateur Code:

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
void signal_handler (int signum){
if (signum == SIGIO) printf ("SIGIO\r\n"); return;
}
int main () {
int i=1 ;
signal(SIGIO, signal_handler);
printf("My PID is %d.\n",getpid());
while (i);
return 0;
}

Maintenant, ici, je suis toujours en cours d'exécution de l'utilisateur de l'espace pour obtenir PID et puis j'ai toujours l'avoir à modifier le pid variable dans le module du Noyau.

J'ai trouvé un moyen d'accéder aux informations à partir de l'espace utilisateur vers l'espace Noyau et vice-versa (c'est à dire, à l'aide de copy_from/to_user() )

Mais je suis incapable de comprendre l'un ou l'autre pour obtenir un PID à partir de l'espace utilisateur, je dois faire un fichier dans /dev répertoire et doit s'appliquer à toutes les fonctions requises pour simplement aller PID?

Est-il un autre moyen? si non, alors quelqu'un peut-il m'aider à faire cela? Je suis nouveau dans la programmation en c et en jouant avec le module du noyau directement, il est donc difficile pour moi.

InformationsquelleAutor Raheel | 2012-05-22
  1. 3

    Regarder dans le code que vous avez donné, il semble que vous souhaitez gérer SIGIO signal

    Voici ma tentative de résoudre votre problème,

    signal_kernel.c fichier : 

    #include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <asm/siginfo.h>
#include <linux/rcupdate.h>
#include <linux/sched.h>
#include <linux/uaccess.h>
#include <linux/signal.h>
#include <linux/debugfs.h>
#include <linux/pid.h>

#define MAX 10

MODULE_LICENSE("GPL");

struct dentry *file;

static ssize_t write_conf_pid(struct file *file, const char *buf,
            size_t count, loff_t *position)
{
    char temp_str[MAX];
    int ret;
    int pid = 0;
    struct siginfo sinfo;
    struct task_struct *task;

    /* NEVER TRUST USER INPUT */
    if (count > MAX)
        return -EINVAL;

    if (copy_from_user(temp_str, buf, MAX) != 0)
        return -EFAULT;

    ret = sscanf(temp_str, "%d", &pid);
    if (ret != 1) {
        pr_info("Error in reading PID value from user");
        return -EINVAL;
    }

    pr_info("User entered pid %d\n", pid);
    memset(&sinfo, 0, sizeof(struct siginfo));
    sinfo.si_signo = SIGIO;
    sinfo.si_code = SI_USER;
    task = pid_task(find_vpid(pid), PIDTYPE_PID);
    if (task == NULL) {
        pr_info("Cannot find PID from user program\r\n");
        return -ENODEV;
    }
    ret = send_sig_info(SIGIO, &sinfo, task);
    if (ret < 0)
        pr_info("Error sending signal\n");
    return count;
}

static const struct file_operations my_fops = {
    .write = write_conf_pid,
};

int init_module()
{
    /* Only root can write to this file */
    file = debugfs_create_file("pidconf", 0200, NULL, NULL, &my_fops);
    return 0;
}

void cleanup_module()
{
    pr_info("\nGoodBye World\n\n");
}

    signal_user.c fichier :

    #include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>

void signal_handler(int signum)
{
    if (signum == SIGIO)
        printf("SIGIO\r\n");
    return;
}

int main()
{
    int i = 1;
    signal(SIGIO, signal_handler);
    printf("My PID is %d.\n", getpid());
    while (i);
    return 0;
}

    Après la compilation et l'exécution à la fois de l'espace utilisateur et l'espace noyau programme, utilisez debugfs interface pour envoyer des PID de la valeur à l'espace du Noyau, 

    $ insmod signal_kernel.ko
$ ./signal_user 
My PID is 17633.

... # Process will run in loop due to while(1)

    À partir d'un autre terminal, fournir des PID pour debugfs interface, 

    $ echo 17633 > /sys/kernel/debug/pidconf

    Il y a différentes façons (sysfs, misc_char_device, char device etc.) pour cette tâche, mais cela va vous donner une brève idée sur l'utilisation de copy_from_user() et copy_to_user()

    Veuillez noter qu'il y a une petite erreur de manipulation fait dans signal_user.c et signal_kernel.c.

    InformationsquelleAutor Abhijeet Kasurde