copy_to_user和copy_from_user兩個函數的分析

在核心的學習中會遇到很多挺有意思的函數，而且能沿着一個函數扯出來很多個相關的函數。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) {

        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頻繁失效，進而大大節約時間。

本文來自CSDN部落格，轉載請标明出處：http://blog.csdn.net/yangdelong/archive/2010/04/15/5491097.aspx