copy_to_user和copy_from_user两个函数的分析

fengyetang

               

  Normal
  0
  
  7.8 磅
  0
  2
  
  false
  false
  false
  
   
   
   
   
   
   
   
   
   
   
   
   
  
  MicrosoftInternetExplorer4



/* Style Definitions */
table.MsoNormalTable
        {mso-style-name:普通表格;
        mso-tstyle-rowband-size:0;
        mso-tstyle-colband-size:0;
        mso-style-noshow:yes;
        mso-style-parent:"";
        mso-padding-alt:0cm 5.4pt 0cm 5.4pt;
        mso-para-margin:0cm;
        mso-para-margin-bottom:.0001pt;
        mso-pagination:widow-orphan;
        font-size:10.0pt;
        font-family:"Times New Roman";
        mso-fareast-font-family:"Times New Roman";
        mso-ansi-language:#0400;
        mso-fareast-language:#0400;
        mso-bidi-language:#0400;}
在内核的学习中会遇到很多挺有意思的函数，而且能沿着一个函数扯出来很多个相关的函数。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
       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
接下来我们看一下
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
其实现为如下(在~/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
#ifndef CONFIG_X86_WP_WORKS_OK
    if (unlikely(boot_cpu_data.wp_works_ok
== 0) &&
            ((unsigned long )to)
        /*
         * 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
         */
        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
       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两个函数的工作方式，这些进行简单的分析与跟踪。细节的部分还有待于进一步研究。

               
               

本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u1/58901/showart_1934008.html