When save states while dealing with tasklets?

Question

I'm reading Linux Kernel development and get confused in the tasklets chapter ( https://doc.lagout.org/operating%20system%20/linux/Linux%20Kernel%20Development%2C%203rd%20Edition.pdf page143). In the tasklet_schedule function, the interrupt state is saved while in the taslet_action it is not. The author explains that the context is not saved in taslet_action because the function knows that interrupts are always enabled. I fail to understand how does the set of interrupts interfere with saving the context? Thank you!

Answer 1

The author states that tasklet_schedule can be called with either interrupts disabled or enabled. Since it wants them disabled, it needs to save whether they are already disabled. Then after the work is done it knows whether to enable them (if they were enabled prior to the call it enables them, if they were disabled prior to the call it leaves them disabled). In contrast, tasklet_action is only called with interrupts enabled, so there is no point in checking their state. They always get disabled and enabled on return.

Answer 2

In case of tasklet_schedule :

We do not want interrupt to disturb us when we are scheduling a tasklet, so we have to disable it. But we also know that, when we are done with scheduling the tasklet, we want to go back to the state of IRQ as it was before schedule tasklet was called. To achieve this, we save the state of the IRQ register before doing anything, then disable the IRQ as per our requirement, do the scheduling, now before going back restore the state of the IRQ and then return from the function.

Now coming to the complicated part, Why dont we need to save the IRQ when executing the tasklet ie when the handler calls the tasklet function ? To understand that we need to look at two different paragraphs :

On page 141 :

The softirq handlers run with interrupts enabled and cannot sleep .While a handler runs, softirqs on the current processor are disabled.Another processor, however, can exe-cute other softirqs. If the same softirq is raised again while it is executing, another processor can run it simultaneously.

So this declares that interrupts are always enabled.

Now going to pg 143 :

1. Disable local interrupt delivery (there is no need to first save their state because the code here is always called as a softirq handler and interrupts are always enabled) and retrieve the tasklet_vec or tasklet_hi_vec list for this processor

So we can conclude that we dont need to save the IRQ state as we already know its state and it will remain so in all the conditions so we just disable the IRQ and enable it later.