Detaillierte Erläuterung des Linux-Kernel-Timers und der Verzögerungsarbeitstreiberentwicklung

Linux-Kernel-Timer und Verzögerungsarbeit sind zwei häufig verwendete Mechanismen zur Implementierung geplanter Aufgaben und verzögerter Ausführungsaufgaben. Sie ermöglichen es dem Treiber, bestimmte Funktionen zum richtigen Zeitpunkt auszuführen, um sich an die Anforderungen und Eigenschaften des Hardwaregeräts anzupassen. Aber wie nutzt man Linux-Kernel-Timer richtig, um mit Verzögerungen umzugehen? In diesem Artikel werden die grundlegenden Kenntnisse und Fähigkeiten der Entwicklung von Linux-Kernel-Timern und Verzögerungsarbeitstreibern aus theoretischer und praktischer Sicht sowie einige häufig auftretende Probleme und Lösungen vorgestellt.

Kernel-Timer

Der Timer der Software hängt letztendlich von der Hardware-Uhr ab. Der Kernel erkennt, ob jeder im Kernel registrierte Timer abgelaufen ist. Wenn er abläuft, ruft er die entsprechende Registrierungsfunktion auf und speichert sie . Wird als Interrupt in der unteren Hälfte ausgeführt. Tatsächlich löst der Clock-Interrupt-Handler den Soft-Interrupt TIMER_SOFTIRQ aus und führt alle Timer aus, die auf dem aktuellen Prozessor abgelaufen sind.
Gerätetreiber, die Zeitinformationen erhalten möchten und Timing-Dienste benötigen, können Kernel-Timer verwenden.

im Handumdrehen

Um über den Kernel-Timer zu sprechen, müssen wir zunächst über ein wichtiges Zeitkonzept im Kernel sprechen: Jiffies-Variable, als Basis der Kernel-Uhr erhöht sich Jiffies zu jeder festgelegten Zeit um 1, was als Hinzufügen eines Taktes bezeichnet wird . Dieses feste Intervall wird durch Timer-Interrupts implementiert, die durch das in HZ definierte Zeitintervall bestimmt werden. HZ. Anzahl der Sekunden seit Systemstart. Die nächsten zwei Sekunden sind (Jiffies/HZ+2). : (jiffies/HZ +2)*HZ=jiffies+2*HZWenn Sie die aktuelle Zeit erhalten möchten, können Sie **do_gettimeofday()** verwenden. Diese Funktion füllt eine struct timeval-Struktur mit einer Auflösung nahe subtil.

//kernel/time/timekeeping.c
 473 /**
 474  * do_gettimeofday - Returns the time of day in a timeval
 475  * @tv:         pointer to the timeval to be set
 476  *
 477  * NOTE: Users should be converted to using getnstimeofday()
 478  */
 479 void do_gettimeofday(struct timeval *tv)   

Um der Hardware genügend Zeit zum Erledigen einiger Aufgaben zu geben, muss der Treiber häufig die Ausführung eines bestimmten Codes um einen bestimmten Zeitraum verzögern, abhängig von der Länge der Verzögerung, zwei Arten: lange Verzögerung und

kurze Verzögerung

, werden in der Kernel-Entwicklung verwendet. Die Definition einer langen Verzögerung lautet: Verzögerungszeit > mehrere Augenblicke. Um eine lange Verzögerung zu erreichen, können Sie die Methode der Abfrage von Augenblicken verwenden:

time_before(jiffies, new_jiffies);
time_after(new_jiffiesmjiffies);

**Die Definition einer kurzen Verzögerung lautet: Das Verzögerungsereignis liegt nahe oder kürzer als ein Augenblick. Um eine kurze Verzögerung zu erreichen, können Sie anrufen

udelay();
mdelay();

Beide Funktionen sind ausgelastete Wartefunktionen, die viel CPU-Zeit beanspruchen. Erstere verwendet Softwareschleifen, um eine bestimmte Anzahl von Mikrosekunden zu verzögern, und letztere nutzt die Verschachtelung der ersteren, um Verzögerungen auf Millisekundenebene zu erreichen.

