Write long to linux char device driver? - c

Question

I'm trying to write a character device driver in linux. Unfortunately it's not working for any numbers greater than 255.
I want this driver specifically to work with value of type long. Anytime I input a value greater than 255, the numbers wrong. 256 goes to 0 etc.
I've written a simple character device driver that shows the problem, there might be a lot of unused include statements as I copied my full driver and deleted almost everything:
chartest.c
#include <linux/init.h>
#include <linux/module.h> /* I mean this is a module after all! */
#include <linux/moduleparam.h>
#include <linux/kernel.h>
#include <linux/sched.h> /* For current task information */
#include <linux/fs.h> /* For file operations */
#include <linux/types.h> /* dev_t: device number data type */
#include <linux/cdev.h> /* cdev is the module data type that the kernel sees */
#include <asm/uaccess.h> /* For routines to copy data to/from user space */
#include <linux/uaccess.h>
#include <linux/slab.h> /* kmalloc/kfree */
MODULE_LICENSE("GPL");
#define DRIVER_NAME "chartest"
#define MAJOR_NUM 230
#define MINOR_NUM 0
struct cdev *cdev;
int test_device_open(struct inode *inode, struct file *fp) {
return 0;
}
int test_device_release(struct inode *inode, struct file *fp) {
return 0;
}
ssize_t test_read(struct file *fp, char __user *buffer, size_t count, loff_t *f_pos) {
return count;
}
ssize_t test_write(struct file *fp, const char __user *buffer, size_t count, loff_t *fpos) {
// We must validate the user's buffer and convert it to a long long
long userOperand;
unsigned char *userInput = NULL;
printk(KERN_NOTICE "Write Function Entered.\n");
printk(KERN_ALERT "Write count: %ld, Write fp: %lld\n", count, *fpos);
userInput = kmalloc(count, GFP_KERNEL);
get_user(*userInput, buffer);
printk(KERN_NOTICE "Value before cast: %ld\n", (long) *userInput);
userOperand = (long) *userInput;
printk(KERN_NOTICE "Value after cast: %ld\n", userOperand);
// Increment the file position pointer (in our case, always by 8)
*fpos += count;
kfree(userInput);
return count;
}
/*
* Declaration of function for open file operations
*/
static struct file_operations test_fops = {
.owner = THIS_MODULE,
.read = test_read,
.write = test_write,
.open = test_device_open,
.release = test_device_release,
};
// Initialization function
static int __init test_init(void)
{
// Register device number:
int err = 0;
dev_t device_number = MKDEV(MAJOR_NUM, MINOR_NUM);
err = register_chrdev_region(device_number, 1, DRIVER_NAME);
if (err < 0) {
printk(KERN_ALERT "Could not allocate device number.\n");
return err;
}
cdev = cdev_alloc();
cdev->owner = THIS_MODULE;
cdev->ops = &test_fops;
err = cdev_add(cdev, device_number, 1);
if (err) {
printk("Error allocating cdev.\n");
}
printk(KERN_ALERT "Test Initialized. Major Number: %d\n", MAJOR_NUM);
return 0;
}
// Exit function:
static void __exit test_exit(void)
{
dev_t device_number = MKDEV(MAJOR_NUM, MINOR_NUM);
// Remove char device */
cdev_del(cdev);
/* Unregister Device Number: */
unregister_chrdev_region(device_number, 1);
printk(KERN_ALERT "TestDriver %d destroyed.\n", MAJOR_NUM);
}
module_init(test_init);
module_exit(test_exit);
Small test program:
maintest.c:
#include <unistd.h>
#include <fcntl.h>
int main(void) {
long input = 256;
int fd = open("/dev/chartest0", O_RDWR);
write(fd, &input, sizeof(long));
close(fd);
return 0;
}
The printk statements gives the following output with the given input of 256:
Write Eunction Entered.
Write count: 8, Write fp: 0
Value before cast: 0
Value after cast: 0
This also fails with copy_from_user given an in put size of 8 bytes. It also fails when iterating through the buffer one byte at a time and copying the data. I've tried everything.
If you are graciously willing to help, compile with:
MakeFile
ifeq ($(KERNELRELEASE),)
# Assume the source tree is where the running kernel was built
# You should set KERNELDIR in the environment if it's elsewhere
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
# The current directory is passed to sub-makes as argument
PWD := $(shell pwd)
modules:
$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
modules_install:
$(MAKE) -C $(KERNELDIR) M=$(PWD) modules_install
clean:
rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions
.PHONY: modules modules_install clean
else
# called from kernel build system: just declare what our modules are
obj-m := chartest.o
endif
then in the same directory:
sudo insmod chartest.ko
finally:
sudo mknod -m 777 /dev/chartest0 c 230 0
Then you can compile maindriver.c and run it to test.
Can someone please help me fix this issue?

Answer 1

you can not use get_user the way you do:
from get_user doc
This macro copies a single simple variable from user space to kernel space. It supports simple types like char and int, but not larger data types like structures or arrays.ptr must have pointer-to-simple-variable type, and the result of dereferencing ptr must be assignable to x without a cast.
With get_user, you will only copy the first character.
You need to use copy_from_user, this function can copy array and structure, not only simple types:
ssize_t test_write(struct file *fp, const char __user *buffer, size_t count, loff_t *fpos) {
// We must validate the user's buffer and convert it to a long long
long userOperand;
unsigned char *userInput = NULL;
userInput = kmalloc(count, GFP_KERNEL);
printk(KERN_NOTICE "Write Function Entered.\n");
printk(KERN_ALERT "Write count: %ld, Write fp: %lld\n", count, *fpos);
/* warning, here you should test that count is exactly sizeof userInput */
copy_from_user(userInput, buffer, count);
userOperand = *(long*)userInput;
printk(KERN_NOTICE "Value after cast: %ld\n", userOperand);
// Increment the file position pointer (in our case, always by 8)
*fpos += count;
kfree(userInput);
return count;
}
You can also copy from char * to long in copy_from_user (no memory alloc in that case):
ssize_t test_write(struct file *fp, const char __user *buffer, size_t count, loff_t *fpos) {
// We must validate the user's buffer and convert it to a long long
long userOperand;
printk(KERN_NOTICE "Write Function Entered.\n");
printk(KERN_ALERT "Write count: %ld, Write fp: %lld\n", count, *fpos);
/* warning, here you should test that count is exactly sizeof userOperand */
copy_from_user(&userOperand, buffer, sizeof userOperand);
printk(KERN_NOTICE "Value after reading: %ld\n", userOperand);
// Increment the file position pointer (in our case, always by 8)
*fpos += count;
return count;
}

Answer 2

You use macro get_user incorrectly.
Its first argument should be literally a variable name, not the address of it.
Its second argument should be typed pointer to the user space data. And exactly type of that pointer is used for determine the size of the data to read.
Correct:
long userOperand;
...
get_user(userOperand, (const long __user*)buffer);
printk(KERN_NOTICE "Value written: %ld\n", userOperand);
Note to the case of the second argument: it is needed for read long instead of char (because buffer parameter is a pointer to the char).
Note, that code above doesn't use your userInput variable, so you don't need to define it and don't need to allocate memory.
Note, that .write method could be called with any count parameter which denotes number of bytes passed from the user. Since get_user always tries to read a predefined number of bytes (in your case this number is equal to the size of the long), it would be a user-friendly to check that count is equal to that number (or, at least, is not less than given number):
if (count != sizeof(long)) {
return -EINVAL;
}