copy_from_user分析

前言

copy_from_user函数的目的是从用户空间拷贝数据到内核空间，失败返回没有被拷贝的字节数，成功返回0。它内部的实现当然不仅仅拷贝数据，还需要考虑到传入的用户空间地址是否有效，比如地址是不是超出用户空间范围啊，地址是不是没有对应的物理页面啊，否则内核就会oops的。不同的架构，该函数的实现不一样。下面主要以arm和x86为例进行说明（分析过程会忽略一些无关的代码）。

arm copy_from_user

arm架构下，copy_from_user相关的文件主要有arch/arm/include/asm/uaccess.h　　arch/arm/lib/copy_from_user.S　　arch/arm/lib/copy_template.S。下面先来看copy_from_user，它的实现在arch/arm/include/asm/uaccess.h中：

static inline unsigned long __must_check copy_from_user(void *to, const void __user *from, unsigned long n)
{
	if (access_ok(VERIFY_READ, from, n))
		n = __copy_from_user(to, from, n);
	else /* security hole - plug it */
		memset(to, 0, n);
	return n;
}

该函数先通过access_ok做第一层的地址范围有效性检查，然后通过__copy_from_user进行正式的拷贝。之所以只做第一层的检查，是因为第二层的检查（地址是不是没有对应的物理页面）只能通过异常处理来解决！

下面看access_ok的实现吧！(代码实现还是在同一个文件里)同样，不同的架构，实现方式不同。甚至有mmu和无mmu也不同。

#ifdef CONFIG_MMU
...
...
...
#define __range_ok(addr,size) ({ \
	unsigned long flag, roksum; \
	__chk_user_ptr(addr);	\
	__asm__("adds %1, %2, %3; sbcccs %1, %1, %0; movcc %0, #0" \
		: "=&r" (flag), "=&r" (roksum) \
		: "r" (addr), "Ir" (size), "0" (current_thread_info()->addr_limit) \
		: "cc"); \
	flag; })
#else /* CONFIG_MMU */
...
...
...
#define __range_ok(addr,size)	((void)(addr),0)
#endif

#define access_ok(type,addr,size)	(__range_ok(addr,size) == 0)

对于无mmu的，检查就是不检查，因为无mmu也就是意味着没有虚拟地址映射，用的都是物理地址（出了问题，也无法解决）。

对于有mmu的，会先__chk_user_ptr检查addr，该函数一般为空！（它的实现涉及到__CHECKER__宏的判断，__CHECKER__宏在通过Sparse（Semantic Parser for C）工具对内核代码进行检查时会定义的。在使用make C=1或C=2时便会调用该工具，这个工具可以检查在代码中声明了sparse所能检查到的相关属性的内核函数和变量。如果定义了__CHECKER__，__chk_user_ptr和__chk_io_ptr在这里只声明函数，没有函数体，目的就是在编译过程中Sparse能够捕捉到编译错误，检查参数的类型。如果没有定义__CHECKER__，这就是一个空语句）。核心的内容在

unsigned long flag, roksum; \
__asm__("adds %1, %2, %3; sbcccs %1, %1, %0; movcc %0, #0" \
		: "=&r" (flag), "=&r" (roksum) \
		: "r" (addr), "Ir" (size), "0" (current_thread_info()->addr_limit) \
		: "cc"); \
	flag; })

这是一段c内嵌汇编(linux采用AT&T编码方式，左边值为原操作数，右边值为目的操作数，与intel编码方式不同，可参考GNU C内嵌汇编语言)！核心思想就是判断源地址+要拷贝的size是否超出了进程所限制的地址limit范围。下面一行行分析，先看输入输出设置部分：

		: "=&r" (flag), "=&r" (roksum) \
		: "r" (addr), "Ir" (size), "0" (current_thread_info()->addr_limit) \
		: "cc"); \

&表示输出数据不会被覆盖，"=&r" (flag), "=&r" (roksum)表示输出用通用寄存器来存放，同时指向flag和roksum中，输入用通用寄存器存放addr，以及32为整形size，同时，flag的初始值设置为current_thread_info()->addr_limit，"cc"表示该内嵌__asm__汇编指令将会改变CPU的条件状态寄存器cc。

下面继续看命令部分：

adds %1, %2, %3; sbcccs %1, %1, %0; movcc %0, #0

先将addr与size相加，存入到roksum中（计算结果会设置cpsr），如果前面的计算没有进位，那么说明add与size的相加没有超出unsigned int范围，于是用sbc来实现addr+size-flag-!C，也就是addr+size-current_thread_info()->addr_limit-1，最后如果前面的命令执行没有导致C位为１，那么执行mov %0, #0，也就是说将flag设置为0。如果C位为１了，那么说明（addr + size）>=（current_thread_info()->addr_limit）。这里要注意减法指令是没有借位时，C为0；有借位时，C为1。

