Linux内核的异常修复原理

简介: Linux内核的异常修复原理

参考

Linker Script in Linux (3.1.1 Exception Table)

Linux异常表

linux Oops和Panic关系

5. Kernel level exception handling

环境

ARM64

Linux-5.8

场景

   用户通过系统调用给内核传递了一个参数,这个参数有一个该用户地址空间的地址,然后内核在访问时会发生什么情况呢?如果这个用户空间地址处于当前进程的有效vma中,那么正常的缺页异常可以处理。

   但是如果这个参数是一个非法的用户地址,内核访问的话,会不会由于访问了非法地址而导致崩溃呢?

测试程序

驱动

static ssize_t fixup_read (struct file *filp, char __user *buf, size_t count, loff_t *fpos)
{
int err;
        err = put_user(10, buf);
        printk("%s: %d\n", __func__, err);
return count;
}

用户程序

int main(int argc, const char *argv[])
{
int fd;
char *buf;
        fd = open("/dev/fixup", O_RDWR);
        buf = 0x4000000;
printf("read buf\n");
        read(fd, buf, 5);
return 0;
}

内核log

[11131.867589] fixup_read: -14

   可以看到put_user返回了错误码:-EFAULT,并没有导致内核崩溃,测试程序也没有异常退出。在这背后发生了什么呢?其实内核在访问这个非法用户地址的时候,确实发生了缺页异常,不过在缺页异常中使用这里说的exception_table进行了修复,返回了错误码。要完成这个功能,需要依赖put_user和缺页异常的支持。

原理

put_user

put_user的实现在arch/arm64/include/asm/uaccess.h中:

#define _ASM_EXTABLE(from, to)            \
  " .pushsection  __ex_table, \"a\"\n"      \
  " .align    3\n"          \
  " .long   (" #from " - .), (" #to " - .)\n" \
  " .popsection\n"
#define __put_mem_asm(store, reg, x, addr, err)       \
  asm volatile(             \
  "1: " store " " reg "1, [%2]\n"     \
  "2:\n"                \
  " .section .fixup,\"ax\"\n"       \
  " .align  2\n"            \
  "3: mov %w0, %3\n"          \
  " b 2b\n"           \
  " .previous\n"            \
  _ASM_EXTABLE(1b, 3b)            \
  : "+r" (err)              \
  : "r" (x), "r" (addr), "i" (-EFAULT))
#define __raw_put_mem(str, x, ptr, err)         \
do {                  \
  __typeof__(*(ptr)) __pu_val = (x);        \
  switch (sizeof(*(ptr))) {         \
  case 1:               \
    __put_mem_asm(str "b", "%w", __pu_val, (ptr), (err)); \
    break;              \
  case 2:               \
    __put_mem_asm(str "h", "%w", __pu_val, (ptr), (err)); \
    break;              \
  case 4:               \
    __put_mem_asm(str, "%w", __pu_val, (ptr), (err)); \
    break;              \
  case 8:               \
    __put_mem_asm(str, "%x", __pu_val, (ptr), (err)); \
    break;              \
  default:              \
    BUILD_BUG();            \
  }               \
} while (0)
#define __raw_put_user(x, ptr, err)         \
do {                  \
  __chk_user_ptr(ptr);            \
  uaccess_ttbr0_enable();           \
  __raw_put_mem("sttr", x, ptr, err);       \
  uaccess_ttbr0_disable();          \
} while (0)
#define __put_user_error(x, ptr, err)         \
do {                  \
  __typeof__(*(ptr)) __user *__p = (ptr);       \
  might_fault();              \
  if (access_ok(__p, sizeof(*__p))) {       \
    __p = uaccess_mask_ptr(__p);        \
    __raw_put_user((x), __p, (err));      \
  } else  {             \
    (err) = -EFAULT;          \
  }               \
} while (0)
#define __put_user(x, ptr)            \
({                  \
  int __pu_err = 0;           \
  __put_user_error((x), (ptr), __pu_err);       \
  __pu_err;             \
})
#define put_user  __put_user

重点关注下面的内容:

#define _ASM_EXTABLE(from, to)            \
  " .pushsection  __ex_table, \"a\"\n"      \
  " .align    3\n"          \
  " .long   (" #from " - .), (" #to " - .)\n" \
  " .popsection\n"
