Linux 4.13内核实现平方根系统调用遇SSE编译错误求助

Hey, let's break down your problem and fix it step by step. That SSE error is a common gotcha when dealing with floating points in the Linux kernel, and there's a couple of ways to handle it—some safe, some less so. Let's start with the root cause, then dive into solutions.

Why You're Seeing This Error #

The Linux kernel is intentionally built with SSE/AVX floating-point instruction support disabled by default. Here's why:

1. Compatibility: The kernel needs to run across a wide range of x86 hardware, including older systems that don't support SSE.
2. Context Safety: User-space programs often use SSE registers. If the kernel uses them without saving/restoring the state first, it'll corrupt user-space's floating-point context, crashing applications.
3. Printk Limitation: On top of that, printk doesn't even support %f format specifiers—even if you fixed the SSE error, your output would be garbage or trigger runtime issues.

Your code uses float types, so the compiler tries to generate SSE instructions, but the kernel's build flags block this, hence the "SSE register return with SSE disabled" error.

Recommended Solution: Avoid Floating Points Entirely #

The safest and most kernel-friendly approach is to implement square root using integer arithmetic only, then format the result as a decimal string for printk. Here's how to do it:

Step 1: Integer Square Root with Decimal Approximation #

We'll use a Newton-Raphson iteration for the integer part, then calculate a decimal approximation (e.g., 6 decimal places) using integer operations:

#include <linux/kernel.h>
#include <linux/syscalls.h>

SYSCALL_DEFINE1(my_sqrt, unsigned long, n) {
    if (n == 0) {
        printk(KERN_INFO "Square root of %lu is 0.000000\n", n);
        return 0;
    }

    // Calculate integer part of square root (Newton-Raphson)
    unsigned long x = n;
    unsigned long y = (x + 1) / 2;
    while (y < x) {
        x = y;
        y = (x + n / x) / 2;
    }

    // Calculate decimal part (approx 6 places)
    unsigned long remainder = n - x * x;
    unsigned long decimal = 0;
    unsigned long temp = remainder;

    for (int i = 0; i < 6; i++) {
        temp *= 10;
        decimal = decimal * 10 + temp / (2 * x);
        temp = temp % (2 * x);
    }

    // Print using integer format specifiers (no floats!)
    printk(KERN_INFO "Square root of %lu is %lu.%06lu\n", n, x, decimal);
    return 0;
}

Step 2: Compile and Test #

This code uses only integer operations, so it won't trigger any SSE-related errors. It also avoids printk's lack of %f support by formatting the result with integer placeholders.

Alternative (Not Recommended): Enable Floating-Point Support #

If you absolutely must use floating-point math (e.g., for learning purposes), you can manually enable SSE and handle context preservation—but this is risky and not suitable for production systems.

Step 1: Add Compiler Flags #

In your syscall's Makefile, add flags to enable SSE:

CFLAGS += -mfpmath=sse -msse2

You may also need to enable CONFIG_X86_SSE in your kernel's .config file and recompile the entire kernel.

Step 2: Preserve FPU/SSE Context #

The kernel doesn't automatically save floating-point registers, so you have to do it manually using kernel-provided functions:

#include <linux/kernel.h>
#include <linux/syscalls.h>
#include <asm/fpu/api.h>
#include <linux/string.h>

SYSCALL_DEFINE1(my_sqrt, unsigned long, n) {
    float sqrt_val;
    float x = (float)n;
    float xhalf = 0.5f * x;

    // Save FPU/SSE registers before using floating points
    kernel_fpu_begin();

    // Your original Newton-Raphson implementation for reciprocal sqrt
    int i = *(int*)&x;
    i = 0x5f3759df - (i >> 1); // Magic initial guess
    x = *(float*)&i;
    x = x * (1.5f - xhalf * x * x); // Iterate once
    x = x * (1.5f - xhalf * x * x); // Iterate again
    sqrt_val = x * n; // Convert reciprocal sqrt to actual sqrt

    // Restore FPU/SSE registers
    kernel_fpu_end();

    // Convert float to string (printk doesn't support %f!)
    char buf[32];
    snprintf(buf, sizeof(buf), "%f", (double)sqrt_val);
    printk(KERN_INFO "Square root of %lu is %s\n", n, buf);

    return 0;
}

Critical Notes for This Approach #

• Stability Risk: If you forget to save/restore the FPU context, you'll crash user-space applications that use floating points.
• No Libm in Kernel: You can't use standard sqrt() from libm—you have to implement your own floating-point sqrt logic.
• Portability: This only works on x86 systems with SSE support; it'll break on other architectures like ARM.

Final Reminders #

• Never use %f with printk: The kernel's print function doesn't support floating-point formatting—always convert floats to strings first if you must use them.
• Floating points in the kernel are a last resort: Integer arithmetic is faster, safer, and more portable for kernel code.

内容的提问来源于stack exchange，提问作者Joko