越界存取（out-of-bounds）。

存取已經被釋放的記憶體（use after free）。

重復釋放（double free）。

記憶體泄漏（memory leak）。

棧溢位（stack overflow）。

寫一個c程式：

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<unistd.h>
longlong *fibonacci(longlong *n0, longlong *n1){
// 分配1024個長整數空間方便觀測記憶體的變化情況
longlong *v = (longlong *) calloc(1024, sizeof(longlong));
*v = *n0 + *n1;
return v;
}
void *child(void *arg){
longlong n0 = 0;
longlong n1 = 1;
longlong *v = NULL;
int n = 2;
for (n = 2; n > 0; n++) {
v = fibonacci(&n0, &n1);
n0 = n1;
n1 = *v;
printf("%dth => %lld\n", n, *v);
sleep(1);
}
}
intmain(void){
pthread_t tid;
pthread_create(&tid, NULL, child, NULL);
pthread_join(tid, NULL);
printf("main thread exit\n");
return0;
}



執行該檔

再開一個終端,使用命令vmstat 3

再次使用命令執行上面C程式

在開啟第二個終端中使用命令:ps aux | grep app檢視行程id

使用命令: sudo /usr/sbin/memleak-bpfcc -p 6867 執行

改進後，重復上面的操作，結果如下

shmget()函式

得到一個共享記憶體識別元或建立一個共享記憶體物件。

asmlinkage longsys_shmget(key_t key, size_t size, int flag);


SYSCALL_DEFINE3(shmget, key_t, key, size_t, size, int, shmflg)
{
return ksys_shmget(key, size, shmflg);
}


longksys_shmget(key_t key, size_t size, int shmflg)
{
structipc_namespace *ns;
staticconststructipc_opsshm_ops = {
.getnew = newseg,
.associate = security_shm_associate,
.more_checks = shm_more_checks,
 };
structipc_paramsshm_params;
 ns = current->nsproxy->ipc_ns;
 shm_params.key = key;
 shm_params.flg = shmflg;
 shm_params.u.size = size;
return ipcget(ns, &shm_ids(ns), &shm_ops, &shm_params);
}



成功：共享記憶體段識別元 出錯：-1

函式參數：

Key：共享記憶體的鍵值，多個行程可以透過它，來存取同一個共享記憶體；其中特殊的值IPC_PRIVATE，用於建立當前行程的私有共享記憶體， 多用於父子行程間。

size：共享記憶體區大小 。

Shmflg：同 open 函式的許可權位，也可以用八進制表示法

返回值：

shmat( )函式

連線共享記憶體識別元為shmid的共享記憶體，連線成功後把共享記憶體區物件對映到呼叫行程的地址空間，隨後可像本地空間一樣存取。

asmlinkage longsys_shmat(int shmid, char __user *shmaddr, int shmflg);


SYSCALL_DEFINE3(shmat, int, shmid, char __user *, shmaddr, int, shmflg)
{
unsignedlong ret;
long err;
 err = do_shmat(shmid, shmaddr, shmflg, &ret, SHMLBA);
if (err)
return err;
 force_successful_syscall_return();
return (long)ret;
}

成功：被對映的段地址 出錯：-1

函式原型

shmid：要對映的共享記憶體區識別元

shmaddr：將共享記憶體對映到指定位置

Shmflg：SHM_RDONLY:共享記憶體唯讀，預設0：共享記憶體可讀寫

返回值：

shmdt()函式

與shmat函式相反，是用來斷開與共享記憶體附加點的地址，禁止本行程存取此片共享記憶體。

本函式呼叫並不刪除所指定的共享記憶體區，而只是將先前用shmat函式連線（attach）好的共享記憶體脫離（detach）目前的行程。

asmlinkage longsys_shmdt(char __user *shmaddr);


SYSCALL_DEFINE1(shmdt, char __user *, shmaddr)
{
return ksys_shmdt(shmaddr);
}


