概述

在計算機系統中，變量、中間數據一般存放在系統存儲空間中，只有實際使用的時候才將他們從存儲空間調入到中央處理器內部進行計算。通常存儲空間分為兩類：內部存儲空間和外部存儲空間。對于電腦來講，內部存儲空間就是電腦的內存，外部存儲空間就是電腦的硬盤。而對于單片機來講，內部存儲就是 RAM ，隨機存儲器。外部存儲可以理解為 flash ，掉電不丟失。該篇文章的主題，內存管理，主要討論的是關于 RAM 的管理。

堆、棧和靜態區

針對于 Cortex M3 內核的單片機的詳細內存分配可以參照筆者的這篇文章 STM32 內存分配解析及變量的存儲位置?，在這里不進行贅述，簡單的進行劃分一下，大致可以分為三個部分：靜態區，棧，堆。

• 靜態區：保存全局變量和 static 變量(包括由 static 修飾的全局變量和局部變量)。靜態區的內容在總個程序的生命周期內都存在，由編譯器在編譯的時候進行分配。

• 棧：保存局部變量。棧上的內容只在函數的范圍內存在，當函數運行結束，這些內容也會自動被銷毀。其特點是效率高，但空間大小有限。

• 堆：由 malloc 函數分配的內存。其生命周期由 free 決定，在沒有釋放之前一直存下，直到程序結束。

內存碎片和內存泄漏

涉及到動態內存管理時，會觸及到兩個概念，一個就是內存碎片另一個就是內存泄漏，下面分別闡述著兩個概念。

內存碎片

假設我現在有 16 個字節的空閑內存，如下圖所示：

空閑內存

現在我使用 malloc 分配了四次內存，然后這 16 個字節的內存變成了這樣：

分配之后的內存空間

然后，又使用 free 釋放了三次內存，釋放之后的內存空間是這樣的：

釋放之后的內存空間

在沒有 MMU 的情況下，現在我準備用 malloc 一次性分配 12 個字節的內存空間，雖然上述 16 個字節的內存空間還剩下 13 個字節，但是卻因為內存不是連續的，因此是不能夠進行分配的，這也就是出現內存碎片的原因了。

內存泄漏

內存泄漏產生的原因是當分配時的內存已經不再使用了，但是卻沒有被釋放掉，這個時候，導致內存不夠用，這對于嵌入式設備這種內存極其有限的對象來說是極其有害的。因此，在使用?malloc時，要搭配著?free?來進行使用。

什么時候會使用到堆呢？

靜態區，棧我們我們在編寫程序的時候都會涉及到，定義一個全局變量，就存放在了靜態區，在函數內部定義了一個局部變量，就存放在了棧，那堆呢？堆什么時候會使用到呢？假設現在有這樣一個程序。

int?main(void){
????char?*buffer[3]?=?{NULL};
????char?*string1?=?"hello";
????char?*string2?=?"word";?
????char?*string3?=?"wenzi";

????buffer[0]?=?(char?*)malloc(strlen(string1)?+?1);
????if?(buffer[0]?!=?NULL)
????????strcpy(buffer[0],string1);

????buffer[1]?=?(char?*)malloc(strlen(string2)?+?1);
????if?(buffer[1]?!=?NULL)
????????strcpy(buffer[1],string2);

????buffer[2]?=?(char?*)malloc(strlen(string3)?+?1);
????if?(buffer[2]?!=?NULL)
????????strcpy(buffer[2],string3);?
}

可以看到上述代碼的意思是將string1、string2、string3三個字符串復制到 buffer 所在內存位置，但是這個時候，如果不給數組的元素分配一定大小的內存，那么可能就放不下拷貝進去的字符串，因此在往里面拷貝字符串時，應該提前開辟出一段內存空間出來，這個時候，就需要使用到 malloc 來進行內存分配，當然所對應的，當這個數組使用完之后，需要使用?free來將分配的內存釋放掉，否則就會造成內存泄漏。

單片機如何進行分配內存

