概述

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

堆、棧和靜態(tài)區(qū)

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

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

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

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

內(nèi)存碎片和內(nèi)存泄漏

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

內(nèi)存碎片

假設(shè)我現(xiàn)在有 16 個字節(jié)的空閑內(nèi)存，如下圖所示：

空閑內(nèi)存

現(xiàn)在我使用 malloc 分配了四次內(nèi)存，然后這 16 個字節(jié)的內(nèi)存變成了這樣：

分配之后的內(nèi)存空間

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

釋放之后的內(nèi)存空間

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

內(nèi)存泄漏

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

什么時候會使用到堆呢？

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

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 所在內(nèi)存位置，但是這個時候，如果不給數(shù)組的元素分配一定大小的內(nèi)存，那么可能就放不下拷貝進去的字符串，因此在往里面拷貝字符串時，應(yīng)該提前開辟出一段內(nèi)存空間出來，這個時候，就需要使用到 malloc 來進行內(nèi)存分配，當然所對應(yīng)的，當這個數(shù)組使用完之后，需要使用?free來將分配的內(nèi)存釋放掉，否則就會造成內(nèi)存泄漏。

單片機如何進行分配內(nèi)存

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

• 他們的實現(xiàn)可能非常大，占據(jù)了相當大的一塊代碼空間

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

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

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

分塊式內(nèi)存管理原理

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

內(nèi)存分配原理

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

#define?MEM1_BLOCK_SIZE????????????32?????????//內(nèi)存塊大小為32字節(jié)
#define?MEM1_MAX_SIZE????????????10*1024????//最大管理內(nèi)存?10K
#define?MEM1_ALLOC_TABLE_SIZE????MEM1_MAX_SIZE/MEM1_BLOCK_SIZE???//內(nèi)存表大小??

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

內(nèi)存釋放原理

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

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

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

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);????//釋放內(nèi)存??????
}?

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

總結(jié)

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

概念

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

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

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

應(yīng)用場景

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

舉2個生活中的例子：

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

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

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

使用方法

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

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

內(nèi)核信號量的構(gòu)成

內(nèi)核信號量類似于自旋鎖，因為當鎖關(guān)閉著時，它不允許內(nèi)核控制路徑繼續(xù)進行。然而，當內(nèi)核控制路徑試圖獲取內(nèi)核信號量鎖保護的忙資源時，相應(yīng)的進程就被掛起。只有在資源被釋放時，進程才再次變?yōu)榭蛇\行。

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

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

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

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

信號量的API

初始化

DECLARE_MUTEX(name)

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

DECLARE_MUTEX_LOCKED(name)

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

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

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

注意：

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

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

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

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

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

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

PV操作

獲取信號量(P)

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

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

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

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

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

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

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

釋放內(nèi)核信號量(V)

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

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

補充

int?down_interruptible(struct?semaphore?*sem)

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

下面是該函數(shù)的注釋：

/**
*?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.
*/

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

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

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

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

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

內(nèi)核信號量的使用例程

場景1

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

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

在這里插入圖片描述

場景2

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

信號處理示意圖

在這里插入圖片描述

如上圖：

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

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

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

進程B執(zhí)行完任務(wù)，釋放設(shè)備文件，通過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

測試步驟

安裝驅(qū)動

insmod?hello.ko

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

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

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

進程B執(zhí)行完sleep函數(shù)后退出，并釋放字符設(shè)備和信號量。

讀-寫信號量

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

如果一個讀寫信號量當前沒有被寫者擁有并且也沒有寫者等待讀者釋放信號量，那么任何讀者都可以成功獲得該讀寫信號量；否則，讀者必須被掛起直到寫者釋放該信號量。如果一個讀寫信號量當前沒有被讀者或?qū)懻邠碛胁⑶乙矝]有寫者等待該信號量，那么一個寫者可以成功獲得該讀寫信號量，否則寫者將被掛起，直到?jīng)]有任何訪問者。因此，寫者是排他性的，獨占性的。

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

讀寫信號量的相關(guān)API：

DECLARE_RWSEM(name)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

讀寫信號量適于在讀多寫少的情況下使用，在linux內(nèi)核中對進程的內(nèi)存映像描述結(jié)構(gòu)的訪問就使用了讀寫信號量進行保護。

-THE END-

---

推薦閱讀

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

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

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

總結(jié)

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

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。