longksys_shmdt(char __user *shmaddr)
{
// 獲取當前行程的記憶體管理結構
structmm_struct *mm = current->mm;
// 定義虛擬記憶體區域結構體指標
structvm_area_struct *vma;
// 將共享記憶體地址轉換為無符號長整型
unsignedlong addr = (unsignedlong)shmaddr;
// 初始化返回值，預設為無效參數錯誤
int retval = -EINVAL;
#ifdef CONFIG_MMU
// 定義大小變量和檔指標
loff_t size = 0;
structfile *file;
structvm_area_struct *next;
#endif
// 檢查共享記憶體地址是否有效
if (addr & ~PAGE_MASK)
return retval;
// 嘗試獲取記憶體對映寫鎖，可被訊號中斷
if (mmap_write_lock_killable(mm))
return -EINTR;
// 尋找給定地址的虛擬記憶體區域
 vma = find_vma(mm, addr);
#ifdef CONFIG_MMU
while (vma) {
next = vma->vm_next;
// 檢查地址是否匹配，並且 vma 與 shm 相關
if ((vma->vm_ops == &shm_vm_ops) &&
(vma->vm_start - addr)/PAGE_SIZE == vma->vm_pgoff) {
// 記錄 shm 段的檔和大小
file = vma->vm_file;
size = i_size_read(file_inode(vma->vm_file));
// 取消對映 shm 段
do_munmap(mm, vma->vm_start, vma->vm_end - vma->vm_start, NULL);
// 設定返回值為成功
retval = 0;
vma = next;
break;
}
vma = next;
 }
// 遍歷所有可能的 vma
 size = PAGE_ALIGN(size);
while (vma && (loff_t)(vma->vm_end - addr) <= size) {
next = vma->vm_next;
// 檢查地址是否匹配，並且 vma 與 shm 相關
if ((vma->vm_ops == &shm_vm_ops) &&
((vma->vm_start - addr)/PAGE_SIZE == vma->vm_pgoff) &&
(vma->vm_file == file))
// 取消對映 shm 段
do_munmap(mm, vma->vm_start, vma->vm_end - vma->vm_start, NULL);
vma = next;
 }
#else/* CONFIG_MMU */
// 在 NOMMU 條件下，必須給出要銷毀的確切地址
if (vma && vma->vm_start == addr && vma->vm_ops == &shm_vm_ops) {
// 取消對映 shm 段
do_munmap(mm, vma->vm_start, vma->vm_end - vma->vm_start, NULL);
// 設定返回值為成功
retval = 0;
 }
#endif
// 解鎖記憶體對映
 mmap_write_unlock(mm);
return retval;
}












函式原型

shmaddr：連線的共享記憶體的起始地址

shmctl函式

完成對共享記憶體的控制

asmlinkage longsys_shmctl(int shmid, int cmd, struct shmid_ds __user *buf);


SYSCALL_DEFINE3(shmctl, int, shmid, int, cmd, struct shmid_ds __user *, buf)
{
return ksys_shmctl(shmid, cmd, buf, IPC_64);
}


staticlongksys_shmctl(int shmid, int cmd, struct shmid_ds __user *buf, int version)
{
int err;
structipc_namespace *ns;
structshmid64_dssem64;
if (cmd < 0 || shmid < 0)
return -EINVAL;
 ns = current->nsproxy->ipc_ns;
switch (cmd) {
case IPC_INFO: {
structshminfo64shminfo;
err = shmctl_ipc_info(ns, &shminfo);
if (err < 0)
return err;
if (copy_shminfo_to_user(buf, &shminfo, version))
err = -EFAULT;
return err;
 }
case SHM_INFO: {
structshm_infoshm_info;
err = shmctl_shm_info(ns, &shm_info);
if (err < 0)
return err;
if (copy_to_user(buf, &shm_info, sizeof(shm_info)))
err = -EFAULT;
return err;
 }
case SHM_STAT:
case SHM_STAT_ANY:
case IPC_STAT: {
err = shmctl_stat(ns, shmid, cmd, &sem64);
if (err < 0)
return err;
if (copy_shmid_to_user(buf, &sem64, version))
err = -EFAULT;
return err;
 }
case IPC_SET:
if (copy_shmid_from_user(&sem64, buf, version))
return -EFAULT;
fallthrough;
case IPC_RMID:
return shmctl_down(ns, shmid, cmd, &sem64);
case SHM_LOCK:
case SHM_UNLOCK:
return shmctl_do_lock(ns, shmid, cmd);
default:
return -EINVAL;
 }
}



函式原型

shmid：共享記憶體識別元

cmd：IPC_STAT：得到共享記憶體的狀態，把共享記憶體的shmid_ds結構復制到buf中；IPC_SET：改變共享記憶體的狀態，把buf所指的shmid_ds結構中的uid、gid、mode復制到共享記憶體的shmid_ds結構內；IPC_RMID：刪除這片共享記憶體

buf：共享記憶體管理結構體。

vmscan:mm_shrink_slab_end，vmscan:mm_shrink_slab_start

使用這兩個跟蹤點計算收縮slab所花的全部時間，以毫秒為單位。這是從各種內核緩存中回收記憶體。

vmscan:mm_vmscan_direct_reclaim_begin，vmscan:mm_vmscan_direct_reclaim_end

