How to make communication between user space program and Linux kernel module in order to print a message sent from user program to the kernel

Question

I have developed a simple linux kernel module which I will send to it a char message from user space program.

This is the module :

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/device.h>  
#include <linux/kernel.h>


MODULE_LICENSE("GPL");      
MODULE_AUTHOR("Gaston");  
MODULE_DESCRIPTION("A simple Linux char driver"); 
MODULE_VERSION("0.1"); 


static char message[256] = {0};

ssize_t exer_open(struct inode *pinode, struct file *pfile) {

    printk(KERN_INFO "Device has been opened\n");
    return 0;
}



ssize_t exer_read(struct file *pfile, char __user *buffer, size_t length, loff_t *offset) {

    return 0;
}


ssize_t exer_write(struct file *pfile, const char __user *buffer, size_t length, loff_t *offset) {

    printk(KERN_INFO "Received %s characters from the user\n", message);
    return 0;

}


ssize_t exer_close(struct inode *pinode, struct file *pfile) {

    printk(KERN_INFO "Device successfully closed\n");
    return 0;
}


struct file_operations exer_file_operations = { 
    .owner = THIS_MODULE,
    .open = exer_open,
    .read = exer_read,
    .write = exer_write,
    .release = exer_close,
};


int exer_simple_module_init(void) {

    printk(KERN_INFO "Initializing the LKM\n");
    register_chrdev(240, "Simple Char Drv", &exer_file_operations);
    return 0;
}



void exer_simple_module_exit(void) {

    unregister_chrdev(240, "Simple Char Drv");
}

module_init(exer_simple_module_init);
module_exit(exer_simple_module_exit);

And this my C program :

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<fcntl.h>
#include<string.h>
#include<unistd.h>


#define BUFFER_LENGTH 256 

int main()

{

int ret, fd;
char stringToSend[BUFFER_LENGTH];


fd = open("/dev/char_device", O_RDWR);             // Open the device with read/write access

if (fd < 0)
    {
            perror("Failed to open the device...");
            return errno;
    }


printf("Type in a short string to send to the kernel module:\n");

scanf("%s", stringToSend);                // Read in a string (with spaces)

printf("Writing message to the device [%s].\n", stringToSend);

ret = write(fd, stringToSend, strlen(stringToSend)); // Send the string to the LKM

if (ret < 0)
    {
            perror("Failed to write the message to the device.");
            return errno;
    }

return 0;

}

After inserting the module with insmod , and when I execute the program and examin the kernel logs using tail -f /var/log/messages command I can see :

Oct  1 13:57:37 auth.info login[306]: root login on 'ttyS0'
Oct  1 13:58:22 user warn kernel: exer_simple_char_drv: loading out-of-tree module taints kernel.
Oct  1 13:58:22 user.info kernel: Initializing the LKM
Oct  1 13:58:35 user.info kernel: Device has been opened
Oct  1 13:58:39 user.info kernel: Received  characters from the user
Oct  1 13:58:39 user.info kernel: Device successfully closed

Same thing when I run dmesg :

exer_simple_char_drv: loading out-of-tree module taints kernel.
Initializing the LKM
Device has been opened
Received  characters from the user
Device successfully closed

The problem is That I am not able to see the message that I entred manually when I executed my C program. What I am missing here please ?

`stringToSend, strlen(stringToSend));` - message will __not__ be zero terminated. Don't use `%s` to print it. You could use `%.*s`. — KamilCuk, Oct 23 '19 at 14:09

Mathieu · Accepted Answer · 2019-10-23T14:50:55.907

1

First problem: you never modify message.

Then, you cannot use directly the user memory in the kernel context

You have to translate it before: copy_from_user is for that.

Your write function could looks like

#define MAX 256
/* here, message is defined as 256 bytes +1 one.
   The extra char is here to be compatible with the `%s` formatter */
static char message[MAX+1] ="";

ssize_t exer_write(struct file *pfile, const char __user *buffer, size_t length, loff_t *offset) {
    if (length > MAX)
        return -EINVAL;

    if (copy_from_user(message, buffer, length) != 0)
        return -EFAULT;

    printk(KERN_INFO "Received %s characters from the user\n", message);
    return 0;

}

edited Oct 23 '19 at 14:50

answered Oct 23 '19 at 14:00

Mathieu

8,840
7
32
45

Thank you for your interraction. I will modify my module and give a try again. But I did not understand you when you told " never modify message " – gaston Oct 23 '19 at 14:08
2

@gaston: In your code, you display `message` (in `exer_write` function), but you never try to change its value. – Mathieu Oct 23 '19 at 14:12
2

The `%s` requires a null-terminated string. – Ian Abbott Oct 23 '19 at 14:45

How to make communication between user space program and Linux kernel module in order to print a message sent from user program to the kernel

1 Answers1