最后要说明一下，__range_ok定义的最后有一个flag;这个是gnu支持的扩展，在({})包围的代码里面，最后一个表达式或值会作为整个({})的返回值。也就是说flag就是__range_ok的返回值。__range_ok如果一切顺利，那么返回就是0，如果其中任何一个指令有问题，那么就不会是0了（最开始flag的初始值为current_thread_info()->addr_limit，非0）

好了，分析完__range_ok的实现，现在继续看__copy_from_user，还是在相同的文件里(同样有mmu和非mmu之分)：

#ifdef CONFIG_MMU
extern unsigned long __must_check __copy_from_user(void *to, const void __user *from, unsigned long n);
...
...
...
#else
#define __copy_from_user(to,from,n)	(memcpy(to, (void __force *)from, n), 0)
...
...
...
#endif

有mmu的时候，它对应的实现在arch/arm/lib/copy_from_user.S里面：

...
...
...
ENTRY(__copy_from_user)

#include "copy_template.S"

ENDPROC(__copy_from_user)

	.pushsection .fixup,"ax"
	.align 0
	copy_abort_preamble
	ldmfd	sp!, {r1, r2}
	sub	r3, r0, r1
	rsb	r1, r3, r2
	str	r1, [sp]
	bl	__memzero
	ldr	r0, [sp], #4
	copy_abort_end
	.popsection

核心的实现在arch/arm/lib/copy_template.S中，arch/arm/lib/copy_template.S里面的具体逻辑会因为arch/arm/lib/copy_from_user.S之前所定义的宏而不同。这里就不再跟进去分析了，异常表的处理我打算通过分析x86实现的时候来完成。

x86 copy_from_user

x86架构下，copy_from_user相关的文件主要有arch/x86/include/asm/uaccess.h　　arch/x86/lib/usercopy_32.S　　arch/x86/include/asm/uaccess_32.h arch/x86/include/asm/uaccess_64.h。下面先来看copy_from_user，它的实现在arch/x86/include/asm/uaccess.h中：

static inline unsigned long __must_check
copy_from_user(void *to, const void __user *from, unsigned long n)
{
	int sz = __compiletime_object_size(to);

	might_fault();

	/*
	 * While we would like to have the compiler do the checking for us
	 * even in the non-constant size case, any false positives there are
	 * a problem (especially when DEBUG_STRICT_USER_COPY_CHECKS, but even
	 * without - the [hopefully] dangerous looking nature of the warning
	 * would make people go look at the respecitive call sites over and
	 * over again just to find that there's no problem).
	 *
	 * And there are cases where it's just not realistic for the compiler
	 * to prove the count to be in range. For example when multiple call
	 * sites of a helper function - perhaps in different source files -
	 * all doing proper range checking, yet the helper function not doing
	 * so again.
	 *
	 * Therefore limit the compile time checking to the constant size
	 * case, and do only runtime checking for non-constant sizes.
	 */

	if (likely(sz < 0 || sz >= n))
		n = _copy_from_user(to, from, n);
	else if(__builtin_constant_p(n))
		copy_from_user_overflow();
	else
		__copy_from_user_overflow(sz, n);

	return n;
}

GCC的内建函数__builtin_constant_p用于判断一个值是否为编译时常数，如果参数值是常数，函数返回 1，否则返回 0。copy_from_user核心的实现在_copy_from_user中：

unsigned long _copy_from_user(void *to, const void __user *from, unsigned n)
{
	if (access_ok(VERIFY_READ, from, n))
		n = __copy_from_user(to, from, n);
	else
		memset(to, 0, n);
	return n;
}

其中，access_ok相关代码（代码比较简单，不再分析）：

static inline bool __chk_range_not_ok(unsigned long addr, unsigned long size, unsigned long limit)
{
	/*
	 * If we have used "sizeof()" for the size,
	 * we know it won't overflow the limit (but
	 * it might overflow the 'addr', so it's
	 * important to subtract the size from the
	 * limit, not add it to the address).
	 */
	if (__builtin_constant_p(size))
		return addr > limit - size;

	/* Arbitrary sizes? Be careful about overflow */
	addr += size;
	if (addr < size)
		return true;
	return addr > limit;
}

#define __range_not_ok(addr, size, limit)				\
({									\
	__chk_user_ptr(addr);						\
	__chk_range_not_ok((unsigned long __force)(addr), size, limit); \
})

#define access_ok(type, addr, size) \
	likely(!__range_not_ok(addr, size, user_addr_max()))

下面看__copy_from_user相关的代码实现（以32位系统为例），注释直接添加到代码中：