#define __put_mem_asm(store, reg, x, addr, err)       \
  asm volatile(             \
  "1: " store " " reg "1, [%2]\n"     \
  "2:\n"                \
  " .section .fixup,\"ax\"\n"       \
  " .align  2\n"            \
  "3: mov %w0, %3\n"          \
  " b 2b\n"           \
  " .previous\n"            \
  _ASM_EXTABLE(1b, 3b)            \
  : "+r" (err)              \
  : "r" (x), "r" (addr), "i" (-EFAULT))

   上面用到了两个section,.fixup__ex_table,其中前者是修复程序的入口,后者用于存放触发异常的指令所在的地址跟对应的修复程序的入口地址之间的映射关系。比如当1b处的代码写addr触发了异常后,陷入内核缺页异常,然后在内核缺页异常里搜索1b对应的__ex_table,这个表里记录了异常指令地址跟对应的修复程序的入口地址的映射关系,找到后在异常返回时会跳转到修复程序入口,也就是跳转到上面.fixup3b处,然后将错误码-EFAULT存入err中,最后跳转到异常指令1b的下一行2b继续执行。

   在每一个__ex_table中存放了两个偏移量,分别是异常指令的地址1b和修改指令的地址3b跟当前地址的偏移,这样遍历__ex_table数组的时候可以很容易获得1b3b的地址。

   在内核的链接脚本中有专门存放__ex_table.fixup的段:

__ex_table:

/*
 * Exception table
 */
#define EXCEPTION_TABLE(align)            \
  . = ALIGN(align);           \
  __ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) {   \
    __start___ex_table = .;         \
    KEEP(*(__ex_table))         \
    __stop___ex_table = .;          \
  }

.fixup:

.text : ALIGN(SEGMENT_ALIGN) {  /* Real text segment    */
    _stext = .;   /* Text and read-only data  */
      IRQENTRY_TEXT
      SOFTIRQENTRY_TEXT
      ENTRY_TEXT
      TEXT_TEXT
      SCHED_TEXT
      CPUIDLE_TEXT
      LOCK_TEXT
      KPROBES_TEXT
      HYPERVISOR_TEXT
      IDMAP_TEXT
      HIBERNATE_TEXT
      TRAMP_TEXT
      *(.fixup)
      *(.gnu.warning)
    . = ALIGN(16);
    *(.got)     /* Global offset table    */
  }

内核缺页

do_translation_fault

   ----> do_page_fault

     ---->__do_kernel_fault

       ----> fixup_exception

int fixup_exception(struct pt_regs *regs)
{
  const struct exception_table_entry *fixup;
  fixup = search_exception_tables(instruction_pointer(regs));
  if (!fixup)
    return 0;
  if (in_bpf_jit(regs))
    return arm64_bpf_fixup_exception(fixup, regs);
  regs->pc = (unsigned long)&fixup->fixup + fixup->fixup;
  return 1;
}

 instruction_pointer(regs)返回异常指令的地址,也就是上面的1b,然后调用search_exception_tables搜索,搜索顺序是先从内核的__start___ex_table ~ __stop___ex_table搜索,如果没有找到,那么会依次从内核module和bpf里搜索。

/* Given an address, look for it in the exception tables. */
const struct exception_table_entry *search_exception_tables(unsigned long addr)
{
  const struct exception_table_entry *e;
  e = search_kernel_exception_table(addr); // 静态编译到内核中的
  if (!e)
    e = search_module_extables(addr);    // 从内核module里搜索
  if (!e)
    e = search_bpf_extables(addr);       // 从bpf里搜索
  return e;
}

search_kernel_exception_table的实现如下:

/* Given an address, look for it in the kernel exception table */
const
struct exception_table_entry *search_kernel_exception_table(unsigned long addr)
{
  return search_extable(__start___ex_table,
            __stop___ex_table - __start___ex_table, addr);
}

search_extable的实现如下:

struct exception_table_entry
{
  int insn, fixup;
};
static inline unsigned long ex_to_insn(const struct exception_table_entry *x)
{
  return (unsigned long)&x->insn + x->insn;
}
static int cmp_ex_search(const void *key, const void *elt)
{
  const struct exception_table_entry *_elt = elt;
  unsigned long _key = *(unsigned long *)key;
  /* avoid overflow */
  if (_key > ex_to_insn(_elt))
    return 1;
  if (_key < ex_to_insn(_elt))
    return -1;
  return 0;
}
/*
 * Search one exception table for an entry corresponding to the
 * given instruction address, and return the address of the entry,
 * or NULL if none is found.
 * We use a binary search, and thus we assume that the table is
 * already sorted.
 */
