linux驅動鎖

Ⅰ linux設備驅動中的並發

並發就是多個執行單元或多個進程並行執行，而這多個執行單元對資源進行共享，比如訪問同一個變數或同一個硬體資源，這個時候就很容易出現競態(說簡單點就是競爭同一個」女朋友」)。

為了處理並發帶來的問題，Linux有幾種處理方法:
1. 中斷屏蔽
2. 原子操作
3. 自旋鎖
4. 信號量
5. 互斥體
6. 完成量

以上幾種處理並發的方式各有利弊，需要根據實際情況來選擇使用哪一種。

它的原理就是讓CPU不響應中斷，一般使用這種方法的要求代碼段要比較少，不能佔用大量的時間。一般在驅動中不推薦使用這種方式。

原子量保證對一個整形數據的操作是排他性的。就是該操作絕不會在執行完畢前被任何其他任務或事件打斷。

自旋鎖是一種典型的對臨界資源進行互斥訪問的手段。當一個自旋鎖已經被其他線程持有，而另一個線程試圖去獲取自旋鎖，這時候就會一直在那裡等待(原地自旋等待)。如果遞歸調用自旋鎖，就會導致系統死鎖。

與自旋鎖不同的是，當獲取不到信號量時，進程不會原地打轉而是進入休眠等待狀態。新的Linux內核傾向於直接使用mutex作為互斥手段，信號量用作互斥不再被推薦使用。

當進程佔用資源時間較長時，用互斥體會比較好。

使用方法：

完成量的機制是實現一個線程發送一個信號通知另一個線程完成某個任務。一個線程調用wait_for_completion後就進入休眠，另一個線程執行完某個任務後就發送通知給進入休眠的線程，然後它就執行wait_for_completion後面的代碼。

Ⅱ linux內核同步問題

Linux內核設計與實現 十、內核同步方法

手把手教Linux驅動5-自旋鎖、信號量、互斥體概述

== 基礎概念： ==

並發 ：多個執行單元同時進行或多個執行單元微觀串列執行，宏觀並行執行

競態 ：並發的執行單元對共享資源（硬體資源和軟體上的全局變數）的訪問而導致的竟態狀態。

臨界資源 ：多個進程訪問的資源

臨界區 ：多個進程訪問的代碼段

== 並發場合： ==

1、單CPU之間進程間的並發 :時間片輪轉，調度進程。 A進程訪問列印機，時間片用完，OS調度B進程訪問列印機。

2、單cpu上進程和中斷之間並發 ：CPU必須停止當前進程的執行中斷;

3、多cpu之間

4、單CPU上中斷之間的並發

== 使用偏向： ==

==信號量用於進程之間的同步，進程在信號量保護的臨界區代碼裡面是可以睡眠的（需要進行進程調度），這是與自旋鎖最大的區別。==

信號量又稱為信號燈，它是用來協調不同進程間的數據對象的，而最主要的應用是共享內存方式的進程間通信。本質上，信號量是一個計數器，它用來記錄對某個資源（如共享內存）的存取狀況。它負責協調各個進程，以保證他們能夠正確、合理的使用公共資源。它和spin lock最大的不同之處就是：無法獲取信號量的進程可以睡眠，因此會導致系統調度。

1、==用於進程與進程之間的同步==

2、==允許多個進程進入臨界區代碼執行，臨界區代碼允許睡眠；==

3、信號量本質是==基於調度器的==，在UP和SMP下沒有區別；進程獲取不到信號量將陷入休眠，並讓出CPU；

4、不支持進程和中斷之間的同步

5、==進程調度也是會消耗系統資源的，如果一個int型共享變數就需要使用信號量，將極大的浪費系統資源==

6、信號量可以用於多個線程，用於資源的計數（有多種狀態）

==信號量加鎖以及解鎖過程：==

sema_init(&sp->dead_sem, 0); / 初始化 /

down(&sema);

臨界區代碼

up(&sema);

==信號量定義：==

