前言
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、24字节的拷贝。主要需要注意的就是.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 "
"
"1: mov"itype" %2,%"rtype"1
"
"2: " ASM_CLAC "
"
".section .fixup,"ax"
"
"3: mov %3,%0
"
" xor"itype" %"rtype"1,%"rtype"1
"
" jmp 2b
"
".previous
"
_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
"
" jbe 1f
"
" movl %1,%0
"
" negl %0
"
" andl $7,%0
"
" subl %0,%3
"
"4: rep; movsb
"
" movl %3,%0
"
" shrl $2,%0
"
" andl $3,%3
"
" .align 2,0x90
"
"0: rep; movsl
"
" movl %3,%0
"
"1: rep; movsb
"
"2:
"
".section .fixup,"ax"
"
"5: addl %3,%0
"
" jmp 6f
"
"3: lea 0(%3,%0,4),%0
"
"6: pushl %0
"
" pushl %%eax
"
" xorl %%eax,%%eax
"
" rep; stosb
"
" popl %%eax
"
" popl %0
"
" jmp 2b
"
".previous
"
_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月