Question

This is related to this question.

I’m not an expert on Linux device drivers or kernel modules, but I’ve been reading ‘Linux Device Drivers’ [O’Reilly] by Rubini & Corbet and a number of online sources, but I haven’t been able to find anything on this specific issue yet.

When is a kernel or driver module allowed to use floating-point registers?
If so, who is responsible for saving and restoring their contents?
(Assume x86-64 architecture)

If I understand correctly, whenever a KM is running, it is using a hardware context (or hardware thread or register set — whatever you want to call it) that has been preempted from some application thread. If you write your KM in c, the compiler will correctly insure that the general-purpose registers are properly saved and restored (much as in an application), but that doesn’t automatically happen with floating-point registers. For that matter, a lot of KMs can’t even assume that the processor has any floating-point capability.

Am I correct in guessing that a KM that wants to use floating-point has to carefully save and restore the floating-point state? Are there standard kernel functions for doing this?

Are the coding conventions for this spelled out anywhere?
Are they different for SMP-non SMP drivers?
Are they different for older non-preemptive kernels and newer preemptive kernels?

Answer 1

Short answer: Kernel code can use floating point if this use is surrounded by kernel_fpu_begin()/kernel_fpu_end(). These function handle saving and restoring the fpu context. Also, they call preempt_disable()/preempt_enable(), which means no sleeping, page faults etc. in the code between those functions. Google the function names for more information.

If I understand correctly, whenever a KM is running, it is using a hardware context (or hardware thread or register set — whatever you want to call it) that has been preempted from some application thread.

No, a kernel module can run in user context as well (eg. when userspace calls syscalls on a device provided by the KM). It has, however, no relation to the float issue.

If you write your KM in c, the compiler will correctly insure that the general-purpose registers are properly saved and restored (much as in an application), but that doesn’t automatically happen with floating-point registers.

That is not because of the compiler, but because of the kernel context-switching code.