我的 Linux 内核模块没有收到正确的用户空间应用程序 PID

Question

我正在开发与我的用户空间 C 应用程序通信的 Linux 内核模块。在这个模块中，我正在创建一个线程。另外，我需要知道用户空间进程的pid，所以我使用了pid_task(find_vpid(pid), PIDTYPE_PID)函数。

这是我面临问题的模块：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <asm/siginfo.h>    //siginfo
#include <linux/rcupdate.h>    //rcu_read_lock
#include <linux/sched/signal.h>    //find_task_by_pid_type
#include <linux/debugfs.h>
#include <linux/uaccess.h>
#include<linux/slab.h>
#include <linux/input.h>
#include <linux/device.h>
#include <linux/fs.h> 
#include <linux/random.h> 
#include <linux/kthread.h> 

#define SIG_TEST 44    // we choose 44 as our signal number (real-time signals are in the range of 33 to 64)
#define BTN_FILE_PATH "/dev/input/event0"


char *str = BTN_FILE_PATH;
int file;

struct file *f;   // keyboard driver

// prototypage des fonctions read_in_thread & read_pid
int read_in_thread(void *data);
static ssize_t read_pid(struct file *pfile, char __user *buffer, size_t length, loff_t *offset);


static ssize_t write_pid(struct file *pfile, const char __user *buffer,
                                size_t length, loff_t *offset)
{
   return 0;
}



struct read_args {
    struct file *pfile;
    const char __user *buffer;
    size_t length;
    loff_t *offset;
};


static ssize_t read_pid(struct file *pfile, char __user *buffer, size_t length, loff_t *offset)
{
  // création de la structure des arguments
    struct read_args args ;
    args.pfile = pfile;
    args.buffer = buffer;
    args.length = length;
    args.offset = offset;

struct task_struct *thread1;
char our_thread[20];
unsigned int rand;

get_random_bytes(&rand, sizeof(rand));
rand = rand % 250;
sprintf(our_thread, "thread%u", rand);

if(thread1==NULL)
{
thread1 = kthread_create(read_in_thread,&args,our_thread);
    if((thread1))
        {
            printk(KERN_INFO "Thread is created\n");
        printk("thread name %s\n", our_thread);
// lancement du thread
            wake_up_process(thread1);
        printk(KERN_INFO "Thread is awake\n");
        }
}

else 
printk("\nTHREAD1 IS NOT NULL!!! CAN NOT CREATE THREAD!!!\n"); 

return 0;                   
}



int read_in_thread(void *data) {

/************************** récupération des arguments *******************/

    struct read_args *const args = data;

/***************************   corps de la fonction ***********************/


// init des variables 

    char mybuf[10];
    enum { MAX_BUF_SIZE = 4096 };
    size_t buf_size = 0;
    char *buf = NULL;
    ssize_t total = 0;
    ssize_t rc = 0;
    struct task_struct *t;
    struct input_event ev[64];
    int yalv;

    int ret;
    struct siginfo info;
    int pid =0; 
    size_t amount = sizeof(ev);    


// récupération de l'ID du processus appelant

/* read the value from user space */
    if(args->length > 10)
        return -EINVAL;
    copy_from_user(mybuf, args->buffer, args->length);
    sscanf(mybuf, "%d", &pid);
    printk("pid = %d\n", pid);

    // the signal 
    memset(&info, 0, sizeof(struct siginfo));
    info.si_signo = SIG_TEST;
    info.si_code = SI_QUEUE;    // this is bit of a trickery: SI_QUEUE is normally used by sigqueue from user space,
                    // and kernel space should use SI_KERNEL. But if SI_KERNEL is used the real_time data 
                    // is not delivered to the user space signal handler function. 
    info.si_int = 260;          //real time signals may have 32 bits of data.

    rcu_read_lock();
    t = pid_task(find_vpid(pid), PIDTYPE_PID);  //find the task_struct associated with this pid
    if(t == NULL){
        printk("no such pid\n");
        rcu_read_unlock();
        return -ENODEV;
    }
    rcu_read_unlock();


// lecture blocquante

    rc = kernel_read(f, ev, amount, &f->f_pos);

// récupération de l'événement

    if (rc > 0) {
            for (yalv = 0; yalv < (int) (rc / sizeof(struct input_event)); yalv++) {
            if (ev[yalv].type == EV_KEY) {
                if (ev[yalv].value == 0)
                     //eval_keycode(ev[yalv].code);
                     info.si_int = ev[yalv].code;  

// envoie du signal vers le processus appelant avec les événements lu

                                         ret = send_sig_info(SIG_TEST, &info, t);    //send the signal
                         printk("signal was send\n");
                     if (ret < 0) {
                            printk("error sending signal\n");
                        kfree(buf);
                            return ret;
                         }              
            }
        }

                if (rc < amount) {
                    /* Didn't read the full amount, so terminate early. */
                    rc = 0;
                }

    } 

    /* Free temporary buffer. */
        kfree(buf);

return 0;
}


static const struct file_operations my_fops = {
    .owner = THIS_MODULE,
    .write = write_pid,
    .read = read_pid,
    //.open = open_pid,
};



static int __init signalexample_module_init(void)
{
    printk(KERN_INFO "Initializing LKM");
    register_chrdev(240, "mod", &my_fops);
    file = debugfs_create_file("signalconfpid", 0200, NULL, NULL, &my_fops);
    f = filp_open(str, O_RDONLY , 0);

    return 0;
}



static void __exit signalexample_module_exit(void)
{
    unregister_chrdev(240, "mod");
    debugfs_remove(file);

}

module_init(signalexample_module_init);
module_exit(signalexample_module_exit);
MODULE_LICENSE("GPL");

当我在插入这个模块后运行我的用户空间程序时，它似乎第一次没有问题地工作：它在控制台上打印：

Thread is created 
thread name thread91
Thread is awake
pid = 323

但是在我退出之后，当我再次尝试重新执行我的用户空间代码时，它会向我显示：

pid = 0 
No such pid

我想知道为什么当我多次执行我的应用程序时它没有以正确的方式工作？这里有什么问题？我需要一些帮助。谢谢。

Answer 1

由于您使用 PID 的唯一行是

    int pid =0;
    copy_from_user(mybuf, args->buffer, args->length);
    sscanf(mybuf, "%d", &pid);
    printk("pid = %d\n", pid);

mybuf 很可能在第二次执行时无效（mybuf 实际上包含 0 或者它为 null 或不可解析为 int），因此您会收到错误。您应该打印它以检查其值。错误可能是用户端的

注意：请不要将其视为个人，但这是您两天内的第三个线程，与主题相比，这是一个简单的问题（内核编程并不简单，即使对于 LKM 也是如此）。我认为您应该在询问之前进一步挖掘。我很确定您可以单独回答您的问题，否则您将在内核空间中开发时遇到麻烦。为了简化此调试过程，您可以使用内核调试器see this post for setup example（正如 Marco Bonelly 所指出的，仅当您计划在内核空间中进行大量开发时才值得使用内核调试器，因为它的部署可能需要一些时间）。祝你好运。

Answer 2

对于任何正在寻找解决此问题的方法的人，经过一些研究我发现使用copy_from_user函数必须在线程函数之外使用。所以，我将它移到我的代码中的 read_pid 函数中，并声明了它用作全局变量的变量，我现在通常能够接收到我的用户空间应用程序的正确 PID。