使用這兩個跟蹤點計算直接接回收所花的時間，以毫秒為單位。這是前台回收過程，在此期間記憶體被換入磁盤中，並且記憶體分配處於阻塞狀態。

vmscan:mm_vmscan_memcg_reclaim_begin，vmscan:mm_vmscan_memcg_reclaim_end

記憶體cgroup回收所花的時間，以毫秒為單位。如果使用了記憶體cgroups，此列顯示當cgroup超出記憶體限制，導致該cgroup進行記憶體回收的時間。

vmscan:mm_vmscan_wakeup_kswapd

kswapd 喚醒的次數。

vmscan:mm_vmscan_writepage

kswapd寫入頁的數量。

直接記憶體回收

在直接記憶體回收過程中，有可能會造成當前需要分配記憶體的行程被加入一個等待佇列，當整個node的空閑頁數量滿足要求時，由kswapd喚醒它重新獲取記憶體。這個等待佇列頭就是node結點描述符pgdat中的pfmemalloc_wait。如果當前行程加入到了pgdat->pfmemalloc_wait這個等待佇列中，那麽行程就不會進行直接記憶體回收，而是由kswapd喚醒後直接進行記憶體分配。

直接記憶體回收執行路徑是：

__alloc_pages_slowpath() -> __alloc_pages_direct_reclaim() -> __perform_reclaim() -> try_to_free_pages() -> do_try_to_free_pages() -> shrink_zones() -> shrink_zone()

在 __alloc_pages_slowpath() 中可能喚醒了所有node的kswapd內核執行緒，也可能沒有喚醒，每個node的kswapd是否在 __alloc_pages_slowpath() 中被喚醒有兩個條件：

而在kswapd中會對node中每一個不平衡的zone進行記憶體回收，直到所有zone都滿足 zone分配頁框後剩余的頁框數量 > 此zone的high閥值 + 此zone保留的頁框數量。 kswapd就會停止記憶體回收，然後喚醒在等待佇列的行程。

之後行程由於記憶體不足，對zonelist進行直接回收時，會呼叫到try_to_free_pages()，在這個函式內，決定了行程是否加入到node結點的pgdat->pfmemalloc_wait這個等待佇列中，如下：

unsignedlongtry_to_free_pages(struct zonelist *zonelist, int order,
gfp_t gfp_mask, nodemask_t *nodemask)
{
unsignedlong nr_reclaimed;
structscan_controlsc = {
/* 打算回收32個頁框 */
.nr_to_reclaim = SWAP_CLUSTER_MAX,
.gfp_mask = current_gfp_context(gfp_mask),
.reclaim_idx = gfp_zone(gfp_mask),
/* 本次記憶體分配的order值 */
.order = order,
/* 允許進行回收的node掩碼 */
.nodemask = nodemask,
/* 優先級為預設的12 */
.priority = DEF_PRIORITY,
/* 與/proc/sys/vm/laptop_mode檔有關
* laptop_mode為0，則允許進行回寫操作，即使允許回寫，直接記憶體回收也不能對臟檔頁進行回寫
* 不過允許回寫時，可以對非檔頁進行回寫
*/
.may_writepage = !laptop_mode,
/* 允許進行unmap操作 */
.may_unmap = 1,
/* 允許進行非檔頁的操作 */
.may_swap = 1,
 };
 BUILD_BUG_ON(MAX_ORDER > S8_MAX);
 BUILD_BUG_ON(DEF_PRIORITY > S8_MAX);
 BUILD_BUG_ON(MAX_NR_ZONES > S8_MAX);
/* 當zonelist中獲取到的第一個node平衡，則返回，如果獲取到的第一個node不平衡，則將當前行程加入到pgdat->pfmemalloc_wait這個等待佇列中 
* 這個等待佇列會在kswapd進行記憶體回收時，如果讓node平衡了，則會喚醒這個等待佇列中的行程
* 判斷node平衡的標準:
* 此node的ZONE_DMA和ZONE_NORMAL的總共空閑頁框數量 是否大於 此node的ZONE_DMA和ZONE_NORMAL的平均min閥值數量，大於則說明node平衡
* 加入pgdat->pfmemalloc_wait的情況
* 1.如果分配標誌禁止了檔案系統操作，則將要進行記憶體回收的行程設定為TASK_INTERRUPTIBLE狀態，然後加入到node的pgdat->pfmemalloc_wait，並且會設定超時時間為1s 
* 2.如果分配標誌沒有禁止了檔案系統操作，則將要進行記憶體回收的行程加入到node的pgdat->pfmemalloc_wait，並設定為TASK_KILLABLE狀態，表示允許 TASK_UNINTERRUPTIBLE 響應致命訊號的狀態 
* 返回真，表示此行程加入過pgdat->pfmemalloc_wait等待佇列，並且已經被喚醒
* 返回假，表示此行程沒有加入過pgdat->pfmemalloc_wait等待佇列
*/
if (throttle_direct_reclaim(sc.gfp_mask, zonelist, nodemask))
return1;
 set_task_reclaim_state(current, &sc.reclaim_state);
 trace_mm_vmscan_direct_reclaim_begin(order, sc.gfp_mask);
/* 進行記憶體回收，有三種情況到這裏 
* 1.當前行程為內核執行緒
* 2.最優node是平衡的，當前行程沒有加入到pgdat->pfmemalloc_wait中
* 3.當前行程接收到了kill訊號
*/
 nr_reclaimed = do_try_to_free_pages(zonelist, &sc);
 trace_mm_vmscan_direct_reclaim_end(nr_reclaimed);
 set_task_reclaim_state(current, NULL);
return nr_reclaimed;
}