==信號量初始化：==

==dowm函數實現：==

==up函數實現：==

信號量一般可以用來標記可用資源的個數。

舉2個生活中的例子：

==dowm函數實現原理解析：==

（1）down

判斷sem->count是否 > 0，大於0則說明系統資源夠用，分配一個給該進程，否則進入__down(sem);

（2）__down

調用__down_common(sem, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);其中TASK_UNINTERRUPTIBLE=2代表進入睡眠，且不可以打斷；MAX_SCHEDULE_TIMEOUT休眠最長LONG_MAX時間；

（3）list_add_tail(&waiter.list, &sem->wait_list);

把當前進程加入到sem->wait_list中；

（3）先解鎖後加鎖;

進入__down_common前已經加鎖了，先把解鎖，調用schele_timeout(timeout)，當waiter.up=1後跳出for循環；退出函數之前再加鎖；

Linux內核ARM構架中原子變數的底層實現研究

rk3288 原子操作和原子位操作

原子變數適用於只共享一個int型變數；

1、原子操作是指不被打斷的操作，即它是最小的執行單位。

2、最簡單的原子操作就是一條條的匯編指令(不包括一些偽指令，偽指令會被匯編器解釋成多條匯編指令)

==常見函數：==

==以atomic_inc為例介紹實現過程==

在Linux內核文件archarmincludeasmatomic.h中。 執行atomic_read、atomic_set這些操作都只需要一條匯編指令，所以它們本身就是不可打斷的。 需要特別研究的是atomic_inc、atomic_dec這類讀出、修改、寫回的函數。

所以atomic_add的原型是下面這個宏：

atomic_add等效於：

result（%0） tmp（%1） (v->counter)（%2） (&v->counter)（%3） i（%4）

注意：根據內聯匯編的語法，result、tmp、&v->counter對應的數據都放在了寄存器中操作。如果出現上下文切換，切換機制會做寄存器上下文保護。

（1）ldrex %0, [%3]

意思是將&v->counter指向的數據放入result中，並且（分別在Local monitor和Global monitor中）設置獨占標志。

（2）add %0, %0, %4

result = result + i

（3）strex %1, %0, [%3]

意思是將result保存到&v->counter指向的內存中， 此時 Exclusive monitors會發揮作用，將保存是否成功的標志放入tmp中。

（4） teq %1, #0

測試strex是否成功（tmp == 0 ？？）

（5）bne 1b

如果發現strex失敗，從（1）再次執行。

Spinlock 是內核中提供的一種比較常見的鎖機制，==自旋鎖是「原地等待」的方式解決資源沖突的==，即，一個線程獲取了一個自旋鎖後，另外一個線程期望獲取該自旋鎖，獲取不到，只能夠原地「打轉」（忙等待）。由於自旋鎖的這個忙等待的特性，註定了它使用場景上的限制 —— 自旋鎖不應該被長時間的持有（消耗 CPU 資源），一般應用在==中斷上下文==。

1、spinlock是一種死等機制

2、信號量可以允許多個執行單元進入，spinlock不行，一次只能允許一個執行單元獲取鎖，並且進入臨界區，其他執行單元都是在門口不斷的死等

3、由於不休眠，因此spinlock可以應用在中斷上下文中；

4、由於spinlock死等的特性，因此臨界區執行代碼盡可能的短；

==spinlock加鎖以及解鎖過程：==

spin_lock(&devices_lock);

臨界區代碼

spin_unlock(&devices_lock);

==spinlock初始化==

==進程和進程之間同步==

==本地軟中斷之間同步==

==本地硬中斷之間同步==

==本地硬中斷之間同步並且保存本地中斷狀態==

==嘗試獲取鎖==

== arch_spinlock_t結構體定義如下： ==

== arch_spin_lock的實現如下： ==

lockval（%0） newval（%1） tmp（%2） &lock->slock（%3） 1 << TICKET_SHIFT（%4）

（1）ldrex %0, [%3]

