copy_to_user和copy_from_user两个函数的分析

不念不忘少年蓝@ 2022-07-12 02:19 121阅读 0赞

在内核的学习中会遇到很多挺有意思的函数，而且能沿着一个函数扯出来很多个相关的函数。copy\_to\_user和copy\_from\_user就是在进行驱动相关程序设计的时候，要经常遇到的两个函数。由于内核空间与用户空间的内存不能直接互访，因此借助函数copy\_to\_user()完成用户空间到内核空间的复制，函数copy\_from\_user()完成内核空间到用户空间的复制。下面我们来仔细的理一下这两个函数的来龙去脉。

首先，我们来看一下这两个函数的在源码文件中是如何定义的：

~/arch/i386/lib/usercopy.c

unsigned long

copy\_to\_user(void \_\_user \*to, const void \*from, unsigned long n)

might\_sleep();

BUG\_ON((long) n < 0);

if (access\_ok(VERIFY\_WRITE, to, n))

n = \_\_copy\_to\_user(to, from, n);

return n;

EXPORT\_SYMBOL(copy\_to\_user);

从注释中就可以看出，这个函数的主要作用就是从内核空间拷贝一块儿数据到用户空间，由于这个函数有可能睡眠，所以只能用于用户空间。它有如下三个参数，

To 目标地址，这个地址是用户空间的地址；

From 源地址，这个地址是内核空间的地址；

N 将要拷贝的数据的字节数。

如果数据拷贝成功，则返回零；否则，返回没有拷贝成功的数据字节数。

以上是对函数的一些说明，接下来让我们看看这个函数的内部面目：

参数to的时候有个\_\_user限定，这个在~/include/linux/compiler.h中有如下定义：

\# define \_\_user     \_\_attribute\_\_((noderef, address\_space(1)))

表示这是一个用户空间的地址，即其指向的为用户空间的内存

大家可能对这个\_\_attribute\_\_感到比较迷惑，不过没关系，google一下嘛

\_\_attribute\_\_是gnu c编译器的一个功能，它用来让开发者使用此功能给所声明的函数或者变量附加一个属性，以方便编译器进行错误检查，其实就是一个内核检查器。

具体可以参考如下：

[http://unixwiz.net/techtips/gnu-c-attributes.html][http_unixwiz.net_techtips_gnu-c-attributes.html]

接下来我们看一下

might\_sleep();它有两个实现版本，debug版本和非debug版本：

在debug版本中，在有可能引起sleep的函数中会给出相应的提示，如果是在原子的上下文中执行，则会打印出栈跟踪的信息，这是通过\_\_might\_sleep(\_\_FILE\_\_, \_\_LINE\_\_);函数来实现的，并且接着调用might\_resched()函数进行重新调度。

在非debug版本中直接调用might\_resched()函数进行重新调度。

其实现方式为，在~/ include/linux/kernel.h中：

\#ifdef CONFIG\_DEBUG\_SPINLOCK\_SLEEP

void \_\_might\_sleep(char \*file, int line);

\# define might\_sleep() /

do \{ \_\_might\_sleep(\_\_FILE\_\_, \_\_LINE\_\_); might\_resched(); \} while (0)

\#else

\# define might\_sleep() do \{ might\_resched(); \} while (0)

\#endif

接下来是一个检查参数合法性的宏：

BUG\_ON((long) n < 0);

其实现为如下(在~/include/asm-generic/bug.h):

它通过检查条件，根据结果来决定是否打印相应的提示信息；

\#ifdef CONFIG\_BUG

\#ifndef HAVE\_ARCH\_BUG

\#define BUG() do \{ /

printk("BUG: failure at %s:%d/%s()!/n", \_\_FILE\_\_, \_\_LINE\_\_, \_\_FUNCTION\_\_); /

panic("BUG!"); /

\} while (0)

\#endif

\#ifndef HAVE\_ARCH\_BUG\_ON

\#define BUG\_ON(condition) do \{ if (unlikely((condition)!=0)) BUG(); \} while(0)

\#endif

接下来是一个宏

access\_ok(VERIFY\_WRITE, to, n)

它是用来检查参数中一个指向用户空间数据块的指针是否有效，如果有效返回非零，否则返回零。其实现如下(在/include/asm-i386/uaccess.h中)：

\#define access\_ok(type,addr,size) (likely(\_\_range\_ok(addr,size) == 0))

其中\_\_range\_ok(addr,size)的实现是通过内嵌汇编来实现的，内容如下(在/include/asm-i386/uaccess.h中)：