在上述介紹的分配內存中，都是使用?malloc來進行分配內存，然后使用?free?來進行釋放內存，但是針對于單片機 RAM 如此緊缺的設備來講，使用 C 標準庫中的內存管理函數是不恰當的，存在著許多弊端，主要有以下幾點：

• 他們的實現可能非常大，占據了相當大的一塊代碼空間

• 這兩個函數會使得鏈接器配置得復雜

• 如果允許堆空間的生長方向覆蓋其他變量的內存，他們會成為 debug 的災難

基于此，正點原子的例程中給出了一種內存管理的方法：分塊式內存管理，實現原理如下圖所示：

分塊式內存管理原理

簡單說明一下，分塊式內存管理由內存池和內存管理表構成。內存池被等分為 n 塊，對應的內存管理表，大小也為 n。內存管理表的每一項對應著內存池的一塊內存。之所以有內存表項的存在，是因為需要通過內存表項表征當前內存塊有沒有被占用，如果對應的內存塊沒有被占用，那么該表項值就為 0 ，非 0 表示該內存塊已經被占用。如果某項值為 10，那么說明本項對應的內存塊在內，總共分配了 10 個內存塊給外部的某個指針。

內存分配原理

當指針 p 調用 malloc 申請內存的時候，先判斷 p 要分配的內存塊數(m)，然后從第 n 項開始，向下查找，直到找到 m 塊連續的空內存塊(即對應內存管理表項為 0)，然后將這 m 個內存管理表項的值都設置為 m(標記被占用)，最后，把最后的這個空內存塊的地址返回指針 p，完成一次分配。注意，如果當內存不夠的時候(找到最后也沒找到連續的 m 塊空閑內存)，則返回 NULL 給 p，表示分配失敗。基于此原理，我們來完成內存分配函數。
首先我們需要定義內存池的大小和內存表的大小：

#define?MEM1_BLOCK_SIZE????????????32?????????//內存塊大小為32字節
#define?MEM1_MAX_SIZE????????????10*1024????//最大管理內存?10K
#define?MEM1_ALLOC_TABLE_SIZE????MEM1_MAX_SIZE/MEM1_BLOCK_SIZE???//內存表大小??

上述中內存表的大小直接用內存池的大小除以內存塊的大小是因為內存管理表和內存塊一一對應的，內存塊的數量也就等于內存池中內存塊的數量。
有了內存池和內存管理表的大小，那么就可以定義內存池和內存管理表了，定義如下所示：

//內存池(32字節對齊)
__align(32)?uint8_t?mem1base[MEM1_MAX_SIZE];????????????????????????????????????????????????????//內部SRAM內存
//內存管理表
uint16_t?mem1mapbase[MEM1_ALLOC_TABLE_SIZE];????????????????????????????????????????????????????//內部SRAM內存池MAP
//內存管理參數???????
const?uint32_t?memtblsize?=?MEM1_ALLOC_TABLE_SIZE;????//內存表大小
const?uint32_t?memblksize?=?MEM1_BLOCK_SIZE;??????????//內存分塊大小
const?uint32_t?memsize?=?MEM1_MAX_SIZE;??????????????????//內存總大小

上述所定義的就是內存池和內存管理表的相關內容，關于內存池采用 32 個字節對齊是因為 內存塊的大小是 32 字節，而且我們從這里也可以看到我們所定義的內存池本質就是一個全局變量的數組，這個數組在編譯時，就被分配了一個固定大小的內存，然后我們會編寫 malloc 函數往這個內存池中去分配內存，緊接著，為了使得程序更加簡潔，我們創建一個結構體，用來存儲內存管理的相關參數：

struct?_m_mallco_dev
{
????void?(*init)(void);??????????//初始化
????uint8_t?(*perused)(void);????//內存使用率
????uint8_t?????*membase;????????//內存池?管理SRAMBANK個區域的內存
????uint16_t?*memmap;????????????//內存管理狀態表
????uint8_t??memrdy;?????????????//內存管理是否就緒
}

可以看到這個結構體包含了兩個函數指針，兩個指針，以及一個普通變量。有了結構體類型之后，我們定義一個變量并初始化如下：