把lock->slock的值賦值給lockval；並且（分別在Local monitor和Global monitor中）設置獨占標志。

（2）add %1, %0, %4

newval =lockval +（1<<16）; 相當於next+1；

（3）strex %2, %1, [%3]

newval =lockval +（1<<16）; 相當於next+1；

意思是將newval保存到 &lock->slock指向的內存中， 此時 Exclusive monitors會發揮作用，將保存是否成功的標志放入tmp中。

（4） teq %2, #0

測試strex是否成功

（5）bne 1b

如果發現strex失敗，從（1）再次執行。

通過上面的分析，可知關鍵在於strex的操作是否成功的判斷上。而這個就歸功於ARM的Exclusive monitors和ldrex/strex指令的機制。

（6）while (lockval.tickets.next != lockval.tickets.owner)

如何lockval.tickets的next和owner是否相等。相同則跳出while循環，否則在循環內等待判斷；

* （7）wfe()和smp_mb() 最終調用#define barrier() asm volatile ("": : :"memory") *

阻止編譯器重排，保證編譯程序時在優化屏障之前的指令不會在優化屏障之後執行。

== arch_spin_unlock的實現如下： ==

退出鎖時：tickets.owner++

== 出現死鎖的情況： ==

1、擁有自旋鎖的進程A在內核態阻塞了，內核調度B進程，碰巧B進程也要獲得自旋鎖，此時B只能自旋轉。 而此時搶占已經關閉，（單核）不會調度A進程了，B永遠自旋，產生死鎖。

2、進程A擁有自旋鎖，中斷到來，CPU執行中斷函數，中斷處理函數，中斷處理函數需要獲得自旋鎖，訪問共享資源，此時無法獲得鎖，只能自旋，產生死鎖。

== 如何避免死鎖： ==

1、如果中斷處理函數中也要獲得自旋鎖，那麼驅動程序需要在擁有自旋鎖時禁止中斷；

2、自旋鎖必須在可能的最短時間內擁有

3、避免某個獲得鎖的函數調用其他同樣試圖獲取這個鎖的函數，否則代碼就會死鎖；不論是信號量還是自旋鎖，都不允許鎖擁有者第二次獲得這個鎖，如果試圖這么做，系統將掛起；

4、鎖的順序規則（a) 按同樣的順序獲得鎖；b) 如果必須獲得一個局部鎖和一個屬於內核更中心位置的鎖，則應該首先獲取自己的局部鎖 ;c) 如果我們擁有信號量和自旋鎖的組合，則必須首先獲得信號量；在擁有自旋鎖時調用down(可導致休眠)是個嚴重的錯誤的；）

== rw（read/write）spinlock： ==

加鎖邏輯：

1、假設臨界區內沒有任何的thread，這個時候任何的讀線程和寫線程都可以鍵入

2、假設臨界區內有一個讀線程，這時候信賴的read線程可以任意進入，但是寫線程不能進入；

3、假設臨界區有一個寫線程，這時候任何的讀、寫線程都不可以進入；

4、假設臨界區內有一個或者多個讀線程，寫線程不可以進入臨界區，但是寫線程也無法阻止後續的讀線程繼續進去，要等到臨界區所有的讀線程都結束了，才可以進入，可見：==rw（read/write）spinlock更加有利於讀線程；==

== seqlock（順序鎖）： ==

加鎖邏輯：

1、假設臨界區內沒有任何的thread，這個時候任何的讀線程和寫線程都可以鍵入

2、假設臨界區內沒有寫線程的情況下，read線程可以任意進入；

3、假設臨界區有一個寫線程，這時候任何的讀、寫線程都不可以進入；

4、假設臨界區內只有read線程的情況下，寫線程可以理解執行，不會等待，可見：==seqlock（順序鎖）更加有利於寫線程；==