static __always_inline unsigned long
__copy_from_user(void *to, const void __user *from, unsigned long n)
{
	might_fault();
	if (__builtin_constant_p(n)) {//如果能够识别为常量，就进入
		unsigned long ret;

		switch (n) {
		case 1:
			__get_user_size(*(u8 *)to, from, 1, ret, 1);
			return ret;
		case 2:
			__get_user_size(*(u16 *)to, from, 2, ret, 2);
			return ret;
		case 4:
			__get_user_size(*(u32 *)to, from, 4, ret, 4);
			return ret;
		}
	}
	return __copy_from_user_ll(to, from, n);//如果不能识别n是一个常量，就调用
}

先看__get_user_size实现，__chk_user_ptr之前已经说过，不再重复。主要看__get_user_asm：

#define __get_user_size(x, ptr, size, retval, errret)			\
do {									\
	retval = 0;							\
	__chk_user_ptr(ptr);						\
	switch (size) {							\
	case 1:								\
		__get_user_asm(x, ptr, retval, "b", "b", "=q", errret);	\
		break;							\
	case 2:								\
		__get_user_asm(x, ptr, retval, "w", "w", "=r", errret);	\
		break;							\
	case 4:								\
		__get_user_asm(x, ptr, retval, "l", "k", "=r", errret);	\
		break;							\
	case 8:								\
		__get_user_asm_u64(x, ptr, retval, errret);		\
		break;							\
	default:							\
		(x) = __get_user_bad();					\
	}								\
} while (0)

__get_user_size根据要copy的size传入不同的参数，最终会使用movb或者movw或者movl来实现1、2\4字节的拷贝。主要需要注意的就是.section .fixup和_ASM_EXTABLE，.section .fixup指定了.fixup section，且该段为可重定位的代码段，_ASM_EXTABLE定义了__ex_table段，且该段为可重定位的数据段，实际上它指定了3b处异常时的跳转地址，即3b,3b刚好就是.fixup段处。

#define __get_user_asm(x, addr, err, itype, rtype, ltype, errret)	\
	asm volatile(ASM_STAC "\n"					\
		     "1:	mov"itype" %2,%"rtype"1\n"		\
		     "2: " ASM_CLAC "\n"				\
		     ".section .fixup,\"ax\"\n"				\
		     "3:	mov %3,%0\n"				\
		     "	xor"itype" %"rtype"1,%"rtype"1\n"		\
		     "	jmp 2b\n"					\
		     ".previous\n"					\
		     _ASM_EXTABLE(1b, 3b)				\
		     : "=r" (err), ltype(x)				\
		     : "m" (__m(addr)), "i" (errret), "0" (err))

分析完1、2、4字节的拷贝后，继续看非1、2、4字节的拷贝实现，现在继续看__copy_from_user_ll：

unsigned long __copy_from_user_ll(void *to, const void __user *from,
					unsigned long n)
{
	stac();
	if (movsl_is_ok(to, from, n))
		__copy_user_zeroing(to, from, n);
	else
		n = __copy_user_zeroing_intel(to, from, n);
	clac();
	return n;
}

先通过movsl_is_ok判断下，然后分别调用__copy_user_zeroing或者__copy_user_zeroing_intel。movsl_is_ok的实现：

static inline int __movsl_is_ok(unsigned long a1, unsigned long a2, unsigned long n)
{
#ifdef CONFIG_X86_INTEL_USERCOPY
	if (n >= 64 && ((a1 ^ a2) & movsl_mask.mask))
		return 0;
#endif
	return 1;
}
#define movsl_is_ok(a1, a2, n) \
	__movsl_is_ok((unsigned long)(a1), (unsigned long)(a2), (n))

从这里可以知道，只有配置了CONFIG_X86_INTEL_USERCOPY，才有可能返回0，不然一般多事返回1。我们不考虑定义CONFIG_X86_INTEL_USERCOPY的情况，也就是该函数返回1时，继续转入到__copy_user_zeroing的调用，代码实现如下：

