Re: character device driver reading only last character of buffer

[Venkatram Tummala <venkatram867@xxxxxxxxx>]

On Sat, Sep 25, 2010 at 8:34 AM, Bond <jamesbond.2k.g@xxxxxxxxx> wrote:

Since you people think me to be a newbie or moron or some thing like copy pasting the code so I am explaining each and every line of it what it is doing but still lectures are lectures and funda's don't work show me real thing or else do not reply.



#include <linux/init.h>

#include <linux/module.h>
#include <linux/kernel.h> /* printk() */
#include <linux/slab.h> /* kmalloc() */
#include <linux/fs.h> /* everything... */
#include <linux/errno.h> /* error codes */
#include <linux/types.h> /* size_t */
#include <linux/proc_fs.h>
#include <linux/fcntl.h> /* O_ACCMODE */
#include <asm/system.h> /* cli(), *_flags */
#include <asm/uaccess.h> /* copy_from/to_user */

The section declared above is used to include header files.

MODULE_LICENSE("Dual BSD/GPL");

MODULE_LICENSE is an exported symbol.

int bond_open(struct inode *inode, struct file *filp);
int bond_release(struct inode *inode, struct file *filp);
ssize_t bond_read(struct file *filp, char *buf, size_t count, loff_t *f_pos);
ssize_t bond_write(struct file *filp, char *buf, size_t count, loff_t *f_pos);

just above defined four functions which will be used in structure file_operations which is of type defined in fs.h


void bond_exit(void);
int bond_init(void);

my init and exit modules of code.

struct file_operations bond_fops = {
  .read = bond_read,
  .write = bond_write,
  .open = bond_open,
  .release = bond_release
declared as above as per new C99 rules so that rest of the file_operations which are not defined be declared NULL
};

above  operations corresponding to the system calls an application can apply to a file : file operations as in fs.h

module_init(bond_init);
module_exit(bond_exit);

my init and exit modules

int bond_major = 60;

there is another way alloc_chrdrv but I am using register_chrdrv so defining the major number


char *bond_buffer;

device buffer to store data when user programs access it

int bond_init(void) {
  int result;


  result = register_chrdev(bond_major, "bond", &bond_fops);
  if (result < 0) {
    printk(KERN_ALERT  "memory: cannot obtain major number %d\n", bond_major);
    return result;
  }


  bond_buffer = kmalloc(14, GFP_KERNEL);
giving 14 bytes to buffer three types GFP_KERNEL,GFP_ATOMIC one more I forgot

  if (!bond_buffer) {
    result = -ENOMEM;
    goto fail;
  }
in case of error above will stop execution

  memset(bond_buffer, 0, 14);

filling all the bytes of memory Claros pointed me here that if I ever used malloc function in my life so mentioning this was important for him.

  printk(KERN_ALERT "Inserting bond module\n");
  return 0;

  fail:

    bond_exit();
    return result;
same when returns a -ve value if fail to register the major number 60
}




void bond_exit(void) {

  unregister_chrdev(bond_major, "bond");


  if (bond_buffer) {
    kfree(bond_buffer);

  }

  printk( KERN_ALERT "Removing bond module\n");

}

just above is a clean up module when driver exits or unloads


int bond_open(struct inode *inode, struct file *filp) {


  return 0;
}

will be needed when a process opens the file

int bond_release(struct inode *inode, struct file *filp) {
 

  return 0;
}

when releasing device driver

ssize_t bond_read(struct file *filp, char *buf,
                    size_t count, loff_t *f_pos) {
 

  copy_to_user(buf,bond_buffer,count<14 ? count:14);
This function works as given here
http://www.gnugeneration.com/mirrors/kernel-api/r4299.html
and an example of this in the current kernel is linux-2.6/drivers/char/snsc.c
they implemented a function scdrv_write I implemented bond_write both implementations are different
do you people get that or still some lecture is missing.
}

ssize_t bond_write( struct file *filp, char *buf,
                      size_t count, loff_t *f_pos) {

  copy_from_user(bond_buffer,buf,count<14 ? count : 14);
from the userspace buf copy the bytes whose total number is equal to count to bond_buffer
  return 1;
}