讀寫速度 ： CPU > 一級緩存 > 二級緩存 > 內存 ，因此某一個CPU0的lock修改了，其他的CPU的lock就會失效；那麼其他CPU就會依次去L1 L2和主存中讀取lock值，一旦其他CPU去讀取了主存，就存在系統性能降低的風險；

mutex用於互斥操作。

互斥體只能用於一個線程，資源只有兩種狀態（佔用或者空閑）

1、mutex的語義相對於信號量要簡單輕便一些，在鎖爭用激烈的測試場景下，mutex比信號量執行速度更快，可擴展

性更好，

2、另外mutex數據結構的定義比信號量小;、

3、同一時刻只有一個線程可以持有mutex

4、不允許遞歸地加鎖和解鎖

5、當進程持有mutex時，進程不可以退出。

• mutex必須使用官方API來初始化。

• mutex可以睡眠，所以不允許在中斷處理程序或者中斷下半部中使用，例如tasklet、定時器等

==常見操作：==

struct mutex mutex_1;

mutex_init(&mutex_1);

mutex_lock(&mutex_1)

臨界區代碼；

mutex_unlock(&mutex_1)

==常見函數：==

=

Ⅲ linux怎麼控制電控門鎖

光耦輸出電流最多也就幾十毫安，8050大約能達到0.5A。 都需要增加驅動能力。 下圖繼電器吸合時間約為100mS，如果不合適可以調節電阻電容值

Ⅳ Linux下各種鎖的理解和使用及總結解決epoll驚群問題(面試常考)-

鎖出現的原因

臨界資源是什麼: 多線程執行流所共享的資源

鎖的作用是什麼, 可以做原子操作, 在多線程中針對臨界資源的互斥訪問... 保證一個時刻只有一個線程可以持有鎖對於臨界資源做修改操作...

任何一個線程如果需要修改，向臨界資源做寫入操作都必須持有鎖，沒有持有鎖就不能對於臨界資源做寫入操作.

鎖 ： 保證同一時刻只能有一個線程對於臨界資源做寫入操作 (鎖地功能)

再一個直觀地代碼引出問題，再從指令集的角度去看問題

上述一個及其奇怪的結果，這個結果每一次運行都可能是不一樣的，Why ？ 按照我們本來的想法是每一個線程 + 20000000 結果肯定應該是60000000呀，可以就是達不到這個值

為何？ (深入匯編指令來看) 一定將過程放置到匯編指令上去看就可以理解這個過程了.

a++; 或者 a += 1; 這些操作的匯編操作是幾個步驟?

其實是三個步驟：

正常情況下，數據少，操作的線程少，問題倒是不大，想一想要是這樣的情況下，操作次數大，對齊操作的線程多，有些線程從中間切入進來了，在運算之後還沒寫回內存就另外一個線程切入進來同時對於之前的數據進行++ 再寫回內存, 啥效果，多次++ 操作之後結果確實一次加加操作後的結果。 這樣的操作 (術語叫做函數的重入) 我覺得其實就是重入到了匯編指令中間了，還沒將上一次運算的結果寫回內存就重新對這個內存讀取再運算寫入，結果肯定和正常的邏輯後的結果不一樣呀

來一幅圖片解釋一下

咋辦? 其實問題很清楚，我們只需要處理的是多條匯編指令不能讓它中間被插入其他的線程運算. （要想自己在執行匯編指令的時候別人不插入進來） 將多條匯編指令綁定成為一條指令不就OK了嘛。

也就是原子操作！！！

不會原子操作？操作系統給咱提供了線程的 綁定方式工具呀：mutex 互斥鎖(互斥量)， 自旋鎖(spinlock)， 讀寫鎖（readers-writer lock） 他們也稱作悲觀鎖. 作用都是一個樣，將多個匯編指令鎖成為一條原子操作 (此處的匯編指令也相當於如下的臨界資源)

悲觀鎖：鎖如其名，每次都悲觀地認為其他線程也會來修改數據，進行寫入操作，所以會在取數據前先加鎖保護，當其他線程想要訪問數據時，被阻塞掛起

