In the last two articles, we have discussed some of the commonly used synchronization mechanisms in kernel. It was observed that these synchronization mechanisms restrict the access to the resource, irrespective of the operation which thread/process wants to perform on the resource. This in turn, mean that even though one thread has acquired the resource for read access, another thread can’t access the same resource for reading. In most of the cases, it is quite desirable to have two or more threads having the read access to the resource as far as they are not modifying the resource data structure. This will result into the improved system performance. Read on to find out the mechanism provided by kernel to achieve this.
Reader / Writer Semaphore
This is the type of semaphore, which provides the access depending on operation which thread/process wants to perform on the data structure. With this, multiple readers can have the access to the resource at the same time, while only one writer gets access at a time. So, will reader be allowed if write operation is in progress? Definitely not. At a time, there can be either read or write operation in progress as usual, but there can be multiple read operations. So, let’s look at the data structures associated with the reader / writer semaphores:
#include <linux/rwsem.h> // Data Structure structure rw_semaphore rw_sem; // Initialization void init_rwsem(&rw_sem); // Operations for reader void down_read(&rw_sem); void up_read(&rw_sem); // Operations for writer void down_write(&rw_sem); void up_write(&rw_sem);
As seen above, initialization operation is similar to what we do with the regular semaphore, but key difference lies in the fact that we have separate operations for readers and writers.
Below is an example usage of reader / writer semaphore:
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <asm/uaccess.h>
#include <linux/semaphore.h>
#include <linux/sched.h>
#include <linux/delay.h>
#define FIRST_MINOR 0
#define MINOR_CNT 1
static dev_t dev;
static struct cdev c_dev;
static struct class *cl;
static struct task_struct *task;
static struct rw_semaphore rwsem;
int open(struct inode *inode, struct file *filp)
{
printk(KERN_INFO "Inside open\n");
task = current;
return 0;
}
int release(struct inode *inode, struct file *filp)
{
printk(KERN_INFO "Inside close\n");
return 0;
}
ssize_t read(struct file *filp, char *buff, size_t count, loff_t *offp)
{
printk("Inside read\n");
down_read(&rwsem);
printk(KERN_INFO "Got the Semaphore in Read\n");
printk("Going to Sleep\n");
ssleep(30);
up_read(&rwsem);
return 0;
}
ssize_t write(struct file *filp, const char *buff, size_t count, loff_t *offp)
{
printk(KERN_INFO "Inside write. Waiting for Semaphore...\n");
down_write(&rwsem);
printk(KERN_INFO "Got the Semaphore in Write\n");
up_write(&rwsem);
return count;
}
struct file_operations fops =
{
read: read,
write: write,
open: open,
release: release
};
int rw_sem_init(void)
{
int ret;
struct device *dev_ret;
if ((ret = alloc_chrdev_region(&dev, FIRST_MINOR, MINOR_CNT, "rws")) < 0)
{
return ret;
}
printk("Major Nr: %d\n", MAJOR(dev));
cdev_init(&c_dev, &fops);
if ((ret = cdev_add(&c_dev, dev, MINOR_CNT)) < 0)
{
unregister_chrdev_region(dev, MINOR_CNT);
return ret;
}
if (IS_ERR(cl = class_create(THIS_MODULE, "chardrv")))
{
cdev_del(&c_dev);
unregister_chrdev_region(dev, MINOR_CNT);
return PTR_ERR(cl);
}
if (IS_ERR(dev_ret = device_create(cl, NULL, dev, NULL, "mychar%d", 0)))
{
class_destroy(cl);
cdev_del(&c_dev);
unregister_chrdev_region(dev, MINOR_CNT);
return PTR_ERR(dev_ret);
}
init_rwsem(&rwsem);
return 0;
}
void rw_sem_cleanup(void)
{
printk(KERN_INFO "Inside cleanup_module\n");
device_destroy(cl, dev);
class_destroy(cl);
cdev_del(&c_dev);
unregister_chrdev_region(dev, MINOR_CNT);
}
module_init(rw_sem_init);
module_exit(rw_sem_cleanup);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("SysPlay Workshops <workshop@sysplay.in>");
MODULE_DESCRIPTION("Reader Writer Semaphore Demo");
Below is the sample run:
cat /dev/mychar0 Inside Open Inside Read Got the Semaphore in Read Going to sleep cat /dev/mychar0 (In different shell) Inside Open Inside Read Got the Semaphore in Read Going to sleep echo 1 > /dev/mychar0 (In different shell) Inside Write. Waiting for semaphore...
As seen above, multiple reader processes are able to access the resource simultaneously. However, writer process gets blocked, while the readers are accessing the resource.
Conclusion
With this, we have covered most of the commonly used synchronization mechanisms in the kernel. Apart from these, kernel provides some atomic operations, which provides instructions that execute atomically without interruption. Atomic operators are indivisible instructions. These are useful when we need to do some operations on integers and bits.