Timer

Der Treiber kann einen Kernel-Timer registrieren, um eine Funktion anzugeben, die zu einem bestimmten Zeitpunkt in der Zukunft ausgeführt werden soll. Der Timer beginnt mit der Zeitmessung, wenn er beim Kernel registriert ist, und die registrierte Funktion wird ausgeführt, nachdem die angegebene Zeit erreicht ist. Das heißt, der Timeout-Wert ist ein Jiffies-Wert. Wenn der Jiffies-Wert größer als timer->expires ist, wird die timer->function ausgeführt. Die API lautet wie folgt

//定一个定时器
struct timer_list my_timer;

//初始化定时器
void init_timer(struct timer_list *timer);
mytimer.function = my_function;
mytimer.expires = jiffies +HZ;

//增加定时器
void add_timer(struct timer_list *timer);

//删除定时器
int del_tiemr(struct timer_list *timer);

Instanzen

static struct timer_list tm;
struct timeval oldtv;

void callback(unsigned long arg)
{
    struct timeval tv;
    char *strp = (char*)arg;
    do_gettimeofday(&tv);
    printk("%s: %ld, %ld\n", __func__,
        tv.tv_sec - oldtv.tv_sec,
        tv.tv_usec- oldtv.tv_usec);
    oldtv = tv;
    tm.expires = jiffies+1*HZ;
    add_timer(&tm);
}

static int __init demo_init(void)
{
    init_timer(&tm);
    do_gettimeofday(&oldtv);
    tm.function= callback;
    tm.data    = (unsigned long)"hello world";
    tm.expires = jiffies+1*HZ;
    add_timer(&tm);
    return 0;
}

Verzögerte Arbeit

Zusätzlich zur Verwendung des Kernel-Timers zum Abschließen geplanter Verzögerungsarbeiten bietet der Linux-Kernel auch eine Reihe gekapselter „Verknüpfungen“ – delayed_work, die im Wesentlichen dem Kernel-Timer ähneln.

//include/linux/workqueue.h
100 struct work_struct {           
101         atomic_long_t data;
102         struct list_head entry;
103         work_func_t func;
104 #ifdef CONFIG_LOCKDEP
105         struct lockdep_map lockdep_map;
106 #endif
107 };
113 struct delayed_work {              
114         struct work_struct work;
115         struct timer_list timer;
116 
117         /* target workqueue and CPU ->timer uses to queue ->work */
118         struct workqueue_struct *wq;
119         int cpu;
120 };

“

struct work_struct
–103–>需要延迟执行的函数, typedef void (work_func_t)(struct work_struct work);

”

至此，我们可以使用一个delayed_work对象以及相应的调度API实现对指定任务的延时执行

//注册一个延迟执行
591 static inline bool schedule_delayed_work(struct delayed_work *dwork,unsigned long delay)
//注销一个延迟执行
2975 bool cancel_delayed_work(struct delayed_work *dwork)    

和内核定时器一样，延迟执行只会在超时的时候执行一次，如果要实现循环延迟，只需要在注册的函数中再次注册一个延迟执行函数。

schedule_delayed_work(&work,msecs_to_jiffies(poll_interval));

本文从理论和实践两方面，详细介绍了Linux内核定时器与延迟工作驱动开发的基本知识和技巧。我们首先了解了Linux内核定时器与延迟工作的概念、原理、特点和API函数，然后学习了如何使用Linux内核定时器与延迟工作来实现按键事件的检测和处理。最后，我们介绍了一些在Linux内核定时器与延迟工作驱动开发过程中可能遇到的问题，以及相应的解决方法。

通过本文，我们希望能够帮助你掌握Linux内核定时器与延迟工作驱动开发的基本方法和技巧，为你在嵌入式Linux领域的进一步学习和工作打下坚实的基础。

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung des Linux-Kernel-Timers und der Verzögerungsarbeitstreiberentwicklung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!