Tasklets Vs Work queues in the kernel

Tasklets Vs Work queues in the kernel

Tasklets and work queues used to implement deferrable functionality in the kernel. Using the Tasklets and Work queues, we can schedule a function to run at later point of time.

Deferrable functions:

It is a mechanism for supporting delayed execution of functions (not urgent functions), used in interrupt handlers.

Types of deferrable functions

1.       Tasklets

2.       Work queues

Mostly, we use these functions in Interrupt Handlers. Because some or majority of the interrupts are disabled in interrupt context. So, if the functions take more time for execution in this context then the latency to handle other hardware interrupts. Generally, we enter into interrupt context when a hardware interrupt is raised.

If we add Deferrable function in the interrupt handlers then this function will be executed in Kernel Context where the all hardware interrupts are in enable mode. So, we move function of code which can later be executed without any harm using deferrable function. And, hence we are minimizing the latency to handle hardware interrupts.

Generally the processing of work done in interrupt handler called as Top Half.

And, the processing of work done in kernel context called as Bottom Half.

Aim: Reduce work (execution time of handler code) in Top Half

We can achieve this using Tasklets method or Work queue.

Using Tasklets:

As already mentioned, the main job of the Tasklets is to schedule the work (function) to run later point of time so that we can decrease the amount of work done in interrupt handlers.

/* Declaring Tasklet */

void tasklet_function(unsigned long data);

DECLARE_TASKLET(tasklet_name, tasklet_function, tasklet_data);

/* Scheduling Tasklet */

tasklet_schedule(&tasklet_name);

Tasklets are represented by tasklet_struct structure.

struct tasklet_struct {

                struct tasklet_struct *next; /*pointing to next tasklet structure */

                unsigned long state; /* state = TASKLET_STATE_SCHED or TASKLET_STATE_RUN */

                atomic count; /* 0 = Enable; !0 = Disable */

unsigned long data;

void (*func) (unsigned long); /*func(data) */

}

Tasklets are defined using a macro DECLARE _TASKLET, which initializes the tasklet_struct using its arguments tasklet_name, tasklet_func and data.

Tasklets are enabled by default when defined using DECLARE_TASKLET macro, so that we can schedule it directly without using any other APIs.

But, if we declare tasklet using DECLARE_TASKLET_DISABLED macro then we should explicitly call tasklet_enable() API before scheduling this tasklet.

Tasklet APIs:

/* Defining Tasklet using macros */

DECLARE_TASKLET(name, func, data);

DECLARE_TASKLET_DISABLED(name, func, data);

void tasklet_init(struct tasklet_struct *, void (*func) (unsigned long), unsigned long data); /*initializes the tasklet structure with user provided info */

/* Enabling and Disabling a tasklet using enable() and disable() */

void tasklet_enable(struct tasklet_struct *); /* Enable normal priority scheduling */

void tasklet_disable(struct tasklet_struct *); /* returns after disabling the tasklet */

void tasklet_hi_enable(struct tasklet_struct *); /* Enabling High priority scheduling */

void tasklet_disable_nosync(struct tasklet_struct *); /* may returns before termination */

/* Schedule a tasklet*/

void tasklet_schedule (struct tasklet_struct *); /* Normal priority scheduling */

void tasklet_hi_schedule (struct tasklet_struct *); /* Higher priority scheduling */

CPU maintains the normal and high priority softirq vectors lists (normal priority vector list and high priority vector list) where these functions are queued.

If the function is higher priority function then it is enqueued in higher priority softirq vector list and similar case for normal priority functions.

The below two functions are used to kill a tasklet

void tasklet_kill(struct tasklet_struct *);

void tasklet_hi_kill(struct tasklet_struct *); /* Kill the tasklet and ensure they would never run */

Sample Program: tasklet.c

#include<linux/module.h>

#include<linux/kernel.h>

#include<linux/interrupt.h>

char tasklet_data[] = "tasklet function was called";

void my_tasklet_function (unsigned long data) {

        printk("%s: in %s\n", (char*)data, __func__);

}

DECLARE_TASKLET(my_first_tasklet, my_tasklet_function, (unsigned long)&tasklet_data);

int init_module()

{

        /* schedule our my_tasklet_function */

        tasklet_schedule(&my_first_tasklet);

        return 0;

}

void cleanup_module(void)

{

        tasklet_kill(&my_first_tasklet);

        return;

}

Makefile:

obj-m += tasklet.o

KDIR = /usr/src/linux-headers-2.6.32-28-generic

all:

        $(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules

clean:

        rm -rf *.o *.ko *.mod.* *.symvers *.order

Execution:

sudo insmod tasklet.ko

Output: dmesg

[3302661.097630] tasklet function was called: in my_tasklet_function

Next: Will cover work queues also...