自己写驱动之Linux设备驱动开发详解———设备驱动概述    在内核的学习中会遇到很多挺有意思的函数，而且能沿着一个函数扯出来很多个相关的函数。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 接下来我们看一下 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()! ", __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 "                   "2: "                                   ".section .fixup,"ax" "                       "3: movl %3,%0 "                            "   jmp 2b "                            ".previous "                                ".section __ex_table,"a" "                        "   .align 4 "                          "   .long 1b,3b "                           ".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) {                 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(¤t->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(¤t->mm->mmap_sem);                 blk_congestion_wait(WRITE, HZ/50);                 goto survive;             }               if (retval != 1) {                 up_read(¤t->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(¤t->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频繁失效，从而大大节约时间。
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/yangdelong/archive/2010/04/15/5491097.aspx