Linux device driver not behaving as expected - c

Question

I am trying to write a simple device driver. The driver has only read/write operations. Ideally, I would like the read() function to work in such a way that when the device file is read from, a message is printed to terminal along with a count of how many times the device file was read from. The driver contains the following libraries and global variables:
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <linux/poll.h>
#include <linux/cdev.h>
#include "my_driver.h"
#define DEVICE_NAME "Edev"
#define SUCCESS 0
#define FAILURE -1
#define BUF_LEN 1024
static struct class * cls;
static int major_num;
static int counter=0;
static char message_buffer[BUF_LEN];
static char * message_pointer;
static char * write_pointer;
static struct file_operations elliott_fops = {
.read=device_read,
.write=device_write,
.owner=THIS_MODULE
};
The read function is written like so:
static ssize_t device_read(struct file * filp2, char *buffer2, size_t length2, loff_t *offset2){
ssize_t bytes_in_message=0;
sprintf(message_buffer,"Yes,you read from the driver this many times: %d",counter++);
message_pointer=message_buffer;
while (length2 && *message_pointer++){
put_user(*(message_pointer++),buffer2++);
bytes_in_message++;
length2--;
}
pr_info("Read %lu bytes with %lu bytes remaining in the buffer",bytes_in_message,length2);
return bytes_in_message;
}
What I would like the read() function to do is print the message out to the terminal using the sprint() call, and then the while loop will obtain the message's byte length. The message byte length information as well as the remaining buffer size will then be logged within the kernel
The write function is written like this:
static ssize_t device_write(struct file * filp, const char *buffer, size_t length, loff_t *offset){
ssize_t bytes_read_in=0;
while (length && *buffer++){
get_user(*(write_pointer++),buffer++);
bytes_read_in++;
}
pr_info("The device had %lu bytes written to it",bytes_read_in);
pr_info("Got message from user: %s",write_pointer);
return bytes_read_in;
}
Ideally, if someone performed a write to the device with a "echo "hello linux kernel" > /dev/Edev" command, the message that was written to the device file would be printed in the kernel, as well as how long the message was. However, the read() and write() functions are not behaving like this at all. If, for instance, I load the module and write to the device file, no message have been logged in the kernel. If I then performed a cat /dev/Edev command, what is printed to terminal output is not the message with the count, but rather what was just written to the device with echo.
I am assuming this may have something to do with buffers overwriting each other, but I am confused as the buffer in write is userspace, while the buffer in read is in kernel space. I also am unsure why no messages are being logged to the kernel.

Answer 1

to copy a block of data into userspace for ref (https://www.cs.bham.ac.uk/~exr/teaching/lectures/opsys/13_14/docs/kernelAPI/r4037.html)
use copy_to_user function.

Answer 2

There is too much use of the post-increment operator in the loop in device_read():
while (length2 && *message_pointer++){
put_user(*(message_pointer++),buffer2++);
bytes_in_message++;
length2--;
}
message_pointer has been incremented twice per iteration. Similarly, in device_write():
while (length && *buffer++){
get_user(*(write_pointer++),buffer++);
bytes_read_in++;
}
buffer has been incremented twice per iteration. Also the length variable is not being decremented and the write_pointer variable has not been set.
The modified loops can be as follows. In device_read():
while (length2 && *message_pointer){
put_user(*message_pointer, buffer2);
message_pointer++;
buffer2++;
bytes_in_message++;
length2--;
}
And in device_write():
while (length && *buffer){
get_user(*write_pointer,buffer);
write_pointer++;
buffer++;
bytes_read_in++;
length--;
}
The write_pointer variable still needs to be set to point to a valid buffer in device_write().
[EDIT: Removed paragraph about put_user() and get_user() evaluating their arguments more than once, as I do not think that is the case.]