樂觀鎖：每次取數據的時候，總是樂觀地認為數據不會被其他線程修改，因此不上鎖。但是在更新數據前， 會判斷其他數據在更新前有沒有對數據進行修改。

互斥鎖

最為常見使用地鎖就是互斥鎖, 也稱互斥量. mutex

特徵，當其他線程持有互斥鎖對臨界資源做寫入操作地時候，當前線程只能掛起等待，讓出CPU，存在線程間切換工作

解釋一下存在線程間切換工作 : 當線程試圖去獲取鎖對臨界資源做寫入操作時候，如果鎖被別的線程正在持有，該線程會保存上下文直接掛起，讓出CPU，等到鎖被釋放出來再進行線程間切換，從新持有CPU執行寫入操作

互斥鎖需要進行線程間切換，相比自旋鎖而言性能會差上許多，因為自旋鎖不會讓出CPU, 也就不需要進行線程間切換的步驟，具體原理下一點詳述

加互斥量(互斥鎖)確實可以達到要求，但是會發現運行時間非常的長，因為線程間不斷地切換也需要時間, 線程間切換的代價比較大.

相關視頻推薦

你繞不開的組件—鎖，4個方面手撕鎖的多種實現

「驚群」原理、鎖的設計方案及繞不開的「死鎖」問題

學習地址：C/C++Linux伺服器開發/後台架構師【零聲教育】-學習視頻教程-騰訊課堂

需要C/C++ Linux伺服器架構師學習資料加qun812855908獲取（資料包括 C/C++，Linux，golang技術，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒體，CDN，P2P，K8S，Docker，TCP/IP，協程，DPDK，ffmpeg 等），免費分享

自旋鎖

spinlock.自旋鎖.

對比互斥量(互斥鎖)而言，獲取自旋鎖不需要進行線程間切換，如果自旋鎖正在被別的線程佔用，該線程也不會放棄CPU進行掛起休眠，而是恰如其名的在哪裡不斷地循環地查看自旋鎖保持者(持有者)是否將自旋鎖資源釋放出來... （自旋地原來就是如此）

口語解釋自旋：持有自旋鎖的線程不釋放自旋鎖，那也沒有關系呀，我就在這里不斷地一遍又一遍地查詢自旋鎖是否釋放出來，一旦釋放出來我立馬就可以直接使用 (因為我並沒有掛起等待，不需要像互斥鎖還需要進行線程間切換，重新獲取CPU，保存恢復上下文等等操作)

哪正是因為上述這些特點，線程嘗試獲取自旋鎖，獲取不到不會採取休眠掛起地方式，而是原地自旋（一遍又一遍查詢自旋鎖是否可以獲取）效率是遠高於互斥鎖了. 那我們是不是所有情況都使用自旋鎖就行了呢，互斥鎖就可以放棄使用了嗎????

解釋自旋鎖地弊端：如果每一個線程都僅僅只是需要短時間獲取這個鎖，那我自旋占據CPU等待是沒啥問題地。要是線程需要長時間地使用占據（鎖）。。。 會造成過多地無端占據CPU資源，俗稱站著茅坑不拉屎... 但是要是僅僅是短時間地自旋，平衡CPU利用率 + 程序運行效率 （自旋鎖確實是在有些時候更加合適）

自旋鎖需要場景：內核可搶占或者SMP(多處理器)情況下才真正需求 (避免死鎖陷入死循環，瘋狂地自旋，比如遞歸獲取自旋鎖. 你獲取了還要獲取，但是又沒法釋放)

自旋鎖的使用函數其實和互斥鎖幾乎是一摸一樣地，僅僅只是需要將所有的mutex換成spin即可

僅僅只是在init存在些許不同

何為驚群，池塘一堆, 我瞄準一條插過去，但是好似所有的都像是覺著自己正在被插一樣的四處逃竄。 這個就是驚群的生活一點的理解