struct?_m_mallco_dev?mallco_dev=
{
????my_mem_init,????????????????//內存初始化
????my_mem_perused,?????????????//內存使用率
????mem1base,???????????????????//內存池
????mem1mapbase,????????????????//內存管理狀態表
????0,??????????????????????????//內存管理未就緒
};

可以看到對與初始化的結構體變量來說，兩個函數指針，指向的分別是內存初始化和內存使用率函數，內存使用率函數不在這里闡述了，需要了解的可以在公眾號底部回復?內存管理獲得內存管理源代碼進行學習。這里闡述一下內存初始化，回顧我們之前定義的內存池，是一個全局變量的數組，因此，這里的初始化實際也就是對于全局數組進行賦 0 操作，代碼如下所示：

void?my_mem_init(void)??{??
????mymemset(mallco_dev.memmap,?0,memtblsize*2);//內存狀態表數據清零??
????mymemset(mallco_dev.membase,?0,memsize);????//內存池所有數據清零??
????mallco_dev.memrdy?=?1;??????????????????????//內存管理初始化OK??
}??

上述的?mymemset函數也不在這里闡述了，可以自行閱讀筆者在公眾號后天給出的源代碼，上述代碼功能也就是對內存池和內存管理表進行賦 0 ，為什么賦 0 時內存管理表的大小要乘以 2 ，是因為內存管理表是的數據是 16 位的，而計算內存管理表的大小時所依據的是 8 位的內存池的數據。
有了初始化，我們就可以根據所要求獲取的內存大小向內存池獲取內存了，下面是內存分配的代碼實現：

