The rate-limiting algorithm uses two parameters: a burst count (how many messages are allowed immediately) and a time interval (the window after which the counter resets).

Every level has a rate-limited version. They are named by adding _ratelimited:

#include <linux/printk.h>

/* General rate-limited printk */
printk_ratelimited(KERN_WARNING "message\n");

/* Level-specific shortcuts (recommended) */
pr_emerg_ratelimited(fmt, ...);
pr_alert_ratelimited(fmt, ...);
pr_crit_ratelimited(fmt, ...);
pr_err_ratelimited(fmt, ...);
pr_warn_ratelimited(fmt, ...);
pr_notice_ratelimited(fmt, ...);
pr_info_ratelimited(fmt, ...);
pr_debug_ratelimited(fmt, ...);   /* also tied to dynamic debug */

/* Device driver versions */
dev_warn_ratelimited(dev, fmt, ...);
dev_err_ratelimited(dev, fmt, ...);

The defaults baked into these macros are:

• Burst: 10 messages allowed immediately
• Window: 5 seconds before the counter resets

Each macro call site has its own independent counter. If you have two different pr_warn_ratelimited() calls in your code, each one gets its own 10-per-5s budget.

/*
 * Example: a network driver receive function called at high frequency.
 * Without rate limiting this would flood the log.
 */
static int mynic_rx(struct mynic_dev *dev, int budget)
{
    u32 status = read_reg(dev, REG_RX_STATUS);

    if (status & RX_ERR_OVERFLOW) {
        /* This might fire thousands of times per second — rate limit it */
        pr_warn_ratelimited("RX FIFO overflow detected, status=0x%x\n", status);
    }

    if (status & RX_ERR_CRC) {
        /* Separate rate limit from the overflow warning above */
        pr_warn_ratelimited("CRC error on received packet\n");
    }

    return process_packets(dev, budget);
}

Sometimes you want to log a message exactly once and never again — for example, a “deprecated API” warning. Linux provides _once variants for this.

/* Prints exactly once per boot, then never again */
pr_warn_once("Using legacy ioctl interface — please update your application\n");

pr_info_once("Firmware version %s loaded\n", fw_version);

/* Device driver version */
dev_warn_once(&pdev->dev, "Using fallback clock source\n");

Internally, each _once macro uses a static bool flag that is set to true after the first print. Since it is a static variable, it survives for the lifetime of the module. The flag is per-callsite — two different pr_info_once() calls in your code each track independently.

You may find references to these two files in older tutorials:

/proc/sys/kernel/printk_ratelimit        # default: 5
/proc/sys/kernel/printk_ratelimit_burst  # default: 10

Here is the important truth that most tutorials get wrong: these sysctl files do NOT control pr_warn_ratelimited() or printk_ratelimited().

These sysctl files only control a single global ratelimit state used by the legacy printk_ratelimit() function — an old, deprecated function that the kernel itself marks as “don’t use.” Modern rate-limited macros (pr_*_ratelimited, dev_*_ratelimited) each use their own private per-callsite state with the defaults (10 burst / 5 seconds) baked in at compile time. Changing the sysctl files has no effect on them.

The printk API (the macros and log levels you use every day) is unchanged in Linux 6.x. What changed is deep inside — how messages reach the console hardware. This matters to you if you care about latency or are working on PREEMPT_RT.

The old design used a single global lock called console_sem that every CPU had to compete for to push characters to the console. On a system with a slow serial console (9600 baud), one printk call could hold this lock for milliseconds, blocking all other CPUs from printing. This made printk() in hot paths dangerous on real-time kernels.

The nbcon (Non-Blocking CONsole) infrastructure was completed and merged in Linux 6.12. It introduced per-console locking with atomic handover, dedicated printing kthreads, and a new write_thread() / write_atomic() callback model for console drivers. This was the last remaining blocker for merging PREEMPT_RT into the mainline kernel — also merged in 6.12.

What this means for you as a module developer: If your kernel is 6.12 or later with nbcon-enabled consoles, the historical advice “avoid printk in interrupt handlers” is less critical than before. However, rate limiting is still good practice to protect the ring buffer and log files.

Here is a realistic example module that demonstrates correct use of log levels, pr_fmt(), pr_debug(), and rate limiting together.

/*
 * demo_logging.c — demonstrates printk best practices
 * Tested on Linux 6.x
 *
 * Define pr_fmt BEFORE any includes so all pr_*() calls get the prefix.
 */
#define pr_fmt(fmt)  KBUILD_MODNAME ": " fmt

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/timer.h>

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("printk / logging demo for EmbeddedPathashala");
MODULE_AUTHOR("EmbeddedPathashala");

static struct timer_list demo_timer;
static int fire_count = 0;

/*
 * This function is called repeatedly by a timer.
 * It shows rate limiting protecting a high-frequency path.
 */
static void timer_callback(struct timer_list *t)
{
    fire_count++;

    /* This would normally flood the log — rate limited to 10 per 5s */
    pr_warn_ratelimited("timer fired (count=%d) — rate-limited warning\n",
                        fire_count);

    /* Debug message — visible only when dynamic debug enables it */
    pr_debug("timer internal state: count=%d\n", fire_count);

    /* Reschedule after 10ms — fires 100 times per second */
    mod_timer(&demo_timer, jiffies + msecs_to_jiffies(10));
}

static int __init demo_init(void)
{
    /* KERN_INFO — normal startup message */
    pr_info("module loading (version 1.0)\n");

    /* One-time warning — shows once no matter how many times init runs */
    pr_info_once("This message will only appear once per boot\n");

    /* Set up the high-frequency timer */
    timer_setup(&demo_timer, timer_callback, 0);
    mod_timer(&demo_timer, jiffies + msecs_to_jiffies(100));

    pr_info("timer started — will fire 100 times/second\n");
    pr_info("run: dmesg -w   to watch rate-limited output\n");
    pr_info("run: echo 'module demo_logging +p' > /sys/kernel/debug/dynamic_debug/control\n");
    pr_info("     to enable pr_debug() messages\n");

    return 0;
}

static void __exit demo_exit(void)
{
    del_timer_sync(&demo_timer);
    pr_info("module unloaded after %d timer firings\n", fire_count);
}

module_init(demo_init);
module_exit(demo_exit);

To build, create a Makefile:

obj-m := demo_logging.o

# Enable pr_debug() statically (only needed if CONFIG_DYNAMIC_DEBUG is not set)
# ccflags-y += -DDEBUG

all:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

Load and test:

# Build and load
make
sudo insmod demo_logging.ko

# Watch rate-limited output (you'll see the "N callbacks suppressed" messages)
dmesg -w

# Enable the pr_debug() messages at runtime
echo 'module demo_logging +p' | sudo tee /sys/kernel/debug/dynamic_debug/control

# Unload
sudo rmmod demo_logging
dmesg | tail -5