主要透過throttle_direct_reclaim()函式判斷是否加入到pgdat->pfmemalloc_wait等待佇列中，主要看此函式：

staticboolthrottle_direct_reclaim(gfp_t gfp_mask, struct zonelist *zonelist,
nodemask_t *nodemask)
{
structzoneref *z;
structzone *zone;
pg_data_t *pgdat = NULL;
/* 如果標記了PF_KTHREAD，表示此行程是一個內核執行緒，則不會往下執行 */
if (current->flags & PF_KTHREAD)
goto out;
/* 此行程已經接收到了kill訊號，準備要被殺掉了 */
if (fatal_signal_pending(current))
goto out;
/* 遍歷zonelist，但是裏面只會在獲取到第一個pgdat時就跳出 */
 for_each_zone_zonelist_nodemask(zone, z, zonelist,
gfp_zone(gfp_mask), nodemask) {
/* 只遍歷ZONE_NORMAL和ZONE_DMA區 */
if (zone_idx(zone) > ZONE_NORMAL)
continue;
/* 獲取zone對應的node */
pgdat = zone->zone_pgdat;
/* 判斷node是否平衡，如果平衡，則返回真
* 如果不平衡，如果此node的kswapd沒有被喚醒，則喚醒，並且這裏喚醒kswapd只會對ZONE_NORMAL以下的zone進行記憶體回收
* node是否平衡的判斷標準是:
* 此node的ZONE_DMA和ZONE_NORMAL的總共空閑頁框數量 是否大於 此node的ZONE_DMA和ZONE_NORMAL的平均min閥值數量，大於則說明node平衡
*/
if (allow_direct_reclaim(pgdat))
goto out;
break;
 }

if (!pgdat)
goto out;
 count_vm_event(PGSCAN_DIRECT_THROTTLE);

if (!(gfp_mask & __GFP_FS))
/* 如果分配標誌禁止了檔案系統操作，則將要進行記憶體回收的行程設定為TASK_INTERRUPTIBLE狀態，然後加入到node的pgdat->pfmemalloc_wait，並且會設定超時時間為1s 
* 1.allow_direct_reclaim(pgdat)為真時被喚醒，而1s沒超時，返回剩余timeout(jiffies)
* 2.睡眠超過1s時會喚醒，而allow_direct_reclaim(pgdat)此時為真，返回1
* 3.睡眠超過1s時會喚醒，而allow_direct_reclaim(pgdat)此時為假，返回0
* 4.接收到訊號被喚醒，返回-ERESTARTSYS
*/
wait_event_interruptible_timeout(pgdat->pfmemalloc_wait,
allow_direct_reclaim(pgdat), HZ);
else
/* 如果分配標誌沒有禁止了檔案系統操作，則將要進行記憶體回收的行程加入到node的pgdat->pfmemalloc_wait，並設定為TASK_KILLABLE狀態，表示允許 TASK_UNINTERRUPTIBLE 響應致命訊號的狀態 
* 這些行程在兩種情況下被喚醒
* 1.allow_direct_reclaim(pgdat)為真時
* 2.接收到致命訊號時
*/
wait_event_killable(zone->zone_pgdat->pfmemalloc_wait,
allow_direct_reclaim(pgdat));
/* 如果加入到了pgdat->pfmemalloc_wait後被喚醒，就會執行到這 */
/* 喚醒後再次檢查當前行程是否接受到了kill訊號，準備結束 */
if (fatal_signal_pending(current))
returntrue;
out:
returnfalse;
}