In the last article, we managed to get our process blocked. As stated then, the code had couple of problems. One of them being unblocking the process. There was no one to wake our process up. Sleeping process is of no use. Another flaw was that our process was sleeping unconditionally. However, in real life scenarios, process never goes to sleep unconditionally. Read on to get the further understanding of wait mechanisms in the kernel.
Waking up the Process
We have the wake_up_process() API as shown below for waking up the process.
void wake_up_process(task_struct *ts); ts - pointer to the task_struct of the waiting process
As our process would be blocked, we need some other process to invoke this API. Below is code snippet which demonstrates the usage of this API.
#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/wait.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 *sleeping_task;
int open(struct inode *inode, struct file *filp)
{
printk(KERN_INFO "Inside open\n");
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(KERN_INFO "Inside read\n");
printk(KERN_INFO "Scheduling out\n");
sleeping_task = current;
set_current_state(TASK_INTERRUPTIBLE);
schedule();
printk(KERN_INFO "Woken up\n");
return 0;
}
ssize_t write(struct file *filp, const char *buff, size_t count, loff_t *offp)
{
printk(KERN_INFO "Inside Write\n");
wake_up_process(sleeping_task);
return count;
}
struct file_operations fops =
{
.read = read,
.write = write,
.open = open,
.release = release
};
int schd_init (void)
{
int ret;
struct device *dev_ret;
if ((ret = alloc_chrdev_region(&dev, FIRST_MINOR, MINOR_CNT, "wqd")) < 0)
{
return ret;
}
printk(KERN_INFO "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);
}
return 0;
}
void schd_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(schd_init);
module_exit(schd_cleanup);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Pradeep Tewani");
MODULE_DESCRIPTION("Waiting Process Demo");
In the above example, we are using the global variable sleeping_task to hold the task_struct of the sleeping process. This variable is updated in read() function. In write() function, we use the sleeping_task as a parameter to the wake_up_process() API.
Below is the sample run for the above example. Assuming that the above module is compiled as sched.ko:
$ insmod wait.ko Major Nr: 250 $ cat /dev/mychar0 Inside open Inside read Scheduling out
The above output is same as that of example from the last article. Now, comes the interesting part of waking up the process. For this, open another shell and execute the command as below:
$ echo 1 > /dev/mychar0 Inside open Inside write Woken up Inside close Inside close
When we execute the echo command, write operation gets invoked, which invokes the wake_up_process() to wake up the blocked process.
Waiting on an event
What we saw in the above example was the basic mechanism to block and unblock the process. However, as discussed earlier, the process always waits on some event. The event can be some specified amount of time, waiting for some resource or it can well be waiting for some data to arrive. Below is the modified version of above program to wait for an event.
ssize_t read(struct file *filp, char *buff, size_t count, loff_t *offp)
{
printk(KERN_INFO "Inside read\n");
printk(KERN_INFO "Scheduling Out\n");
sleeping_task = current;
slp:
if (flag != 'y')
{
set_current_state(TASK_INTERRUPTIBLE);
schedule();
}
if (flag == 'y')
printk(KERN_INFO "Woken Up\n");
else
{
printk(KERN_INFO "Interrupted by signal\n");
goto slp;
}
flag = 'n';
printk(KERN_INFO "Woken Up\n");
return 0;
}
ssize_t write(struct file *filp, const char *buff, size_t count, loff_t *offp)
{
printk(KERN_INFO, "Inside write\n");
ret = __get_user(flag, buffer);
printk(KERN_INFO "%c", flag);
wake_up_process(sleeping_task);
return count;
}
Here, we use the global variable flag to signal the condition and the event for waking up is the flag being set to ‘y’. This flag is updated in write() function as per the data from the user space. Below is the sample run of the above program, assuming that the module is compiled as sched.ko:
$ insmod wait.ko Major Nr: 250 $ cat /dev/mychar0 Inside open Inside read Scheduling out
This gets our process blocked. Open another shell to wake up the process:
$ echo 1 > /dev/mychar0 Inside open Inside write Interrupted by signal Inside close
Unlike earlier program, this doesn’t unblock the process. The process wakes up and again goes to sleep, since the condition for waking up is not satisfied. The process will wake up only if the flag is set to ‘y’. Let’s execute the echo as below:
$ echo 'y' > /dev/mychar0 Inside open Inside write Woken up Inside close Inside close
As seen above, this will wake up the process, since the condition of flag being ‘y’ is satisfied.
Conclusion
In this article, we implemented the basic wait mechanism in the driver. This was more like a manual waiting where everything needs to be taken care by driver writer and as such is prone to some synchronization issues. So, this kind of manual waiting is rarely used. However, kernel does provide some robust mechanism to implement the waiting. So, stay tuned to my next article to learn more about the waiting in Linux driver.