kernel地址转换的函数

这个在编程的时候常用。 一定搞清楚他们之间的关系。 

    struct page * buffer_page;
    unsigned long buffer_virt;
    buffer_virt = get_zeroed_page(GFP_ATOMIC))) {
    buffer_page = virt_to_page(buffer_virt);


    unsigned long get_zeroed_page(unsigned int gfp_mask)
{
    struct page * page;

    page = alloc_pages(gfp_mask, 0);
    if (page) {
        void *address = page_address(page);
        clear_page(address);
        return (unsigned long) address;
    }
    return 0;
}
/*
 * Common helper functions.
 */
unsigned long __get_free_pages(unsigned int gfp_mask, unsigned int order)
{
    struct page * page;

    page = alloc_pages(gfp_mask, order);
    if (!page)
        return 0;
    return (unsigned long) page_address(page);
}

#define TryLockPage(page)    test_and_set_bit(PG_locked, &(page)->flags)
#define PageChecked(page)    test_bit(PG_checked, &(page)->flags)
#define SetPageChecked(page)    set_bit(PG_checked, &(page)->flags)
#define PageLaunder(page)    test_bit(PG_launder, &(page)->flags)
#define SetPageLaunder(page)    set_bit(PG_launder, &(page)->flags)
#define ClearPageLaunder(page)    clear_bit(PG_launder, &(page)->flags)

//关于调用wait函数的代码

/*
 * Calling wait_on_buffer() for a zero-ref buffer is illegal, so we call into
 * __wait_on_buffer() just to trip a debug check. Because debug code in inline
 * functions is bloaty.
 */
static inline void wait_on_buffer(struct buffer_head *bh)
{
    might_sleep();
    if (buffer_locked(bh) || atomic_read(&bh->b_count) == 0) 
        /* if a block is locked , it says kernel is transfering data into it
         * so we must wait for the bit has been cleared successfully 
         * bob
         */
        __wait_on_buffer(bh);
}

/*
 * Note that the real wait_on_buffer() is an inline function that checks
 * that the buffer is locked before calling this, so that unnecessary disk
 * unplugging does not occur.
 */
void __wait_on_buffer(struct buffer_head * bh)
{
    struct task_struct *tsk = current;
    DECLARE_WAITQUEUE(wait, tsk);

    get_bh(bh);
    add_wait_queue(&bh->b_wait, &wait);
    
    /* in fact , here we use do {} while(condition) is better than for(;;) 
     * because ,after "schedule()" ,maybe condition(buffer_locked()) has been applied
     * then the loop can directly break 
     * --bob
     */
    do {
        run_task_queue(&tq_disk);
        set_task_state(tsk, TASK_UNINTERRUPTIBLE);
        if (!buffer_locked(bh))
            break;
        schedule();
    } while (buffer_locked(bh)); 
    
    tsk->state = TASK_RUNNING;
    remove_wait_queue(&bh->b_wait, &wait);
    put_bh(bh);
}