\#define \_\_range\_ok(addr,size) (\{ /

unsigned long flag,sum; /

\_\_chk\_user\_ptr(addr); /

asm("addl %3,%1 ; sbbl %0,%0; cmpl %1,%4; sbbl $0,%0" /

:"=&r" (flag), "=r" (sum) /

:"1" (addr),"g" ((int)(size)),"g" (current\_thread\_info()->addr\_limit.seg)); /

flag; \})

其实现的功能为：

(u33)addr + (u33)size >= (u33)current->addr\_limit.seg

判断上式是否成立，若不成立则表示地址有效，返回零；否则返回非零

接下来的这个函数才是最重要的函数，它实现了拷贝的工作：

\_\_copy\_to\_user(to, from, n)

其实现方式如下(在/include/asm-i386/uaccess.h中)：

static \_\_always\_inline unsigned long \_\_must\_check

\_\_copy\_to\_user(void \_\_user \*to, const void \*from, unsigned long n)

might\_sleep();

return \_\_copy\_to\_user\_inatomic(to, from, n);

有一个\_\_always\_inline宏，其内容就是inline，一个\_\_must\_check，其内容是在gcc3和gcc4版本里为\_\_attribute\_\_((warn\_unused\_result))

其中might\_sleep同上面\_\_user时候的注释。

最终调用的是\_\_copy\_to\_user\_inatomic(to, from, n)来完成拷贝工作的，此函数的实现如下(在/include/asm-i386/uaccess.h中)：

static \_\_always\_inline unsigned long \_\_must\_check

\_\_copy\_to\_user\_inatomic(void \_\_user \*to, const void \*from, unsigned long n)

