리눅스 커널에서 자는 방법?

리눅스 커널에서 자는 방법?

msleep() 함수를 사용하여 커널 공간에서 지정된 시간 동안 잠을 잘 수 있습니까?그렇다면 어떤 헤더 파일을 포함해야 합니까?#include <linux/time.h>맞는 것 같지 않아요이 목적을 위해 더 나은 기능이 있을까요?

나는 포함시킬 필요가 있었습니다.<linux/delay.h>커널 공간에서 msleep을 사용합니다.

리눅스 커널 설명서

Documentation/timers/timers-howto에 있는 Linux 커널 설명서입니다.txt에는 다음과 같은 주요 방법이 있습니다.

Inserting Delays
----------------

The first, and most important, question you need to ask is "Is my
code in an atomic context?"  This should be followed closely by "Does
it really need to delay in atomic context?" If so...

ATOMIC CONTEXT:
    You must use the *delay family of functions. These
    functions use the jiffie estimation of clock speed
    and will busy wait for enough loop cycles to achieve
    the desired delay:

    ndelay(unsigned long nsecs)
    udelay(unsigned long usecs)
    mdelay(unsigned long msecs)

    udelay is the generally preferred API; ndelay-level
    precision may not actually exist on many non-PC devices.

    mdelay is macro wrapper around udelay, to account for
    possible overflow when passing large arguments to udelay.
    In general, use of mdelay is discouraged and code should
    be refactored to allow for the use of msleep.

NON-ATOMIC CONTEXT:
    You should use the *sleep[_range] family of functions.
    There are a few more options here, while any of them may
    work correctly, using the "right" sleep function will
    help the scheduler, power management, and just make your
    driver better :)

    -- Backed by busy-wait loop:
        udelay(unsigned long usecs)
    -- Backed by hrtimers:
        usleep_range(unsigned long min, unsigned long max)
    -- Backed by jiffies / legacy_timers
        msleep(unsigned long msecs)
        msleep_interruptible(unsigned long msecs)

    Unlike the *delay family, the underlying mechanism
    driving each of these calls varies, thus there are
    quirks you should be aware of.


    SLEEPING FOR "A FEW" USECS ( < ~10us? ):
        * Use udelay

        - Why not usleep?
            On slower systems, (embedded, OR perhaps a speed-
            stepped PC!) the overhead of setting up the hrtimers
            for usleep *may* not be worth it. Such an evaluation
            will obviously depend on your specific situation, but
            it is something to be aware of.

    SLEEPING FOR ~USECS OR SMALL MSECS ( 10us - 20ms):
        * Use usleep_range

        - Why not msleep for (1ms - 20ms)?
            Explained originally here:
                http://lkml.org/lkml/2007/8/3/250
            msleep(1~20) may not do what the caller intends, and
            will often sleep longer (~20 ms actual sleep for any
            value given in the 1~20ms range). In many cases this
            is not the desired behavior.

        - Why is there no "usleep" / What is a good range?
            Since usleep_range is built on top of hrtimers, the
            wakeup will be very precise (ish), thus a simple
            usleep function would likely introduce a large number
            of undesired interrupts.

            With the introduction of a range, the scheduler is
            free to coalesce your wakeup with any other wakeup
            that may have happened for other reasons, or at the
            worst case, fire an interrupt for your upper bound.

            The larger a range you supply, the greater a chance
            that you will not trigger an interrupt; this should
            be balanced with what is an acceptable upper bound on
            delay / performance for your specific code path. Exact
            tolerances here are very situation specific, thus it
            is left to the caller to determine a reasonable range.

    SLEEPING FOR LARGER MSECS ( 10ms+ )
        * Use msleep or possibly msleep_interruptible

        - What's the difference?
            msleep sets the current task to TASK_UNINTERRUPTIBLE
            whereas msleep_interruptible sets the current task to
            TASK_INTERRUPTIBLE before scheduling the sleep. In
            short, the difference is whether the sleep can be ended
            early by a signal. In general, just use msleep unless
            you know you have a need for the interrupt

다음과 같은 훌륭한 답변을 바탕으로 조정되었습니다. https://stackoverflow.com/a/39921020/895245

다음으로 소스의 각 기능에 대한 설명서 주석을 살펴봅니다.예: :

/**
 * usleep_range - Sleep for an approximate time
 * @min: Minimum time in usecs to sleep
 * @max: Maximum time in usecs to sleep
 *
 * In non-atomic context where the exact wakeup time is flexible, use
 * usleep_range() instead of udelay().  The sleep improves responsiveness
 * by avoiding the CPU-hogging busy-wait of udelay(), and the range reduces
 * power usage by allowing hrtimers to take advantage of an already-
 * scheduled interrupt instead of scheduling a new one just for this sleep.
 */
void __sched usleep_range(unsigned long min, unsigned long max)

LDD37.3. 실행 지연도 필수 리소스입니다.

실행 가능한 최소 예제

마지막으로 여러분만의 최소한의 시험을 써보세요!

#include <linux/delay.h> /* usleep_range */
#include <linux/kernel.h>
#include <linux/kthread.h>
#include <linux/module.h>

MODULE_LICENSE("GPL");

static struct task_struct *kthread;

static int work_func(void *data)
{
    int i = 0;
    while (!kthread_should_stop()) {
        printk(KERN_INFO "%d\n", i);
        usleep_range(1000000, 1000001);
        i++;
        if (i == 10)
            i = 0;
    }
    return 0;
}

int init_module(void)
{
    kthread = kthread_create(work_func, NULL, "mykthread");
    wake_up_process(kthread);
    return 0;
}

void cleanup_module(void)
{
    /* Waits for thread to return. */
    kthread_stop(kthread);
}

깃허브 업스탐.

언급URL : https://stackoverflow.com/questions/15994603/how-to-sleep-in-the-linux-kernel