Hi,
Further continuing my previous code i am registering a class in "static int hello_init(void)" function and adding to the linked list and in
"static void hello_exit(void)" function i am trying to find the device from the list in the class using "class_find_device(&hello_drv, NULL, tmp, match_entry)" and un-registering all the devices from the calss and finally unregistering the class.
When i do insmod it works fine
But rmmod displays the message "killed" and the driver is not removed
messages are as below:
$>insmod hello.ko
$> rmmod hello.ko
killed
Please guide me i have copied my whole code.
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/sysfs.h>
#include <linux/device.h>
#include <linux/sysdev.h>
#include <linux/major.h>
#include <asm/uaccess.h>
#include <linux/slab.h>
#include <linux/cdev.h>
#include <linux/kdev_t.h>
#define MAJOR_NUM 200
#define DEVICE_NAME "cdev"
static int enable = 0;
struct hello_dev {
struct list_head list;
int device_open;
dev_t tev;
char name[10];
char buff[50];
};
static struct hello_dev mylist;
static struct hello_dev ref[4];
static ssize_t export_store(struct class *cls,struct class_attribute *attr, const char *buf, size_t count);
static ssize_t export_show(struct class *cls, struct class_attribute *attr, char *buf);
static ssize_t dev_attr_show(struct device *dev, struct device_attribute *attr, char *buf) ;
static ssize_t dev_attr_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size);
static ssize_t hello_read(struct file *, char *, size_t, loff_t *);
static ssize_t hello_write(struct file *, const char *, size_t, loff_t *);
static long hello_ioctl(struct file *filp, unsigned int ioctl_num, unsigned long ioctl_param);
static int hello_open(struct inode *, struct file *);
static int hello_release(struct inode *, struct file *);
static DEVICE_ATTR(Devattr, 0644, dev_attr_show, dev_attr_store);
static struct file_operations fops = {
.open = hello_open,
.read = hello_read,
.write = hello_write,
.release = hello_release,
.unlocked_ioctl = hello_ioctl
};
static struct class_attribute class_attr[] = {
__ATTR(export, 0644, export_show, export_store),
__ATTR_NULL,
};
static const struct attribute *Device_attrs[] = {
&dev_attr_Devattr.attr,
NULL,
};
static const struct attribute_group Device_attr_group = {
.attrs = (struct attribute **) Device_attrs,
};
static struct class hello_drv = {
.name = "Dev_Hello",
.owner = THIS_MODULE,
.class_attrs = (struct class_attribute *) &class_attr,
};
static ssize_t dev_attr_show(struct device *dev, struct device_attribute *attr, char *buf)
{
char *x[] = {"Disabled", "Enabled"};
return sprintf(buf, "%s\n", x[enable]);
return 0;
}
static ssize_t dev_attr_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
{
sscanf(buf, "%du", &enable);
return size;
}
static ssize_t export_show(struct class *cls, struct class_attribute *attr, char *buf)
{
char *x[] = {"Disabled", "Enabled"};
return sprintf(buf, "%s\n", x[enable]);
}
static ssize_t export_store(struct class *cls,struct class_attribute *attr, const char *buf, size_t count)
{
sscanf(buf, "%du", &enable);
return count;
}
static int hello_open(struct inode *inode, struct file *file)
{
struct hello_dev *hdev;
struct device *dev;
int status;
int count = 0;
hdev = &ref[iminor(inode)];
if((hdev->device_open) || (count >=3))
{
printk(KERN_INFO "Device Already Open\n Cannot open more devices");
return -EBUSY;
}
else if(count < 3)
{
count++;
hdev->device_open = 1;
file->private_data = hdev;
dev = device_create(&hello_drv, NULL, MKDEV(imajor(inode),iminor(inode)), NULL, "%s%d", "hdev", (int)count);
if(dev)
{
status = sysfs_create_group(&dev->kobj, &Device_attr_group);
if(status != 0)
printk("error creating sysfs_group\n");
return 0 ;
}
printk(KERN_INFO"Device opened\n");
try_module_get(THIS_MODULE);
}
return 0;
}
static int hello_release(struct inode *inode, struct file *file)
{
struct hello_dev *hdev;
hdev = (struct hello_dev *)file->private_data;
hdev->device_open = 0;
device_destroy(&hello_drv, MKDEV(imajor(inode), iminor(inode)));
// class_unregister(&hello_drv);
// unregister_chrdev(MAJOR_NUM, DEVICE_NAME);
printk(" GoodBye, world\n");
module_put(THIS_MODULE);
return 0;
}
static int hello_read(struct file *flip, char __user *buffer, size_t length, loff_t *offset)
{
int status;
struct hello_dev *hdev;
hdev = (struct hello_dev *)flip->private_data;
status = copy_to_user(buffer, hdev->buff, length);
if(status)
{
printk("Copy to user unsuccessful\n No: of bytes not copied = %d\n", status);
status = length - status;
}
else
{
printk("Device read\n");
}
return status;
}
static int hello_write(struct file *flip, const char * buffer, size_t length, loff_t * offset)
{
int count;
struct hello_dev *hdev;
hdev = (struct hello_dev *)flip->private_data;
memset(hdev->buff, '\0', length);
count = copy_from_user(hdev->buff, buffer, length);
printk("Device Write Done\n");
count = length - count;
return count;
}
long hello_ioctl(struct file *flip,unsigned int ioctl_num,unsigned long ioctl_param)
{
switch(ioctl_num)
{
case 0:
printk("IOCTL : CASE 0:");
break;
case 1:
printk("IOCTL : CASE 1:");
break;
default:
printk(KERN_ALERT"Unknown IOCTL number\n");
break;
}
return 0;
}
static int hello_init(void)
{
int status;
struct device *dev;
int count = 0;
int i;
struct list_head *pos, *q;
struct hello_dev *tmp;
// struct hello_dev mylist;
INIT_LIST_HEAD(&mylist.list);
for(i=0; i<4;i++)
{
ref[i].device_open = 0;
}
status = register_chrdev(MAJOR_NUM, DEVICE_NAME, &fops);
if(status < 0)
printk("Registering char driver failed with status = %d\n", status);
else
printk("Hello World\n");
status = class_register(&hello_drv);
if(status < 0)
printk("Registering Class Failed\n");
tmp = (struct hello_dev *)kmalloc(sizeof(struct hello_dev), GFP_KERNEL);
tmp->device_open = 1;
tmp->tev = MKDEV(MAJOR_NUM, count);
list_add(&(tmp->list), &(mylist.list));
dev = device_create(&hello_drv, NULL, MKDEV(MAJOR_NUM,count), NULL, "%s%d", "hdev", (int) count);
count++;
if(dev)
{
status = sysfs_create_group(&dev->kobj, &Device_attr_group);
if(status != 0)
printk("error creating sysfs_group\n");
}
list_for_each(pos, &mylist.list)
{
tmp = list_entry(pos, struct hello_dev, list);
printk("device_open = %d dev_t = 0x%X \n ", tmp->device_open, tmp->tev);
}
return 0;
}
static int match_entry(struct device *dev, void *data)
{
dev_t *devt = data;
return dev->devt == *devt;
// return dev_get_drvdata(dev) == data;
}
static void hello_exit(void)
{
struct hello_dev *tmp;
struct device *dev;
struct list_head *pos, *q;
list_for_each(pos, &mylist.list)
{
tmp = list_entry(pos, struct hello_dev, list);
dev = class_find_device(&hello_drv, NULL, tmp, match_entry);
if(dev)
device_unregister(dev);
else
printk("Den Is NULL");
list_del(pos);
kfree(tmp);
}
class_unregister(&hello_drv);
unregister_chrdev(MAJOR_NUM, DEVICE_NAME);
printk(" GoodBye, world\n");
}
module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");
