Race Condition
A race condition occurs when two or more threads can access shared data and they try to change it at the same time. Because the thread scheduling algorithm can swap between threads at any time, we don’t know the order in which the threads will attempt to access the shared data. Therefore, the result of the change in data is dependent on the thread scheduling algorithm, i.e. both threads are “racing” to access/change the data.
To avoid the race conditions, we have many ways like Semaphore, Spinlock and Mutex. In this tutorial we will concentrate on Mutex.
Mutex
A mutex is a mutual exclusion lock. Only one thread can hold the lock.
Mutex is used as a synchronization primitive in situations where a resource has to be shared by multiple threads simultaneously.
Mutex has ownership. The thread which locks a Mutex must also unlock it.
So whenever you are accessing a shared resource that time first we lock mutex and then access the shared resource. When we are finished with that shared resource then we unlock the Mutex.
Mutex in Linux Kernel
struct mutex {
atomic_t count;
spinlock_t wait_lock;
struct list_head wait_list;
};
Initializing Mutex
We can initialize Mutex in two ways
- Static Method
- Dynamic Method
Static Method
This method will be useful while using global Mutex. This macro is defined below.
DEFINE_MUTEX(name);
This call defines and initializes a mutex. Refer to
Linux/include/linux/mutex.hDynamic Method
This method will be useful for per-object mutexes, when mutex is just a field in a heap-allocated object. This macro is defined below.
mutex_init(struct mutex *lock);mutex_lock
This is used to lock/acquire the mutex exclusively for the current task. If the mutex is not available, the current task will sleep until it acquires the Mutex.
The mutex must later on be released by the same task that acquired it. Recursive locking is not allowed. The task may not exit without first unlocking the mutex. Also, kernel memory where the mutex resides must not be freed with the mutex still locked. The mutex must first be initialized (or statically defined) before it can be locked.
memset-ing the mutex to 0 is not allowed.void mutex_lock(struct mutex *lock);mutex_trylock
This will try to acquire the mutex, without waiting (will attempt to obtain the lock, but will not sleep). Returns 1 if the mutex has been acquired successfully, and 0 on contention.
int mutex_trylock(struct mutex *lock);
Argument:
struct mutex *lock – the mutex to be acquired
This function must not be used in interrupt context. The mutex must be released by the same task that acquired it.
Mutex Unlock
This is used to unlock/release a mutex that has been locked by a task previously.
This function must not be used in interrupt context. Unlocking of a not locked mutex is not allowed.
void mutex_unlock(struct mutex *lock);
#include
#include
#include
#include
#include
#include
#include
#include //kmalloc()
#include //copy_to/from_user()
#include //kernel threads
#include //task_struct
#include
#include
struct mutex etx_mutex;
unsigned long etx_global_variable = 0;
dev_t dev = 0;
static struct class *dev_class;
static struct cdev etx_cdev;
static int __init etx_driver_init(void);
static void __exit etx_driver_exit(void);
static struct task_struct *etx_thread1;
static struct task_struct *etx_thread2;
/*************** Driver Fuctions **********************/
static int etx_open(struct inode *inode, struct file *file);
static int etx_release(struct inode *inode, struct file *file);
static ssize_t etx_read(struct file *filp,
char __user *buf, size_t len,loff_t * off);
static ssize_t etx_write(struct file *filp,
const char *buf, size_t len, loff_t * off);
/******************************************************/
int thread_function1(void *pv);
int thread_function2(void *pv);
int thread_function1(void *pv)
{
while(!kthread_should_stop()) {
mutex_lock(&etx_mutex);
etx_global_variable++;
printk(KERN_INFO "In EmbeTronicX Thread Function1 %lu\n", etx_global_variable);
mutex_unlock(&etx_mutex);
msleep(1000);
}
return 0;
}
int thread_function2(void *pv)
{
while(!kthread_should_stop()) {
mutex_lock(&etx_mutex);
etx_global_variable++;
printk(KERN_INFO "In EmbeTronicX Thread Function2 %lu\n", etx_global_variable);
mutex_unlock(&etx_mutex);
msleep(1000);
}
return 0;
}
static struct file_operations fops =
{
.owner = THIS_MODULE,
.read = etx_read,
.write = etx_write,
.open = etx_open,
.release = etx_release,
};
static int etx_open(struct inode *inode, struct file *file)
{
printk(KERN_INFO "Device File Opened...!!!\n");
return 0;
}
static int etx_release(struct inode *inode, struct file *file)
{
printk(KERN_INFO "Device File Closed...!!!\n");
return 0;
}
static ssize_t etx_read(struct file *filp,
char __user *buf, size_t len, loff_t *off)
{
printk(KERN_INFO "Read function\n");
return 0;
}
static ssize_t etx_write(struct file *filp,
const char __user *buf, size_t len, loff_t *off)
{
printk(KERN_INFO "Write Function\n");
return len;
}
static int __init etx_driver_init(void)
{
/*Allocating Major number*/
if((alloc_chrdev_region(&dev, 0, 1, "etx_Dev")) <0){
printk(KERN_INFO "Cannot allocate major number\n");
return -1;
}
printk(KERN_INFO "Major = %d Minor = %d \n",MAJOR(dev), MINOR(dev));
/*Creating cdev structure*/
cdev_init(&etx_cdev,&fops);
etx_cdev.owner = THIS_MODULE;
etx_cdev.ops = &fops;
/*Adding character device to the system*/
if((cdev_add(&etx_cdev,dev,1)) < 0){
printk(KERN_INFO "Cannot add the device to the system\n");
goto r_class;
}
/*Creating struct class*/
if((dev_class = class_create(THIS_MODULE,"etx_class")) == NULL){
printk(KERN_INFO "Cannot create the struct class\n");
goto r_class;
}
/*Creating device*/
if((device_create(dev_class,NULL,dev,NULL,"etx_device")) == NULL){
printk(KERN_INFO "Cannot create the Device \n");
goto r_device;
}
/* Creating Thread 1 */
etx_thread1 = kthread_run(thread_function1,NULL,"eTx Thread1");
if(etx_thread1) {
printk(KERN_ERR "Kthread1 Created Successfully...\n");
} else {
printk(KERN_ERR "Cannot create kthread1\n");
goto r_device;
}
/* Creating Thread 2 */
etx_thread2 = kthread_run(thread_function2,NULL,"eTx Thread2");
if(etx_thread2) {
printk(KERN_ERR "Kthread2 Created Successfully...\n");
} else {
printk(KERN_ERR "Cannot create kthread2\n");
goto r_device;
}
mutex_init(&etx_mutex);
printk(KERN_INFO "Device Driver Insert...Done!!!\n");
return 0;
r_device:
class_destroy(dev_class);
r_class:
unregister_chrdev_region(dev,1);
cdev_del(&etx_cdev);
return -1;
}
void __exit etx_driver_exit(void)
{
kthread_stop(etx_thread1);
kthread_stop(etx_thread2);
device_destroy(dev_class,dev);
class_destroy(dev_class);
cdev_del(&etx_cdev);
unregister_chrdev_region(dev, 1);
printk(KERN_INFO "Device Driver Remove...Done!!\n");
}
module_init(etx_driver_init);
module_exit(etx_driver_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("EmbeTronicX " );
MODULE_DESCRIPTION("A simple device driver - Mutex");
MODULE_VERSION("1.17");
No comments:
Post a Comment