if (\_\_builtin\_constant\_p(n)) \{

unsigned long ret;

switch (n) \{

case 1:

\_\_put\_user\_size(\*(u8 \*)from, (u8 \_\_user \*)to, 1, ret, 1);

return ret;

case 2:

\_\_put\_user\_size(\*(u16 \*)from, (u16 \_\_user \*)to, 2, ret, 2);

return ret;

case 4:

\_\_put\_user\_size(\*(u32 \*)from, (u32 \_\_user \*)to, 4, ret, 4);

return ret;

return \_\_copy\_to\_user\_ll(to, from, n);

其中\_\_builtin\_constant\_p(n)为gcc的内建函数，\_\_builtin\_constant\_p用于判断一个值是否为编译时常熟，如果参数n的值为常数，函数返回1，否则返回0。很多计算或操作在参数为常数时有更优化的实现，在 GNU C 中用上面的方法可以根据参数是否为常数，只编译常数版本或非常数版本，这样既不失通用性，又能在参数是常数时编译出最优化的代码。

如果n为常数1、2或者4，就会选择某个swith来执行拷贝动作，拷贝是通过如下函数来实现的(在/include/asm-i386/uaccess.h中)：

\#ifdef CONFIG\_X86\_WP\_WORKS\_OK

\#define \_\_put\_user\_size(x,ptr,size,retval,errret)           /

do \{                                     /

retval = 0;                         /

\_\_chk\_user\_ptr(ptr);                        /

switch (size) \{                          /

case 1: \_\_put\_user\_asm(x,ptr,retval,"b","b","iq",errret);break; /

case 2: \_\_put\_user\_asm(x,ptr,retval,"w","w","ir",errret);break; /

case 4: \_\_put\_user\_asm(x,ptr,retval,"l","","ir",errret); break; /

case 8: \_\_put\_user\_u64((\_\_typeof\_\_(\*ptr))(x),ptr,retval); break;/

default: \_\_put\_user\_bad();                /

\}                               /

\} while (0)

\#else

\#define \_\_put\_user\_size(x,ptr,size,retval,errret)           /

do \{                                     /

\_\_typeof\_\_(\*(ptr)) \_\_pus\_tmp = x;               /

retval = 0;                         /

if(unlikely(\_\_copy\_to\_user\_ll(ptr, &\_\_pus\_tmp, size) != 0)) /

retval = errret;                    /

\} while (0)

\#endif

其中\_\_put\_user\_asm为一个宏，拷贝工作是通过如下的内联汇编来实现的(在/include/asm-i386/uaccess.h中)：

\#define \_\_put\_user\_asm(x, addr, err, itype, rtype, ltype, errret)   /

\_\_asm\_\_ \_\_volatile\_\_(                       /

"1: mov"itype" %"rtype"1,%2/n"          /

"2:/n"                          /

".section .fixup,/"ax/"/n"              /

"3: movl %3,%0/n"                   /

"   jmp 2b/n"                   /

".previous/n"                       /

".section \_\_ex\_table,/"a/"/n"               /

"   .align 4/n"                 /

"   .long 1b,3b/n"                  /

".previous"                     /

: "=r"(err)                     /

: ltype (x), "m"(\_\_m(addr)), "i"(errret), "0"(err))

以上这两个函数是为了在拷贝小字节数据比如char/int等数据的时候考虑到效率来实现小数据拷贝。

而若n不是如上所说的常数，则进行数据块区域拷贝，其实现如下(~/arch/i386/lib/usercopy.c)：

unsigned long \_\_copy\_to\_user\_ll(void \_\_user \*to, const void \*from, unsigned long n)

BUG\_ON((long) n < 0);

\#ifndef CONFIG\_X86\_WP\_WORKS\_OK

if (unlikely(boot\_cpu\_data.wp\_works\_ok == 0) &&

((unsigned long )to) < TASK\_SIZE) \{

/\*

\* CPU does not honor the WP bit when writing

\* from supervisory mode, and due to preemption or SMP,

\* the page tables can change at any time.

\* Do it manually. Manfred <manfred@colorfullife.com>

\*/

while (n) \{

unsigned long offset = ((unsigned long)to)%PAGE\_SIZE;

unsigned long len = PAGE\_SIZE - offset;

int retval;

struct page \*pg;

void \*maddr;

if (len > n)

len = n;

survive:

down\_read(&current->mm->mmap\_sem);

retval = get\_user\_pages(current, current->mm,

(unsigned long )to, 1, 1, 0, &pg, NULL);

if (retval == -ENOMEM && current->pid == 1) \{

up\_read(&current->mm->mmap\_sem);

blk\_congestion\_wait(WRITE, HZ/50);

goto survive;

if (retval != 1) \{

up\_read(&current->mm->mmap\_sem);

break;

maddr = kmap\_atomic(pg, KM\_USER0);

memcpy(maddr + offset, from, len);

kunmap\_atomic(maddr, KM\_USER0);

set\_page\_dirty\_lock(pg);

put\_page(pg);

up\_read(&current->mm->mmap\_sem);

from += len;

to += len;

n -= len;

return n;

\#endif

if (movsl\_is\_ok(to, from, n))

\_\_copy\_user(to, from, n);

else

n = \_\_copy\_user\_intel(to, from, n);

return n;

EXPORT\_SYMBOL(\_\_copy\_to\_user\_ll);

下面是copy\_from\_user函数的实现：

unsigned long

copy\_from\_user(void \*to, const void \_\_user \*from, unsigned long n)

might\_sleep();

BUG\_ON((long) n < 0);

if (access\_ok(VERIFY\_READ, from, n))

n = \_\_copy\_from\_user(to, from, n);

else

memset(to, 0, n);

return n;

EXPORT\_SYMBOL(copy\_from\_user);

其实现方式与copy\_to\_user函数的实现方式类似：就不再累述了。

如上就是copy\_to\_user和copy\_from\_user两个函数的工作方式，这些进行简单的分析与跟踪。细节的部分还有待于进一步研究。

copy\_to\_user与mmap的工作原理

copy\_to\_user在每次拷贝时需要检测指针的合法性，也就是用户空间的指针所指向的地址的确是一段该进程本身的地址，而不是指向了不属于它的地方，而且每次都会拷贝一次数据，频繁访问内存，由于虚拟地址连续，物理地址不一定会连续，从而造成CPU的CACHE频繁失效，从而使速度降低     
  mmap仅在第一次使用时为进程建立页表，也就是将一段物理地址映射到一段虚拟地址上，以后操作时不再检测其地址的合法性（合法性交由CPU页保护异常来做），另一方面是内核下直接操作mmap地址，可以不用频繁拷贝，也就是说在内核下直接可用指针向该地址操作，而不再在内核中专门开一个缓冲区，然后将缓冲区中的数据拷贝一次进来,mmap一般是将一段连续的物理地址映射成一段虚拟地址，当然，也可以将每段连续，但各段不连续的物理地址映射成一段连续的虚拟地址，无论如何，其物理地址在每段之中是连续的，这样一来，就不会造成CPU的CACHE频繁失效，从而大大节约时间。

[http_unixwiz.net_techtips_gnu-c-attributes.html]: http://unixwiz.net/techtips/gnu-c-attributes.html