内存_用户空间程序出现非法页错误

linux中的虚拟地址通过PGD，PTE等映射到物理地址。但当这个映射过程无法正常映射时候，就会报错，产生page fault exception。那么什么时候会无法正常呢？

• 编程错误。程序使用了不存在的地址
• 不是编程错误，linux的请求调页机制。即：当进程运行时，linux并不将全部的资源分配给进程，而是仅分配当前需要的这一部分，当进程需要另外的资源的时候（这时候就会产生缺页异常），linux再分配这部分。

 编程错误linux肯定不会手软的，直接弄死进程。请求调页机制，linux会申请页的。

 

当MMU对不存在的虚拟地址进行映射的时候，会产生异常，__dabt_usr: __dabt_svc。 他们都会调用do_DataAbort。

 

__dabt_usr:
	usr_entry
	kuser_cmpxchg_check

	@
	@ Call the processor-specific abort handler:
	@
	@  r2 - aborted context pc
	@  r3 - aborted context cpsr
	@
	@ The abort handler must return the aborted address in r0, and
	@ the fault status register in r1.                           //说明了调用do_DataAbort时候传递给他的参数。  r0，r1，
	@
#ifdef MULTI_DABORT
	ldr	r4, .LCprocfns
	mov	lr, pc
	ldr	pc, [r4, #PROCESSOR_DABT_FUNC]
#else
	bl	CPU_DABORT_HANDLER
#endif

	@
	@ IRQs on, then call the main handler
	@
	enable_irq
	mov	r2, sp                                           //参数r2
	adr	lr, ret_from_exception
	b	do_DataAbort                   //调用do_DataAbort
ENDPROC(__dabt_usr)

do_DataAbor根据川进来的参数调用 inf->fn ，在这里就是 do_page_fault

asmlinkage void __exception
do_DataAbort(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
{
	const struct fsr_info *inf = fsr_info + (fsr & 15) + ((fsr & (1 << 10)) >> 6);
	struct siginfo info;

	if (!inf->fn(addr, fsr, regs))
		return;

	printk(KERN_ALERT "Unhandled fault: %s (0x%03x) at 0x%08lx\n",
		inf->name, fsr, addr);

	info.si_signo = inf->sig;
	info.si_errno = 0;
	info.si_code  = inf->code;
	info.si_addr  = (void __user *)addr;
	arm_notify_die("", regs, &info, fsr, 0);
}

 

do_page_fault函数是页异常的重要函数：

ps：因为在，__dabt_usr: __dabt_svc这两种情况下都会调用do_DataAbort函数，然后调用do_page_fault，所以调用do_page_fault可能是在内核空间，也可能是在用户空间。在内核空间可能会是 进程通过系统调用，中断等进入的，也可能进程本来是内核线程。所以在do_page_fault中要行进判断的。到底是从哪里发生的异常。

一下函数的分析大部分参考了《深入linux内核》书中的 第9章。

static int __kprobes                               //__kprobes标志应该是调试的一种东西，等以后再专门研究一下。
do_page_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
{
	struct task_struct *tsk;
	struct mm_struct *mm;
	int fault, sig, code;

	if (notify_page_fault(regs, fsr))       //这个函数是专门和上面的__kprobes对应的，调试的东西
		return 0;

	tsk = current;
	mm  = tsk->mm;                          //将出现页异常的进程的  的进程描述符 赋给tsk，内存描述符赋给mm
 
	/*
	 * If we're in an interrupt or have no user
	 * context, we must not take the fault..
	 */
	if (in_atomic() || !mm)                //判断发生发生异常的，in_atomic判断是否是在 原子操作中：中断程序，可延迟函数，禁用内核抢占的临界区。   ！mm  判断进程是否是内核线程。参照博客线程调度的文章。
		goto no_context;              //如果缺页是发生在这些情况下，那么就要特殊处理，因为这些程序都是没有用户空间的，要特殊处理。
                           
	/*
	 * As per x86, we may deadlock here.  However, since the kernel only
	 * validly references user space from well defined areas of the code,
	 * we can bug out early if this is from code which shouldn't.
	 */
	if (!down_read_trylock(&mm->mmap_sem)) {
		if (!user_mode(regs) && !search_exception_tables(regs->ARM_pc))
			goto no_context;
		down_read(&mm->mmap_sem);
	}                                           //down sem，没啥说的。

	fault = __do_page_fault(mm, addr, fsr, tsk);          //下面分析。
	up_read(&mm->mmap_sem);

	/*
	 * Handle the "normal" case first - VM_FAULT_MAJOR / VM_FAULT_MINOR
	 */
	if (likely(!(fault & (VM_FAULT_ERROR | VM_FAULT_BADMAP | VM_FAULT_BADACCESS))))
		return 0;                                                          //如果返回值不是上面的值。那么就是MAJOR  MINOR，说明问题解决了，return，如果是，那么还要go on

	/*
	 * If we are in kernel mode at this point, we
	 * have no context to handle this fault with.
	 */
	if (!user_mode(regs))
		goto no_context; //如果是内核空间出现了 页异常，并且通过__do_page_fault没有没有解决，那么到on_context

	if (fault & VM_FAULT_OOM) {
		/*
		 * We ran out of memory, or some other thing
		 * happened to us that made us unable to handle
		 * the page fault gracefully.
		 */
		printk("VM: killing process %s\n", tsk->comm);
		do_group_exit(SIGKILL);
		return 0;
	}
	if (fault & VM_FAULT_SIGBUS) {
		/*
		 * We had some memory, but were unable to
		 * successfully fix up this page fault.
		 */
		sig = SIGBUS;
		code = BUS_ADRERR;
	} else {
		/*
		 * Something tried to access memory that
		 * isn't in our memory map..
		 */
		sig = SIGSEGV;
		code = fault == VM_FAULT_BADACCESS ?
			SEGV_ACCERR : SEGV_MAPERR;
	}                       //这上面的英文描述很清楚了

	__do_user_fault(tsk, addr, fsr, sig, code, regs);    //用户态错误，这个函数什么都不做，就是发个新号，弄死进程
	return 0;

no_context:
	__do_kernel_fault(mm, addr, fsr, regs);             //内核错误，这个函数什么都不干，发送OOP：：：啊啊啊 啊啊啊，这个警告曾经弄死多少好汉
	return 0;
}

 

 

static int
__do_page_fault(struct mm_struct *mm, unsigned long addr, unsigned int fsr,
		struct task_struct *tsk)
{
	struct vm_area_struct *vma;
	int fault, mask;

	vma = find_vma(mm, addr);    //find_vma函数是从mm结构中找到一个vm_area_struct结构，这个结构的vm_end值 > 参数addr， 但是vm_start可能大于也可能小于，但fing_vma会尽可能找到小于的。即：addr在vma这个区间中。
	fault = VM_FAULT_BADMAP;
	if (!vma)                    //如果vma为0，那么想当于所有vma的vm_end地址都 < 参数addr，这个产生异常错误的地址  肯定是无效地址了。 因为根据进程的结构，如上图，所有vm中vm_end的最大值是3G。
		goto out;
	if (vma->vm_start > addr)    //如果vm_start>addr，说明这个异常的地址是 图中  的那个 空洞中，那么则可能是在用户态的栈中出错的。则跳去 check_stack
		goto check_stack;

	/*
	 * Ok, we have a good vm_area for this
	 * memory access, so we can handle it.
	 *///如果上面条件都不是，那么得到的vma结构就包含 addr这个地址。有可能是malloc后出错的。 用户态下的malloc时候，其实并不分配物理空间，只是返回一个虚拟地址，并产生一个vm_area_struct结构，当真正要用到malloc的空间的时候，才会产生异常，在这里得到真正的物理空间。 当然也有可能是其他原因，比如在read only的时候进行write了。
good_area:
	if (fsr & (1 << 11)) /* write? */       //fsr从第一段的汇编中得出意义，他是r1.状态。 这里看地址异常时候 是写还是其他。并复制到mask中
		mask = VM_WRITE;
	else
		mask = VM_READ|VM_EXEC|VM_WRITE;

	fault = VM_FAULT_BADACCESS;
	if (!(vma->vm_flags & mask))
		goto out;                       //如果是写，但是vma->vm_flag写没有set 1，说明的确是权限的问题，那么就set fault的值，退出。

	/*
	 * If for any reason at all we couldn't handle
	 * the fault, make sure we exit gracefully rather
	 * than endlessly redo the fault.
	 */
survive:                                          //上面原因都不是，那么就给进程分配一个新的页框。成功返回VM_FAULT_MAJOR（在handle_mm_fault中得到一个页框时候出现了阻塞，进行了睡眠）/VM_FAULT_MINOR（没有睡眠）
	fault = handle_mm_fault(mm, vma, addr & PAGE_MASK, fsr & (1 << 11));
	if (unlikely(fault & VM_FAULT_ERROR)) {
		if (fault & VM_FAULT_OOM)          //返回OOM，没有足够的内存。 到out_of_memory中，sleep一会，retry。
			goto out_of_memory;
		else if (fault & VM_FAULT_SIGBUS)
			return fault;
		BUG();
	}
	if (fault & VM_FAULT_MAJOR)
		tsk->maj_flt++;
	else
		tsk->min_flt++;
	return fault;

out_of_memory:
	if (!is_global_init(tsk))
		goto out;

	/*
	 * If we are out of memory for pid1, sleep for a while and retry
	 */
	up_read(&mm->mmap_sem);
	yield();
	down_read(&mm->mmap_sem);
	goto survive;

check_stack:
	if (vma->vm_flags & VM_GROWSDOWN && !expand_stack(vma, addr))          //检查堆栈，进行expand，扩展原来的栈的vma，然后goto good_area，去得到一个实际的物理地址。
		goto good_area;
out:
	return fault;
}

 

进程的用户空间结构:

图上面的堆栈空间个人感觉不对，堆是堆，栈是栈，  准确的说应该是栈吧、、。。堆会在brk（）函数中设置的。

这样分析之后基本上2.4和2.5节的内容已经全包含了，下面总结扩展并补充一下下：

• 当发生页面异常时候，会产生中断，当在用户态时候，会产生，__dabt_usr: 在内核态时__dabt_svc。但他们都会调用到do_DataAbort函数，do_DataAbort会根据中断的寄存器调用相应的处理函数。这里产生页面中断时候，会调用do_page_fault函数。
• 在do_page_fault函数中，首先会检查中断发生时，是不是在临界区，或者中断中，或者内核线程中。 如果是的话，那么就产生个OOPs。 因为这些地方是不允许异常的。如果异常会产生阻塞，阻塞就会死锁。死锁程序员就会被弄，被弄了程序员就发过来弄linux，所以linux就先弄了程序员，发出OOPs错误。
• 如果不在临界区中，那么调用__do_page_fault函数。这个函数会先检查 产生异常的地址，是不是进程的已有的线性空间中，即检查vm_area_struct的list中。
• 如果在的话，检查是不是因为 权限的问题产生的异常，如果是，那么说明应用程序是有问题的，直接弄死他。 如果不是，有可能是写时复制等一些linux机制。调用handle_mm_fault函数，进行分页等。
• 如果不在vm_area_struc的list中，如果大于所有的vm_area_struct的vm_end，那么说明是错误的地址，也是直接弄死。 如果有小于<vm_end，也小于vm_start，那么说明是在空洞中，应该是栈的问题，去申请更多的栈空间。（为什么<vm_end&&<vm_start就是在栈中，因为malloc等都是事先分配个vm_area_struct结构，当异常时，会找到相应的vm_area_struct结构的。如果找不到，那就是在栈里面了溢出了）。

下面再说handle_mm_fault函数：

• 他会首先 检查是否已经存在了PTE等映射，如果不在alloc 所有的 PUD,PMD,PTE等，建立映射。然后调用handle_pte_fault函数。注意：由于有些在刚建立的pte，所有pte里面全是0，有些是以前是建立好的，所以里面pte里面不是0，可能有其他值。所以下面还会做判断。
• handle_pte_fault函数会判断具体缺页的类型，具体分为3类， 会根据这三类调用不同的函数。具体调用的函数，以后再说吧。。。。。
•                  1.这个页从来没有被访问过，也就是这个pte中全是0，pte_none这个宏返回1
•                   2.以前访问过这个页，但这个页是非线性磁盘文件的映射，即：dirty位 置1， pte_file返回1
•                   3. 以前访问过这个页，但内容已经被保存在磁盘上了，即：dirty位 0

 

下图是 understand linux kernel书中的一个图，中文图在中文书中的P378

 

 

 

 

 

 

一、 段错误原因分析


         1 使用非法的指针，包括使用未经初始化及已经释放的指针(指针使用之前和释放之后置为NULL)

         2 内存读/写越界。包括数组访问越界，或在使用一些写内存的函数时，长度指定不正确或者这些函数本身不能指定长度，典型的函数有strcpy(strncpy)，sprintf

(snprint)等等。

         3 对于C++对象，请通过相应类的接口来去内存进行操作，禁止通过其返回的指针对内存进行写操作，典型的如string类的data()和c_str()两个接口。

         4 函数不要返回其中局部对象的引用或地址，当函数返回时，函数栈弹出，局部对象的地址将失效，改写或读这些地址都会造成未知的后果。

         5 避免在栈中定义过大的数组，否则可能导致进程的栈空间不足，此时也会出现段错误。

         6 操作系统的相关限制，如：进程可以分配的最大内存，进程可以打开的最大文件描述符个数等，这些需要通过ulimit或setrlimit或sysctl来解除相关的限制。

         7 多线程的程序，涉及到多个线程同时操作一块内存时必须进行互斥，否则内存中的内存将不可预料

         8 使用非线程安全的函数调用，例如 strerror 函数等

         9 在有信号的环境中，使用不可重入函数调用，而这些函数内部会读或写某片内存区，当信号中断时，内存写操作将被打断，而下次进入时将不避免的出错。

         10 跨进程传递某个地址

        11 某些有特殊要求的系统调用，例如epool_wait，正常情况下使用close关闭一个套接字后，epool会不再返回这个socket上的事件，但是如果你使用dup或dup2操作，将

导致epool无法进行移除操作。


二、 段错误原因查找

1） 查看函数调用栈

    在头文件"execinfo.h"中声明了三个函数用于获取当前线程的函数调用堆栈

    Function: int backtrace(void **buffer,int size)

    该函数用与获取当前线程的调用堆栈,获取的信息将会被存放在buffer中,它是一个指针列表。参数 size 用来指定buffer中可以保存多少个void* 元素。函数返回值是实际获取的指针个数,最大不超过size大小。

   在buffer中的指针实际是从堆栈中获取的返回地址,每一个堆栈框架有一个返回地址。

    注意某些编译器的优化选项对获取正确的调用堆栈有干扰,另外内联函数没有堆栈框架;删除框架指针也会使无法正确解析堆栈内容。

   Function: char ** backtrace_symbols (void *const *buffer, int size)

    backtrace_symbols将从backtrace函数获取的信息转化为一个字符串数组. 参数buffer应该是从backtrace函数获取的数组指针,size是该数组中的元素个数(backtrace的返回值)   。
   
   函数返回值是一个指向字符串数组的指针,它的大小同buffer相同.每个字符串包含了一个相对于buffer中对应元素的可打印信息.它包括函数名，函数的偏移地址,和实际的返回地址。

   现在,只有使用ELF二进制格式的程序和苦衷才能获取函数名称和偏移地址.在其他系统,只有16进制的返回地址能被获取.另外,你可能需要传递相应的标志给链接器,以能支持函数名功能(比如,在使用GNU ld的系统中,你需要传递(-rdynamic))。

   该函数的返回值是通过malloc函数申请的空间,因此调用这必须使用free函数来释放指针。

注意:如果不能为字符串获取足够的空间函数的返回值将会为NULL

Function:void backtrace_symbols_fd (void *const *buffer, int size, int fd)

backtrace_symbols_fd与backtrace_symbols 函数具有相同的功能,不同的是它不会给调用者返回字符串数组,而是将结果写入文件描述符为fd的文件中,每个函数对应一行.它不需要调用malloc函数，因此适用于有可能调用该函数会失败的情况。

下面的例子显示了这三个函数的用法

#include <execinfo.h>
#include <stdio.h>
#include <stdlib.h>

/* Obtain a backtrace and print it to stdout. */
void print_trace (void)
{
     void *array[10];
     size_t size;
     char **strings;
     size_t i;

     size = backtrace (array, 10);
     strings = backtrace_symbols (array, size);

      printf ("Obtained %zd stack frames.\n", size);

     for (i = 0; i < size; i++)
     {
          printf ("%s\n", strings);
     }
     free (strings);
}

/* A dummy function to make the backtrace more interesting. */
void  dummy_function (void)
{
       print_trace ();
}

int  main (void)
{
     dummy_function ();
      return 0;
}

备注:void *const *buffer -- buffer指向char类型的常量指针的指针(很是拗口)

2） 查看寄存器内容
要查看寄存器内容有两个解决办法：

A） 在内核里面把这些寄存器打印出来；

      

    

       图一：段错误时内核执行路径

根据上图，我们只需要在__do_user_fault的时候把打印信息打开就可以了，如下：

把

#ifdef CONFIG_DEBUG_USER

       if (user_debug & UDBG_SEGV) {

              printk(KERN_DEBUG "%s: unhandled page fault (%d) at 0x%08lx, code 0x%03x\n",

                     tsk->comm, sig, addr, fsr);

              show_pte(tsk->mm, addr);

              show_regs(regs);

       }

#endif

改成

printk(KERN_DEBUG "%s: unhandled page fault (%d) at 0x%08lx, code 0x%03x\n",

                     tsk->comm, sig, addr, fsr);

              show_pte(tsk->mm, addr);

              show_regs(regs);

就可以了；

       里面会打印出 pc 寄存器的值。

B） 在上层程序里面把寄存器打印出来；

这个做法的主要思路就是先拦截SIGSEGV信号，然后在信号处理函数里面打印信息：

信号拦截代码如下：

static void  catch_sigsegv()

{

       struct sigaction action;

       memset(&action, 0, sizeof(action));

       action.sa_sigaction = sigsegv_handler;

       action.sa_flags = SA_SIGINFO;       // 注意这里，flag 是 SA_SIGINFO，这样信号处理函数就会多一些信息。

       if(sigaction(SIGSEGV, &action, NULL) < 0){

              perror("sigaction");

}

}

只需要在main函数里面加入这个函数就可以了，

main(…)

{

….

catch_sigsegv();

…

}

 

下面来看看这个处理函数sigsegv_handler是怎么写的，代码如下：

#include <memory.h>

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

#include <signal.h>

#include <ucontext.h>

#include <dlfcn.h>

static void sigsegv_handler(int signum, siginfo_t* info, void*ptr)

{

        static const char *si_codes[3] = {"", "SEGV_MAPERR", "SEGV_ACCERR"};

        int i;

        ucontext_t *ucontext = (ucontext_t*)ptr;

        void *bt[100];

        char **strings;

        printf("Segmentation Fault Trace:\n");

        printf("info.si_signo = %d\n", signum);

        printf("info.si_errno = %d\n", info->si_errno);

        printf("info.si_code  = %d (%s)\n", info->si_code, si_codes[info->si_code]);

        printf("info.si_addr  = %p\n", info->si_addr);

 

        /*for arm*/

        printf("the arm_fp 0x%3x\n",ucontext->uc_mcontext.arm_fp);

        printf("the arm_ip 0x%3x\n",ucontext->uc_mcontext.arm_ip);

        printf("the arm_sp 0x%3x\n",ucontext->uc_mcontext.arm_sp);

        printf("the arm_lr 0x%3x\n",ucontext->uc_mcontext.arm_lr);

        printf("the arm_pc 0x%3x\n",ucontext->uc_mcontext.arm_pc);

        printf("the arm_cpsr 0x%3x\n",ucontext->uc_mcontext.arm_cpsr);

        printf("the falut_address 0x%3x\n",ucontext->uc_mcontext.fault_address);

 

        printf("Stack trace (non-dedicated):");

        int sz = backtrace(bt, 20);

        printf("the stack trace is %d\n",sz);

        strings = backtrace_symbols(bt, sz);

        for(i = 0; i < sz; ++i){

                printf("%s\n", strings[i]);

        }

    _exit (-1);

}

 

 

测试代码如下：

void test_segv()

{

        char *i=0;

        *i=10;

}

 

void cause_segv()

{

        printf("this is the cause_segv\n");

        test_segv();

}

int main(int argc,char **argv)

{

        catch_sigsegv();

        cause_segv();

        return 0;

}

编译方法：

gcc segment_trace.c -g –rdynamic –o segment_trace

执行：

./segment_trace

输出如下：

this is the catch_sigsegv

Segmentation Fault Trace:

info.si_signo = 11

info.si_errno = 0

info.si_code  = 1 (SEGV_MAPERR)

info.si_addr  = (nil)

the arm_fp 0xb7f8a3d4

the arm_ip 0xb7f8a3d8

the arm_sp 0xb7f8a3c0

the arm_lr 0x8998

the arm_pc 0x8974

the arm_cpsr 0x60000010

the falut_address 0x  0

Stack trace (non-dedicated):the stack trace is 5

./segment_trace(backtrace_symbols+0x1c8) [0x8844]

/lib/libc.so.6(__default_rt_sa_restorer+0) [0xb5e22230]

./segment_trace(cause_segv+0x18) [0x8998]

./segment_trace(main+0x20) [0x89c0]

/lib/libc.so.6(__libc_start_main+0x108) [0xb5e0c10c]

    C） 输出信息分析 

根据上面的输出可以看出一些端倪：

根据栈信息，可以看出是在cause_segv里面出了问题，但是最后一层栈信息是看不到的，另外需要根据pc寄存器的值来定位：

addr2line  -f -e segment_trace 0x8974

test_segv

/home/wf/test/segment_trace.c:55

可以看到说是在55行，一看:

刚好是

*i=10;

这一行，

而且可以看出，函数名是test_segv，

所以基本上不需要打印栈信息，也可以定位了。

也可以使用 objdump 工具：

objdump -S -l -z  -j .text segment_trace   >1.txt

查看 0x8974 地址的代码。