在內核的學習中會遇到很多挺有意思的函數，而且能沿着一個函數扯出來很多個相關的函數。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()!/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 <[email protected]>
*/
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