内存检测

• 越界访问（out-of-bounds）。
• 访问已经被释放的内存（use after free）。
• 重复释放（double free）。
• 内存泄漏（memory leak）。
• 栈溢出（stack overflow）。

跟踪内存活动的各种事件源

oomkill

memleak

• 写一个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 运行

fibonacci+0x23 [leak]child+0x5a [leak]

• 改进后，重复上面的操作，结果如下

mmapsnoop

brkstack

shmsnoop

• 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：共享内存管理结构体。

faults

vmscan

• 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写入页的数量。

drsnoop

• 直接内存回收

  在直接内存回收过程中，有可能会造成当前需要分配内存的进程被加入一个等待队列，当整个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

  ;

  
  

  }

  
  
1. 分配标志中没有__GFP_NO_KSWAPD，只有在透明大页的分配过程中会有这个标志。
2. node中有至少一个zone的空闲页框没有达到 空闲页框数量 >= high阀值 + 1 << order + 保留内存，或者有至少一个zone需要进行内存压缩，这两种情况node的kswapd都会被唤醒。

swapin

hfaults