Penjelasan terperinci tentang pemasa kernel Linux dan pembangunan pemacu kerja kelewatan

Pemasa kernel Linux dan kerja kelewatan ialah dua mekanisme yang biasa digunakan untuk melaksanakan tugas berjadual dan tugas pelaksanaan tertunda. Ia membenarkan pemandu melaksanakan fungsi tertentu pada titik masa yang sesuai untuk menyesuaikan diri dengan keperluan dan ciri peranti perkakasan. Tetapi bagaimana anda menggunakan pemasa kernel Linux dengan betul untuk bekerja dengan kelewatan? Artikel ini akan memperkenalkan pengetahuan dan kemahiran asas pemasa kernel Linux dan pembangunan pemacu kerja kelewatan dari kedua-dua aspek teori dan praktikal, serta beberapa masalah dan penyelesaian biasa.

Pemasa kernel

Pemasa pada perisian akhirnya bergantung pada jam perkakasan Secara ringkasnya, kernel akan mengesan sama ada setiap pemasa yang didaftarkan kepada kernel telah tamat tempoh selepas gangguan jam berlaku, ia akan memanggil semula fungsi pendaftaran yang sepadan dan menyimpannya . Malah, pengendali gangguan jam mencetuskan gangguan lembut TIMER_SOFTIRQ dan menjalankan semua pemasa yang telah tamat tempoh pada pemproses semasa.
Pemacu peranti yang ingin mendapatkan maklumat masa dan memerlukan perkhidmatan pemasaan boleh menggunakan pemasa kernel.

jiffies

Untuk bercakap tentang pemasa kernel, kita mesti bercakap tentang konsep penting masa dalam kernel: pembolehubah jiffies, sebagai asas jam kernel, jiffies akan meningkat sebanyak 1 setiap masa tetap, yang dipanggil menambah rentak . , selang tetap ini dilaksanakan oleh gangguan pemasa. HZ. Bilangan saat sejak sistem dimulakan. Dua saat seterusnya ialah (jiffies/HZ+2). : (jiffies/HZ +2)*HZ=jiffies+2*HZJika anda ingin mendapatkan masa semasa, anda boleh menggunakan **do_gettimeofday()** Fungsi ini mengisi struktur timeval struct dengan resolusi yang hampir dengan halus.

//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)   

Untuk membolehkan perkakasan cukup masa untuk menyelesaikan beberapa tugas, pemandu selalunya perlu menangguhkan pelaksanaan kod tertentu untuk satu tempoh masa Bergantung pada tempoh kelewatan, dua jenis, kelewatan lama dan kelewatan pendek. , digunakan dalam konsep kernel. Takrif kelewatan lama ialah: masa kelewatan > beberapa kejap Untuk mencapai kelewatan yang lama, anda boleh menggunakan kaedah menanya kejap:

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

**Definisi kelewatan pendek ialah: peristiwa kelewatan hampir atau lebih pendek daripada satu sekejap Untuk mencapai kelewatan yang singkat, anda boleh menghubungi

udelay();
mdelay();

Kedua-dua fungsi adalah fungsi menunggu yang sibuk, yang menggunakan banyak masa CPU yang pertama menggunakan gelung perisian untuk melambatkan bilangan mikrosaat tertentu, dan yang kedua menggunakan sarang yang pertama untuk mencapai kelewatan tahap milisaat.

Pemasa

Pemandu boleh mendaftar pemasa kernel untuk menentukan fungsi yang akan dilaksanakan pada masa tertentu pada masa hadapan. Pemasa mula mengira apabila ia didaftarkan ke kernel, dan fungsi berdaftar akan dilaksanakan selepas masa yang ditentukan dicapai. Iaitu, nilai tamat masa ialah nilai jiffies Apabila nilai jiffies lebih besar daripada pemasa-> tamat tempoh, fungsi pemasa-> akan dilaksanakan. API adalah seperti berikut

//定一个定时器
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);

Instance

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;
}

Kerja tertangguh

Selain menggunakan pemasa kernel untuk menyelesaikan kerja kelewatan berjadual, kernel Linux juga menyediakan set "pintasan" berkapsul -

kerja_tertunda

, yang serupa dengan pemasa kernel Intipatinya juga dilaksanakan menggunakan baris gilir kerja dan pemasa.

//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领域的进一步学习和工作打下坚实的基础。

Atas ialah kandungan terperinci Penjelasan terperinci tentang pemasa kernel Linux dan pembangunan pemacu kerja kelewatan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!