const struct exception_table_entry *
search_extable(const struct exception_table_entry *base,
         const size_t num,
         unsigned long value)
{
  return bsearch(&value, base, num,
           sizeof(struct exception_table_entry), cmp_ex_search);
}

   对于遍历到的每一个__ex_table都会调用cmp_ex_search,第一个参数key中存放的是&value,第二个参数存放的是当前__ex_table的地址。_key中存放的是异常指令1b的地址,ex_to_insn(_elt)返回记录的异常指令1b的地址(__ex_table的地址+偏移),如果二者相等,表示当前__ex_table就是我们想要的。

   最后回到fixup_exception中,search_exception_tables返回找到的__ex_table,然后计算修复指令的地址(unsigned long)&fixup->fixup + fixup->fixup(地址+偏移),将结果赋值给regs->pc,这样当异常返回后就会跳转到修复指令的地址开始执行,也就是上面提到的3b位置。

   上面分析了put_user,对于get_usercopy_to_user以及copy_from_user都采用了类似的方法来处理用户传递了非法的地址的情况,防止内核崩溃。

相关文章
|
6天前
|
安全 Linux 编译器
探索Linux内核的奥秘:从零构建操作系统####
本文旨在通过深入浅出的方式,带领读者踏上一段从零开始构建简化版Linux操作系统的旅程。我们将避开复杂的技术细节,以通俗易懂的语言,逐步揭开Linux内核的神秘面纱,探讨其工作原理、核心组件及如何通过实践加深理解。这既是一次对操作系统原理的深刻洞察,也是一场激发创新思维与实践能力的冒险。 ####
|
9天前
|
网络协议 Linux 调度
深入探索Linux操作系统的心脏:内核与系统调用####
本文旨在揭开Linux操作系统中最为核心的部分——内核与系统调用的神秘面纱,通过生动形象的语言和比喻,让读者仿佛踏上了一段奇妙的旅程,从宏观到微观,逐步深入了解这两个关键组件如何协同工作,支撑起整个操作系统的运行。不同于传统的技术解析,本文将以故事化的方式,带领读者领略Linux内核的精妙设计与系统调用的魅力所在,即便是对技术细节不甚了解的读者也能轻松享受这次知识之旅。 ####
|
5天前
|
缓存 算法 安全
深入理解Linux操作系统的心脏:内核与系统调用####
【10月更文挑战第20天】 本文将带你探索Linux操作系统的核心——其强大的内核和高效的系统调用机制。通过深入浅出的解释,我们将揭示这些技术是如何协同工作以支撑起整个系统的运行,同时也会触及一些常见的误解和背后的哲学思想。无论你是开发者、系统管理员还是普通用户,了解这些基础知识都将有助于你更好地利用Linux的强大功能。 ####
13 1
|
6天前
|
缓存 编解码 监控
深入探索Linux内核调度机制的奥秘###
【10月更文挑战第19天】 本文旨在以通俗易懂的语言,深入浅出地剖析Linux操作系统内核中的进程调度机制,揭示其背后的设计哲学与实现策略。我们将从基础概念入手,逐步揭开Linux调度策略的神秘面纱,探讨其如何高效、公平地管理系统资源,以及这些机制对系统性能和用户体验的影响。通过本文,您将获得关于Linux调度机制的全新视角,理解其在日常计算中扮演的关键角色。 ###
25 1
|
13天前
|
网络协议 Linux 芯片
Linux 内核 6.11 RC6 发布!
【10月更文挑战第12天】
76 0
Linux 内核 6.11 RC6 发布!
|
2月前
|
存储 安全 Linux
探索Linux操作系统的心脏:内核
在这篇文章中,我们将深入探讨Linux操作系统的核心—内核。通过简单易懂的语言和比喻,我们会发现内核是如何像心脏一样为系统提供动力,处理数据,并保持一切顺畅运行。从文件系统的管理到进程调度,再到设备驱动,我们将一探究竟,看看内核是怎样支撑起整个操作系统的大厦。无论你是计算机新手还是资深用户,这篇文章都将带你领略Linux内核的魅力,让你对这台复杂机器的内部运作有一个清晰的认识。
71 3
|
2月前
|
缓存 安全 Unix
Linux 内核黑客不可靠指南【ChatGPT】
Linux 内核黑客不可靠指南【ChatGPT】
|
2月前
|
Linux 开发者
Linux内核贡献成熟度模型 【ChatGPT】
Linux内核贡献成熟度模型 【ChatGPT】
|
2月前
|
网络协议 Ubuntu Linux
用Qemu模拟vexpress-a9 (三)--- 实现用u-boot引导Linux内核
用Qemu模拟vexpress-a9 (三)--- 实现用u-boot引导Linux内核
|
2月前
|
Linux
用clang编译Linux内核
用clang编译Linux内核