驚群現象其實一點也不少，比如說 accept pthread_cond_broadcast 還有多個線程共享epoll監視一個listenfd 然後此刻 listenfd 說來 SYN了，放在了SYN隊列中，然後完成了三次握手放在了 accept隊列中了, 現在問題是這個connect我應該交付給哪一個線程處理呢.

多個epoll監視准備工作的線程 就是這群 ()，然後connet就是魚叉，這一叉下去肯定是所有的 epoll線程都會被驚醒 (多線程共享listenfd引發的epoll驚群)

同樣如果將上述的多個線程換成多個進程共享監視 同一個 listenfd 就是(多進程的epoll驚群現象)

咱再畫一個草圖再來理解一下這個驚群:

如果是多進程道理是一樣滴，僅僅只是將所有的線程換成進程就OK了

終是來到了今天的正題了: epoll驚群問題地解決上面了...

首先 先說說accept的驚群問題，沒想到吧accept 平時大家寫它的多線程地時候，多個線程同時accept同一個listensock地時候也是會存在驚群問題地，但是accept地驚群問題已經被Linux內核處理了: 當有新的連接進入到accept隊列的時候，內核喚醒且僅喚醒一個進程來處理

但是對於epoll的驚群問題，內核卻沒有直接進行處理。哪既然內核沒有直接幫我們處理，我們應該如何針對這種現象做出一定的措施呢?

驚群效應帶來的弊端: 驚群現象會造成epoll的偽喚醒，本來epoll是阻塞掛起等待著地，這個時候因為掛起等待是不會佔用CPU地。。。 但是一旦喚醒就會佔用CPU去處理發生地IO事件， 但是其實是一個偽喚醒，這個就是對於線程或者進程的無效調度。然而進程或者線程地調取是需要花費代價地，需要上下文切換。需要進行進程(線程)間的不斷切換... 本來多核CPU是用來支持高並發地，但是現在卻被用來無效地喚醒，對於多核CPU簡直就是一種浪費 （浪費系統資源） 還會影響系統的性能.

解決方式（一般是兩種）

Nginx的解決方式:

加鎖：驚群問題發生的前提是多個進程（線程）監聽同一個套接字(listensock)上的事件，所以我們只讓一個進程（線程）去處理監聽套接字就可以了。

畫兩張圖來理解一下：

上述還沒有進行一個每一個進程都對應一個listensock 而是多線程共享一個listensock 運行結果如下

所有的線程同時被喚醒了，但是實際上會處理連接的僅僅只是一個線程，

咱僅僅只是將主線程做如上這樣一個簡單的修改，每一個線程對應一個listensock；每一個線程一個獨有的監視窗口，將問題拋給內核去處理，讓內核去負載均衡 ： 結果如下

僅僅喚醒一個線程來進行處理連接，解決了驚群問題

本文通過介紹兩種鎖入手，以及為什麼需要鎖，鎖本質就是為了保護，持有鎖你就有權力有能力操作寫入一定的臨界保護資源，沒有鎖你就不行需要等待，本質其實是將多條匯編指令綁定成原子操作

然後介紹了驚群現象，通過一個巧妙地例子，扔一顆石子，只是瞄準一條魚扔過去了，但是整池魚都被驚醒了，

對應我們地實際問題就是， 多個線程或者進程共同監視同一個listensock。。。。然後IO連接事件到來地時候本來僅僅只是需要一個線程醒過來處理即可，但是卻會使得所有地線程（進程）全部醒過來，造成不必要地進程線程間切換，多核CPU被浪費喔，系統資源被浪費

處理方式 一。 Nginx 源碼加互斥鎖處理。。 二。設置SO_REUSEPORT, 使得多個進程線程可以同時連接同一個port , 為每一個進程線程搞一個listensock... 將問題拋給內核去處理，讓他去負載均衡地僅僅將IO連接事件分配給一個進程或線程

Ⅳ 求《Linux設備驅動開發詳解4.0》全文免費下載百度網盤資源,謝謝~

