Probelm with using Threads in Linux kernel Module - c

Question

I am developing Linux kernel module which is communicating with my user-space C application. In this module, I am creating a thread. this is my module where I am facing the problem :
#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");
/* we need to know the pid of the user space process
* -> we use debugfs for this. As soon as a pid is written to
* this file, a signal is sent to that pid
*/
/* only root can write to this file (no read) */
register_chrdev(240, "mod", &my_fops);
file = debugfs_create_file("signalconfpid", 0200, NULL, NULL, &my_fops);
f = filp_open(str, O_RDONLY , 0);
//printk("%d",f);
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");
When I execute my user-space program for the first time, everything is working well and it prints for me on the console :
Thread is created
thread name thread91
Thread is awake
But when I try to execute it again, it prints :
THREAD1 IS NOT NULL!!! CAN NOT CREATE THREAD!!!
I think that the probelm is in task_struct *thread1 which still holding information about the first thread which was created in my first execution of the program.
Could anyone help me how to solve the problem ? How can I edit my code in order to make it run much more times correctly ?
Thank you.

Answer 1

As you mentionned, the thread is correctly marked as not null since it is already running. So the behaviour is intended.
So in order to solve your issue you have to describe what is you actual intended behavior.
If you want to make it run multiple times, you might want to use a local variable to run the thread (for instance storing it in an array for later communication).
You could also wait the previous thread to complete before running the next one.

Answer 2

Your kernel code lives before and after your user space code started and finished to run. So when you execute your command for the first time, the kernel thread is created, as it is the first time the read_pid called so the thread is created. But after the read_pid done, the kernel did not stop. So the thread is still there. It looks like you should create your thread in the driver's probe function, and write the threads logic in the way that it only prepares data for the read_pid call. The signal usage looks absolutely unnecessary in your case.