The above fundas and lectures do not work.You people give lectures or show attitude but only if the code works.

Hey buddy, i took the module code in your first post & modified it to make it work . I am attaching the code. It works on the latest kernel 2.6.35. If you are using any other kernel, you may have to change the file_operations function pointers (memory_read & memory_write signatures) by looking at struct file_operations in include/linux/fs.h. Rest assured, the code does exactly what you want it do.

Do the following steps :

1) insmod <MODULE.ko>

2) cat /proc/devices |grep <DEVICENAME>     This will fetch you a number. Use it in step 3

3) mknod /dev/<DEVICENAME> c <Number from step 2> 0

4) echo  -n "whatever" > /dev/<DEVICENAME>

5) cat /dev/<DEVICENAME>

This will print the the last character of the string you  wrote.

As a side note, please spare us all with all this non-sense. We have better things to do in our life. Please try your level best to understand things before asking the kernel mailing list. If this BS continues, i am afraid you will get yourself kicked out of the mailing list. Please do yourself a favour by not posting such crap.

Venkatram Tummala

/* Necessary includes for device drivers */
#include <linux/init.h>
//#include <linux/config.h>
#include <linux/module.h>
#include <linux/kernel.h> /* printk() */
#include <linux/slab.h> /* kmalloc() */
#include <linux/fs.h> /* everything... */
#include <linux/errno.h> /* error codes */
#include <linux/types.h> /* size_t */
#include <linux/proc_fs.h>
#include <linux/fcntl.h> /* O_ACCMODE */
#include <asm/system.h> /* cli(), *_flags */
#include <asm/uaccess.h> /* copy_from/to_user */

MODULE_LICENSE("Dual BSD/GPL");

/* Declaration of memory.c functions */
int memory_open(struct inode *inode, struct file *filp);
int memory_release(struct inode *inode, struct file *filp);
ssize_t memory_read(struct file *filp, char *buf, size_t count, loff_t *f_pos);
ssize_t memory_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos);
void memory_exit(void);
int memory_init(void);

/* Structure that declares the usual file */
/* access functions */
struct file_operations memory_fops = {
	read: memory_read,
   	write: memory_write,
	open: memory_open,
	release: memory_release
};
/* Declaration of the init and exit functions */
module_init(memory_init);
module_exit(memory_exit);

/* Buffer to store data */
char *memory_buffer;
int result;

int memory_init(void) {

	/* Registering device */
	result = register_chrdev(0, "bond", &memory_fops);
	if (result < 0) {
		printk(KERN_ALERT  "memory: cannot obtain major number \n");
		return result;
	}

	/* Allocating memory for the buffer */
	memory_buffer = kmalloc(1, GFP_KERNEL); 
	if (!memory_buffer) { 
		result = -ENOMEM;
		goto fail; 
	} 
	memset(memory_buffer, 0, 1);

	printk(KERN_ALERT "Inserting bond module\n"); 
	return 0;

fail: 
	memory_exit(); 
	return result;
}


void memory_exit(void) {
	/* Freeing the major number */
	unregister_chrdev(result, "bond");

	/* Freeing buffer memory */
	if (memory_buffer) {
		kfree(memory_buffer);
	}

	printk( KERN_ALERT "Removing bond module\n");

}


int memory_open(struct inode *inode, struct file *filp) {

	/* Success */
	return 0;
}


int memory_release(struct inode *inode, struct file *filp) {

	/* Success */
	return 0;
}


ssize_t memory_read(struct file *filp, char __user *buf, 
		size_t count, loff_t *f_pos) 
{ 
	if (*f_pos != 0)
		return 0;
	copy_to_user(buf,memory_buffer,1);
	if(*f_pos == 0)
		*f_pos = *f_pos + 1;

	return 1; 
}

ssize_t memory_write( struct file *filp, const char __user *buf,
		size_t count, loff_t *f_pos) 
{
	copy_from_user(memory_buffer, buf + count - 1, 1);
	return 1;
}