uint32_t?my_mem_malloc(uint32_t?size)??
{??
????signed?long?offset=0;??
????uint32_t?nmemb;????//需要的內存塊數??
????uint32_t?cmemb?=?0;//連續空內存塊數
????uint32_t?i;??

????if?(!mallco_dev.memrdy)
????????mallco_dev.init();//未初始化,先執行初始化?
????if?(size?==?0)
????????return?0XFFFFFFFF;//不需要分配

????nmemb?=?size?/?memblksize;??????//獲取需要分配的連續內存塊數
????if?(size?%?memblksize)
????????nmemb?++;??
????for?(offset?=?memtblsize-1;?offset?>=?0;?offset--)//搜索整個內存控制區??
????{?????
????????if?(!mallco_dev.memmap[offset])
????????????cmemb++;//連續空內存塊數增加
????????else?
????????????cmemb?=?0;??????????????????????????????//連續內存塊清零
????????if?(cmemb?==?nmemb)?????????????????????????//找到了連續nmemb個空內存塊
????????{
????????????for(i?=?0;?i?//標注內存塊非空?
????????????{??
????????????????mallco_dev.memmap[offset+i]?=?nmemb;??
????????????}??
????????????return?(offset*memblksize);//返回偏移地址??
????????}
????}??
????return?0XFFFFFFFF;//未找到符合分配條件的內存塊??
}??

上述代碼仔細閱讀也不難理解，總體來說，分配的過程最開始是檢查內存池是否已經初始化，如果沒有初始化，那么就進行初始化，進一步地就檢查所要分配的大小是否等于 0 ，如果等于0 ，那么就返回。接下來的就是根據要分配的內存大小來計算所要分配的內存塊數，最后，所要分配的內存可能不足以需要一整個內存塊了，但是不足的話仍舊以一個內存塊來進行計算，緊接著，就開始從內存池的底部開始尋找空閑內存塊，如果找到了，就將對應的內存管理表賦值成所要分配的內存塊大小。最后，返回所分配的內存在內存池中的偏移。注意，到這里并沒有結束，返回的只是偏移，并不是我們所需要的地址，因此，我們還需要如下所示的一個函數：

void?*mymalloc(uint32_t?size)??{??
????uint32_t?offset;???
????offset?=?my_mem_malloc(size);??????????????
????if?(offset?==?0XFFFFFFFF)
????????return?NULL;??
????else?
????????return?(void*)((uint32_t)mallco_dev.membase+offset);??
}??

上面這個函數就不在這里贅述了，其功能呢就是將在我們剛剛那個函數得到的偏移地址加上內存池所在的地址就得到了我們分配的那個內存的地址。

內存釋放原理

當 p 申請的內存用完，需要釋放的時候，調用 free 函數實現。free 函數先判斷 p 指向的內存地址所對應的內存塊，然后找到對應的內存管理表項目，得到 p 所占用的內存塊數目 m(內存管理表項目的值就是所分配內存塊的數目)，將這 m 個內存管理表項目的值都清零，標記釋放，完成一次內存釋放。這就是內存釋放的原理，對應的代碼如下所示：

uint8_t?my_mem_free(uint32_t?offset)??
{??
????int?i;??
????if?(!mallco_dev.memrdy)????????//未初始化,先執行初始化
????{
????????mallco_dev.init();????
????????return?1;?????????????????//未初始化??
????}??
????if?(offset?//偏移在內存池內.?
????{??
????????int?index?=?offset/memblksize;?????????//偏移所在內存塊號碼??
????????int?nmemb?=?mallco_dev.memmap[index];????//內存塊數量
????????for(i?=?0;?i?//內存塊清零
????????{??
????????????mallco_dev.memmap[index+i]=0;??
????????}??
????????return?0;??
????}
????else?
????????return?2;//偏移超區了. ?
}

通過上述代碼我們也可以知道關于內存的釋放只需要將其內存管理表的項置 0 就好，簡而言之，我們需要找到需要釋放的內存所在的地址，然后根據內存管理表的數值一次將內存管理表的值進行置 0 就完成了內存的釋放，當然，上述代碼也不是全部，釋放前我們需要知道釋放內存在內存池中的偏移，這部分代碼如下所示：

void?myfree(void?*ptr)??{??
????uint32_t?offset;???
????if(ptr==NULL)return;//地址為0.??
?????offset=(uint32_t)ptr-(uint32_t)mallco_dev.membase;?????
????my_mem_free(offset);????//釋放內存??????
}?

其中 ptr 就是要釋放的內存的地址，然后在減去內存池所在的地址，就可以得到要釋放的內存在內存池中的偏移。

總結

上述就是關于在裸機上實現的一個內存管理，仔細來看實現原理其實挺簡單，關于這個例子，筆者覺得也僅僅是提供了一個關于內存分配的一個思路，要真正的運用到實際中，還存在問題，在上述中的內存分配中，在進行分配時，當要分配的大小小于一個內存塊的大小時，直接采用的是分配一個內存塊的大小，而在例子中定義的內存塊大小是 32 K ，也就是說如果分配的內存大小小于 32 K ，那就分配 32 K ，這樣是極其浪費的。如果把內存塊定義的太小，那么相應伴隨的又是內存管理表數組的增大，也會增加對于 RAM 的消耗，所以總體來說上述的代碼存在著一些不完善，但是對于學習來說是極好的~

概念

Linux內核的信號量在概念和原理上和用戶態的System V的IPC機制信號量是相同的，不過他絕不可能在內核之外使用，因此他和System V的IPC機制信號量毫不相干。

如果有一個任務想要獲得已經被占用的信號量時，信號量會將其放入一個等待隊列(它不是站在外面癡癡地等待而是將自己的名字寫在任務隊列中)然后讓其睡眠。

當持有信號量的進程將信號釋放后，處于等待隊列中的一個任務將被喚醒(因為隊列中可能不止一個任務)，并讓其獲得信號量。這一點與自旋鎖不同，處理器可以去執行其它代碼。

應用場景

由于爭用信號量的進程在等待鎖重新變為可用時會睡眠，所以信號量適用于鎖會被長時間持有的情況；相反，鎖被短時間持有時，使用信號量就不太適宜了，因為睡眠、維護等待隊列以及喚醒所花費的開銷可能比鎖占用的全部時間表還要長。

舉2個生活中的例子：

我們坐火車從南京到新疆需要2天的時間，這個'任務'特別的耗時，只能坐在車上等著車到站，但是我們沒有必要一直睜著眼睛等，理想的情況就是我們上車就直接睡覺，醒來就到站(看過《異形》的讀者會深有體會)，這樣從人(用戶)的角度來說，體驗是最好的，對比于進程，程序在等待一個耗時事件的時候，沒有必須要一直占用CPU，可以暫停當前任務使其進入休眠狀態，當等待的事件發生之后再由其他任務喚醒，類似于這種場景采用信號量比較合適。

我們有時候會等待電梯、洗手間，這種場景需要等待的時間并不是很多，如果我們還要找個地方睡一覺，然后等電梯到了或者洗手間可以用了再醒來，那很顯然這也沒有必要，我們只需要排好隊，刷一刷抖音就可以了，對比于計算機程序，比如驅動在進入中斷例程，在等待某個寄存器被置位，這種場景需要等待的時間往往很短暫，系統開銷甚至遠小于進入休眠的開銷，所以這種場景采用自旋鎖比較合適。

關于信號量和自旋鎖，以及死鎖問題，我們后面會再詳細討論。

使用方法

一個任務要想訪問共享資源，首先必須得到信號量，獲取信號量的操作將把信號量的值減1，若當前信號量的值為負數，表明無法獲得信號量，該任務必須掛起在 該信號量的等待隊列等待該信號量可用；若當前信號量的值為非負數，表示能獲得信號量，因而能即時訪問被該信號量保護的共享資源。

當任務訪問完被信號量保護的共享資源后，必須釋放信號量，釋放信號量通過把信號量的值加1實現，如果信號量的值為非正數，表明有任務等待當前信號量，因此他也喚醒所有等待該信號量的任務。

內核信號量的構成

內核信號量類似于自旋鎖，因為當鎖關閉著時，它不允許內核控制路徑繼續進行。然而，當內核控制路徑試圖獲取內核信號量鎖保護的忙資源時，相應的進程就被掛起。只有在資源被釋放時，進程才再次變為可運行。

只有可以睡眠的函數才能獲取內核信號量；中斷處理程序和可延遲函數都不能使用內核信號量。

內核信號量是struct semaphore類型的對象，在內核源碼中位于include\linux\semaphore.h文件

struct?semaphore{
????raw_spinlock_t????????lock;
????unsigned?int????????count;
????struct?list_head????wait_list;
}
成員描述

lock	在2.6.33之后的版本，內核加入了raw_spin_lock系列，使用方法和spin_lock系列一模一樣，只是參數spinlock_t變為了raw_spinlock_t
count	相當于信號量的值，大于0，資源空閑；等于0，資源忙，但沒有進程等待這個保護的資源；小于0，資源不可用，并至少有一個進程等待資源
wait_list	內核鏈表，當前獲得信號量的任務會與該成員一起注冊到等待的鏈表中

信號量的API

初始化

DECLARE_MUTEX(name)

該宏聲明一個信號量name并初始化他的值為1，即聲明一個互斥鎖。

DECLARE_MUTEX_LOCKED(name)

該宏聲明一個互斥鎖name，但把他的初始值設置為0，即鎖在創建時就處在已鎖狀態。因此對于這種鎖，一般是先釋放后獲得。

void?sema_init?(struct?semaphore?*sem,?int?val);

該函用于數初始化設置信號量的初值，他設置信號量sem的值為val。

注意：

val設置為1說明只有一個持有者，這種信號量叫二值信號量或者叫互斥信號量。

我們還允許信號量可以有多個持有者，這種信號量叫計數信號量，在初始化時要說明最多允許有多少個持有者也可以把信號量中的val初始化為任意的正數值n，在這種情況下，最多有n個進程可以并發地訪問這個資源。

void?init_MUTEX?(struct?semaphore?*sem);

該函數用于初始化一個互斥鎖，即他把信號量sem的值設置為1。

void?init_MUTEX_LOCKED?(struct?semaphore?*sem);

該函數也用于初始化一個互斥鎖，但他把信號量sem的值設置為0，即一開始就處在已鎖狀態。

PV操作

獲取信號量(P)

void?down(struct?semaphore?*?sem);

該函數用于獲得信號量sem，他會導致調用該函數的進程睡眠，因此不能在中斷上下文(包括IRQ上下文和softirq上下文)使用該函數。該函數將把sem的值減1，如果信號量sem的值非負，就直接返回，否則調用者將被掛起，直到別的任務釋放該信號量才能繼續運行。

int?down_interruptible(struct?semaphore?*?sem);

該函數功能和down類似，不同之處為，down不會被信號(signal)打斷，但down_interruptible能被信號打斷，因此該函數有返回值來區分是正常返回還是被信號中斷，如果返回0，表示獲得信號量正常返回，如果被信號打斷，返回-EINTR。

int?down_trylock(struct?semaphore?*?sem);

該函數試著獲得信號量sem，如果能夠即時獲得，他就獲得該信號量并返回0，否則，表示不能獲得信號量sem，返回值為非0值。因此，他不會導致調用者睡眠，能在中斷上下文使用。

int?down_killable(struct?semaphore?*sem);
int?down_timeout(struct?semaphore?*sem,?long?jiffies);
int?down_timeout_interruptible(struct?semaphore?*sem,?long?jiffies);

釋放內核信號量(V)

void?up(struct?semaphore?*?sem);

該函數釋放信號量sem，即把sem的值加1，如果sem的值為非正數，表明有任務等待該信號量，因此喚醒這些等待者。

補充

int?down_interruptible(struct?semaphore?*sem)

這個函數的功能就是獲得信號量，如果得不到信號量就睡眠，此時沒有信號打斷，那么進入睡眠。但是在睡眠過程中可能被信號打斷，打斷之后返回-EINTR，主要用來進程間的互斥同步。

下面是該函數的注釋：

/**
*?down_interruptible?-?acquire?the?semaphore?unless?interrupted
*?@sem:?the?semaphore?to?be?acquired
*
*?Attempts?to?acquire?the?semaphore.?If?no?more?tasks?are?allowed?to
*?acquire?the?semaphore,?calling?this?function?will?put?the?task?to?sleep.
*?If?the?sleep?is?interrupted?by?a?signal,?this?function?will?return?-EINTR.
*?If?the?semaphore?is?successfully?acquired,?this?function?returns?0.
*/

一個進程在調用down_interruptible()之后，如果sem<0，那么就進入到可中斷的睡眠狀態并調度其它進程運行， 但是一旦該進程收到信號，那么就會從down_interruptible函數中返回。并標記錯誤號為:-EINTR。

一個形象的比喻：傳入的信號量為1好比天亮，如果當前信號量為0，進程睡眠，直到(信號量為1)天亮才醒，但是可能中途有個鬧鈴(信號)把你鬧醒。

又如：小強下午放學回家，回家了就要開始吃飯嘛，這時就會有兩種情況：情況一：飯做好了，可以開始吃；情況二：當他到廚房去的時候發現媽媽還在做， 媽媽就對他說：“你先去睡會，待會做好了叫你。” 小強就答應去睡會，不過又說了一句：“睡的這段時間要是小紅來找我玩，你可以叫醒我。” 小強就是down_interruptible，想吃飯就是獲取信號量，睡覺對應這里的休眠，而小紅來找我玩就是中斷休眠。

使用可被中斷的信號量版本的意思是，萬一出現了semaphore的死鎖，還有機會用ctrl+c發出軟中斷，讓等待這個內核驅動返回的用戶態進程退出。而不是把整個系統都鎖住了。在休眠時，能被中斷信號終止，這個進程是可以接受中斷信號的！

比如你在命令行中輸入# sleep 10000，按下ctrl + c，就給上面的進程發送了進程終止信號。信號發送給用戶空間，然后通過系統調用，會把這個信號傳給遞給驅動。信號只能發送給用戶空間，無權直接發送給內核的，那1G的內核空間，我們是無法直接去操作的。

內核信號量的使用例程

場景1

在驅動程序中，當多個線程同時訪問相同的資源時(驅動中的全局變量時一種典型的共享資源)，可能會引發“競態“，因此我們必須對共享資源進行并發控制。Linux內核中

解決并發控制的最常用方法是自旋鎖與信號量(絕大多數時候作為互斥鎖使用)。

在這里插入圖片描述

場景2

有時候我們希望設備只能被一個進程打開，當設備被占用的時候，其他設備必須進入休眠。

信號處理示意圖

在這里插入圖片描述

如上圖：

進程A首先通過open()打開設備文件，調用到內核的hello_open()，并調用down_interruptible()，因為此時信號量沒有被占用，所以進程A可以獲得信號量；

進程A獲得信號量之后繼續處理原有任務，此時進程B也要通過open()打開設備文件，同樣調用內核函數hello_open(),但此時信號量獲取不到，于是進程B被阻塞；

進程A任務執行完畢，關閉設備文件，并通過up()釋放信號量，于是進程B被喚醒，并得以繼續執行剩下的任務，

進程B執行完任務，釋放設備文件，通過up()釋放信號量

代碼如下：

#include?
#include?
#include?
#include?
#include?
#include?
#include?

static?int?major?=?250;
static?int?minor?=?0;
static?dev_t?devno;
static?struct?cdev?cdev;


static?struct?class?*cls;
static?struct?device?*test_device;

static?struct?semaphore?sem;
static?int?hello_open?(struct?inode?*inode,?struct?file?*filep){
????
????if(down_interruptible(&sem))//p
????{
????????return?-ERESTARTSYS;
????}
??????return?0;
}
static?int?hello_release?(struct?inode?*inode,?struct?file?*filep){
????up(&sem);//v
????return?0;
}
static?struct?file_operations?hello_ops?=
{
????.open?=?hello_open,
????.release?=?hello_release,
};
static?int?hello_init(void){
????int?result;
????int?error;????
????printk("hello_init?\n");
????result?=?register_chrdev(?major,?"hello",?&hello_ops);
????if(result?0)
????{
????????printk("register_chrdev?fail?\n");
????????return?result;
????}
????devno?=?MKDEV(major,minor);
????cls?=?class_create(THIS_MODULE,"helloclass");
????if(IS_ERR(cls))
????{
????????unregister_chrdev(major,"hello");
????????return?result;
????}
????test_device?=?device_create(cls,NULL,devno,NULL,"test");
????if(IS_ERR(test_device?))
????{
????????class_destroy(cls);
????????unregister_chrdev(major,"hello");
????????return?result;
????}
????sem_init(&sem,1);
????return?0;
}
static?void?hello_exit(void){
????printk("hello_exit?\n");
????device_destroy(cls,devno);????
????class_destroy(cls);
????unregister_chrdev(major,"hello");
????return;
}
module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("daniel.peng")；

測試程序 test.c

#include?
#include?
#include?
#include?
main()
{
????int?fd;
????
????printf("before?open\n?");????
????fd?=?open("/dev/test",O_RDWR);??//原子變量??0
????if(fd<0)
????{
????????perror("open?fail?\n");
????????return;
????}
????printf("open?ok?,sleep......\n?");????
????sleep(20);
????printf("wake?up?from?sleep!\n?");????????
????close(fd);???//加為1
}

編譯步驟

1 make 生成 hello.ko

2 gcc test.c -o a

3 gcc test.c -o b

測試步驟

安裝驅動

insmod?hello.ko

先運行進程A，在運行進程B

可見進程A成功打開設備，在進程A sleep期間會一直占有該字符設備，進程B由于無法獲得信號量，進入休閑，結合代碼可知，進程B被阻塞在函數open()中。

進程A 結束了sleep，并釋放字符設備以及信號量，進程B被喚醒獲得信號量，并成功打開了字符設備。

進程B執行完sleep函數后退出，并釋放字符設備和信號量。

讀-寫信號量

跟自旋鎖一樣，信號量也有區分讀-寫信號量之分。

如果一個讀寫信號量當前沒有被寫者擁有并且也沒有寫者等待讀者釋放信號量，那么任何讀者都可以成功獲得該讀寫信號量；否則，讀者必須被掛起直到寫者釋放該信號量。如果一個讀寫信號量當前沒有被讀者或寫者擁有并且也沒有寫者等待該信號量，那么一個寫者可以成功獲得該讀寫信號量，否則寫者將被掛起，直到沒有任何訪問者。因此，寫者是排他性的，獨占性的。

讀寫信號量有兩種實現，一種是通用的，不依賴于硬件架構，因此，增加新的架構不需要重新實現它，但缺點是性能低，獲得和釋放讀寫信號量的開銷大；另一種是架構相關的，因此性能高，獲取和釋放讀寫信號量的開銷小，但增加新的架構需要重新實現。在內核配置時，可以通過選項去控制使用哪一種實現。

讀寫信號量的相關API：

DECLARE_RWSEM(name)

該宏聲明一個讀寫信號量name并對其進行初始化。

void?init_rwsem(struct?rw_semaphore?*sem);

該函數對讀寫信號量sem進行初始化。

void?down_read(struct?rw_semaphore?*sem);

讀者調用該函數來得到讀寫信號量sem。該函數會導致調用者睡眠，因此只能在進程上下文使用。

int?down_read_trylock(struct?rw_semaphore?*sem);

該函數類似于down_read，只是它不會導致調用者睡眠。它盡力得到讀寫信號量sem，如果能夠立即得到，它就得到該讀寫信號量，并且返回1，否則表示不能立刻得到該信號量，返回0。因此，它也可以在中斷上下文使用。

void?down_write(struct?rw_semaphore?*sem);

寫者使用該函數來得到讀寫信號量sem，它也會導致調用者睡眠，因此只能在進程上下文使用。

int?down_write_trylock(struct?rw_semaphore?*sem);

該函數類似于down_write，只是它不會導致調用者睡眠。該函數盡力得到讀寫信號量，如果能夠立刻獲得，就獲得該讀寫信號量并且返回1，否則表示無法立刻獲得，返回0。它可以在中斷上下文使用。

void?up_read(struct?rw_semaphore?*sem);

讀者使用該函數釋放讀寫信號量sem。它與down_read或down_read_trylock配對使用。

如果down_read_trylock返回0，不需要調用up_read來釋放讀寫信號量，因為根本就沒有獲得信號量。

void?up_write(struct?rw_semaphore?*sem);

寫者調用該函數釋放信號量sem。它與down_write或down_write_trylock配對使用。如果down_write_trylock返回0，不需要調用up_write，因為返回0表示沒有獲得該讀寫信號量。

void?downgrade_write(struct?rw_semaphore?*sem);

該函數用于把寫者降級為讀者，這有時是必要的。因為寫者是排他性的，因此在寫者保持讀寫信號量期間，任何讀者或寫者都將無法訪問該讀寫信號量保護的共享資源，對于那些當前條件下不需要寫訪問的寫者，降級為讀者將，使得等待訪問的讀者能夠立刻訪問，從而增加了并發性，提高了效率。

讀寫信號量適于在讀多寫少的情況下使用，在linux內核中對進程的內存映像描述結構的訪問就使用了讀寫信號量進行保護。

-THE END-

---

推薦閱讀

【1】SPI轉can芯片CSM300詳解、Linux驅動移植調試筆記?必讀【2】到底什么是Cortex、ARMv8、arm架構、ARM指令集、soc？一文幫你梳理基礎概念【科普】?必讀【3】搞懂進程組、會話、控制終端關系，才能明白守護進程干嘛的？【4】快速掌握TCP協議【5】Linux庫概念，動態庫和靜態庫的制作，如何移植第三方庫【6】I2C基礎知識入門?必讀

本公眾號全部原創干貨已整理成一個目錄，點擊「干貨」即可獲得。

后臺回復「進群」，即可加入技術交流群，進群福利：免費贈送Linux學習資料。

總結

以上是生活随笔為你收集整理的电脑是否存在内存泄漏_STM32裸机内存管理解析的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。