#define __copy_user_zeroing(to, from, size)				\
do {									\
	int __d0, __d1, __d2;						\
	__asm__ __volatile__(						\
		"	cmp  $7,%0\n"					\
		"	jbe  1f\n"					\
		"	movl %1,%0\n"					\
		"	negl %0\n"					\
		"	andl $7,%0\n"					\
		"	subl %0,%3\n"					\
		"4:	rep; movsb\n"					\
		"	movl %3,%0\n"					\
		"	shrl $2,%0\n"					\
		"	andl $3,%3\n"					\
		"	.align 2,0x90\n"				\
		"0:	rep; movsl\n"					\
		"	movl %3,%0\n"					\
		"1:	rep; movsb\n"					\
		"2:\n"							\
		".section .fixup,\"ax\"\n"				\
		"5:	addl %3,%0\n"					\
		"	jmp 6f\n"					\
		"3:	lea 0(%3,%0,4),%0\n"				\
		"6:	pushl %0\n"					\
		"	pushl %%eax\n"					\
		"	xorl %%eax,%%eax\n"				\
		"	rep; stosb\n"					\
		"	popl %%eax\n"					\
		"	popl %0\n"					\
		"	jmp 2b\n"					\
		".previous\n"						\
		_ASM_EXTABLE(4b,5b)					\
		_ASM_EXTABLE(0b,3b)					\
		_ASM_EXTABLE(1b,6b)					\
		: "=&c"(size), "=&D" (__d0), "=&S" (__d1), "=r"(__d2)	\
		: "3"(size), "0"(size), "1"(to), "2"(from)		\
		: "memory");						\
} while (0)

同样是汇编实现，.section .fixup和_ASM_EXTABLE部分前面已经说了，而指令部分就是我们通常的数据拷贝，因此也就不再分析了。

这里摘抄下网上的一段叙述，同时他对__copy_user_zeroing的指令部分有详细的注释，大家可以看看：

在cpu进行访址的时候，内核空间和用户空间使用的都是线性地址，cpu在访址的过程中会自动完成从线性地址到物理地址的转换[用户态、内核态都得依靠进程页表完成转换]，而合理的线性地址意味着：该线性地址位于该进程task_struct->mm虚存空间的某一段vm_struct_mm中，而且建立线性地址到物理地址的映射，即线性地址对应内容在物理内存中。如果访存失败，有两种可能：该线性地址存在在进程虚存区间中，但是并未建立于物理内存的映射，有可能是交换出去，也有可能是刚申请到线性区间[内核是很会偷懒的]，要依靠缺页异常去建立申请物理空间并建立映射；第2种可能是线性地址空间根本没有在进程虚存区间中，这样就会出现常见的坏指针，就会引发常见的段错误[也有可能由于访问了无权访问的空间造成保护异常]。如果坏指针问题发生在用户态，最严重的就是杀死进程[最常见的就是在打dota时候出现的大红X，然后dota程序结束]，如果发生在内核态,整个系统可能崩溃[xp的蓝屏很可能就是这种原因形成的]。所以linux当然不会任由这种情况的发生，其措施如下：

linux内核对于可能发生问题的指令都会准备"修复地址"，比如前面的fixup部分，而且遵循谁使用这些指令，谁负责修复工作的原则。比如前面的代码中，标号5即为标号4的修复指令，3为0,6为1的修复指令。在编译过程中，编译器会将5,4等的地址对应的存入struct exception_table_entry{unsigned long insn，fixup；}中。insn即可能为4的地址，而fixup可能为5的地址，如果4为坏地址[即该地址并未在虚存区间中]，则在页面异常处理过程中，会转入bad_area处，如果发生在用户态直接杀死进程即可。如果发生在内核态，首先通过search_exception_table查找异常处理表exception_table。即找到某一个exception_table_entry，假设其insn=标号4地址，fixup=标号5地址.内核将发生:

regs->ip=fixup,即通过修改当前的内核地址，从而将内核从死亡的边缘拉回来，通过标号5地址处的修复工作从而全身而退。

总结

主要分析了copy_from_user接口的内部实现，copy_to_user实现类似，不再重复分析。总的来说，copy_from_user完成了数据的拷贝的同时，处理了可能发生了地址访问异常。理论上，内核空间可以直接使用用户空间传过来的指针，即使要做数据拷贝的动作，也可以直接使用memcpy，事实上，在没有MMU的体系架构上，copy_form_user最终的实现就是利用了memcpy。但对于大多数有MMU的平台，情况就有了一些变化：用户空间传过来的指针是在虚拟地址空间上的，它指向的虚拟地址空间很可能还没有真正映射到实际的物理页面上。用户空间的缺页导致的异常会透明的被内核予以修复(为缺页的地址空间提交新的物理页面)，访问到缺页的指令会继续运行仿佛什么都没有发生一样。内核空间必须被显示的修复，这是由内核提供的缺页异常处理函数的设计模式决定的（其背后的思想后：在内核态中，如果程序试图访问一个尚未提交物理页面的用户空间地址，内核必须对此保持警惕而不能像用户空间那样毫无察觉。如果内核访问一个尚未被提交物理页面的空间，将产生缺页异常，这个时候内核会调用do_page_fault，因为异常发生在内核空间，do_page_fault的处理逻辑将调用search_exception_tables在__ex_table中查找异常指令的修复指令），正因为这样，copy_from_user的实现才会看起来有些复杂，当然性能方面提升也是它的复杂度提升的一个原因。

完！

2015年7月