《Linux設備驅動開發詳解4.0》網路網盤pdf最新全集下載:
鏈接: https://pan..com/s/1wxaYK87l11FDur15aS6FTQ

Ⅵ 怎麼學習嵌入式linux下的驅動編寫

1、 編寫Linux設備驅動要求工程師有非常好的硬體基礎，懂得SRAM、Flash、SDRAM、磁碟的讀寫方式，UART、I2C、USB等設備的介面以及輪詢、中斷、DMA的原理，PCI匯流排的工作方式以及CPU的內存管理單元（MMU）等。
2、編寫Linux設備驅動要求工程師有非常好的C語言基礎，能靈活地運用C語言的結構體、指針、函數指針及內存動態申請和釋放等。
3、編寫Linux設備驅動要求工程師有一定的Linux內核基礎，雖然並不要求工程師對內核各個部分有深入的研究，但至少要明白驅動與內核的介面。尤其是對於塊設備、網路設備、Flash設備、串口設備等復雜設備，內核定義的驅動體系架構本身就非常復雜。
4、編寫Linux設備驅動要求工程師有非常好的多任務並發控制和同步的基礎，因為在驅動中會大量使用自旋鎖、互斥、信號 量、等待隊列等並發與同步機制。

Ⅶ linux驅動里 mutex_lock(&amp;amp;tty_mutex)有什麼作用

mutex_lock是用來保護資源。
比如某一個變數，多個函數都會對該變數進行操作，
為了保證在同一時間，只能有同一個函數對該變數的操作，
需要對該變數進行加鎖和解鎖操作，用來防止不可預知的錯誤。

多線程，多進程中更應該如此。

希望對你有幫助！

Ⅷ Linux字元設備驅動的組成

在Linux中，字元設備驅動由如下幾個部分組成。
1.字元設備驅動模塊載入與卸載函數
在字元設備驅動模塊載入函數中應該實現設備號的申請和cdev的注冊，而在卸載函數中應實現設備號
的釋放和cdev的注銷。
Linux內核的編碼習慣是為設備定義一個設備相關的結構體，該結構體包含設備所涉及的cdev、私有
數據及鎖等信息。2.字元設備驅動的file_operations結構體中的成員函數
file_operations結構體中的成員函數是字元設備驅動與內核虛擬文件系統的介面，是用戶空間對Linux
進行系統調用最終的落實者。設備驅動的讀函數中，filp是文件結構體指針，buf是用戶空間內存的地址，該地址在內核空間不宜直
接讀寫，count是要讀的位元組數，f_pos是讀的位置相對於文件開頭的偏移。
設備驅動的寫函數中，filp是文件結構體指針，buf是用戶空間內存的地址，該地址在內核空間不宜直
接讀寫，count是要寫的位元組數，f_pos是寫的位置相對於文件開頭的偏移。
由於用戶空間不能直接訪問內核空間的內存，因此藉助了函數_from_user（）完成用戶空間緩沖
區到內核空間的復制，以及_to_user（）完成內核空間到用戶空間緩沖區的復制，見代碼第6行和第14
行。
完成內核空間和用戶空間內存復制的_from_user（）和_to_user（）的原型分別為：
unsigned long _from_user(void *to, const void _ _user *from, unsigned long count);
unsigned long _to_user(void _ _user *to, const void *from, unsigned long count);
上述函數均返回不能被復制的位元組數，因此，如果完全復製成功，返回值為0。如果復制失敗，則返
回負值。如果要復制的內存是簡單類型，如char、int、long等，則可以使用簡單的put_user（）和
get_user（）讀和寫函數中的_user是一個宏，表明其後的指針指向用戶空間，實際上更多地充當了代碼自注釋的
功能。內核空間雖然可以訪問用戶空間的緩沖區，但是在訪問之前，一般需要先檢查其合法性，通過
access_ok（type，addr，size）進行判斷，以確定傳入的緩沖區的確屬於用戶空間。