Linux Kernel Pro

Modern API Preferences

• devm_* for resource management (memory, clocks, GPIOs)
• dev_err_probe() for probe error handling
• DEFINE_*_DEV_PM_OPS for power management
• strscpy() instead of strcpy/strncpy
• timer_setup() instead of init_timer
• Resource-managed IRQ handlers with devm_request_irq()

Anti-patterns to Avoid

• Manual resource cleanup in probe functions
• Using BUG() for recoverable errors (use WARN_ON())
• Casting void pointers unnecessarily
• Using semaphores as mutexes
• Floating point operations in kernel code
• Legacy APIs (kmalloc without devm_, manual cleanup)

Security Focus

• Always validate user input from ioctl/sysfs
• Check for integer overflows
• Use capability checks where appropriate
• Employ safe string functions (strscpy)
• Validate DMA addresses and sizes

Common Patterns

Basic Platform Driver Structure

#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/of.h>

struct my_device {
    struct device *dev;
    void __iomem *base;
    /* Device-specific fields */
};

static int my_probe(struct platform_device *pdev)
{
    struct my_device *priv;
    struct resource *res;
    int ret;

    priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
    if (!priv)
        return -ENOMEM;

    priv->dev = &pdev->dev;
    platform_set_drvdata(pdev, priv);

    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    priv->base = devm_ioremap_resource(&pdev->dev, res);
    if (IS_ERR(priv->base))
        return PTR_ERR(priv->base);

    /* Device initialization */

    return 0;
}

static int my_remove(struct platform_device *pdev)
{
    /* Cleanup handled by devm_* */
    return 0;
}

static const struct of_device_id my_of_match[] = {
    { .compatible = "vendor,device" },
    { }
};
MODULE_DEVICE_TABLE(of, my_of_match);

static struct platform_driver my_driver = {
    .probe = my_probe,
    .remove = my_remove,
    .driver = {
        .name = "my-driver",
        .of_match_table = my_of_match,
    },
};
module_platform_driver(my_driver);

MODULE_DESCRIPTION("My device driver");
MODULE_AUTHOR("Author Name");
MODULE_LICENSE("GPL");

Error Handling with dev_err_probe()

static int my_probe(struct platform_device *pdev)
{
    struct clk *clk;

    clk = devm_clk_get(&pdev->dev, NULL);
    if (IS_ERR(clk))
        return dev_err_probe(&pdev->dev, PTR_ERR(clk),
                           "Failed to get clock\n");

    /* Continue probe */
}

Interrupt Handler

static irqreturn_t my_irq_handler(int irq, void *data)
{
    struct my_device *priv = data;
    u32 status;

    status = readl(priv->base + STATUS_REG);
    if (!(status & IRQ_PENDING))
        return IRQ_NONE;

    /* Handle interrupt */
    writel(status, priv->base + STATUS_REG); /* Clear */

    return IRQ_HANDLED;
}

static int my_probe(struct platform_device *pdev)
{
    int irq, ret;

    irq = platform_get_irq(pdev, 0);
    if (irq < 0)
        return irq;

    ret = devm_request_irq(&pdev->dev, irq, my_irq_handler,
                          0, dev_name(&pdev->dev), priv);
    if (ret)
        return dev_err_probe(&pdev->dev, ret,
                           "Failed to request IRQ\n");
}

Remember: The kernel is unforgiving - a single bug can crash the entire system. Always prioritize safety and correctness over cleverness.