Subversion Repositories or1k_old

#ifndef _LINUX_PAGEMAP_H

#define _LINUX_PAGEMAP_H

#include <asm/system.h>

/*

 * Page-mapping primitive inline functions

 *

 * Copyright 1995 Linus Torvalds

 */

#include <linux/config.h>

#include <linux/mm.h>

#include <linux/fs.h>

#include <linux/swapctl.h>

static inline unsigned long page_address(struct page * page)

{

        return PAGE_OFFSET + PAGE_SIZE * page->map_nr;

}

#ifdef CONFIG_REDUCED_MEMORY

#define PAGE_HASH_BITS 6 /* originally 11 = 8192, 6 = 256 */

#else /* !CONFIG_REDUCED_MEMORY */

#define PAGE_HASH_BITS 11 

#endif /* !CONFIG_REDUCED_MEMORY */

#define PAGE_HASH_SIZE (1 << PAGE_HASH_BITS)

#define PAGE_AGE_VALUE ((PAGE_INITIAL_AGE)+(PAGE_ADVANCE))

extern unsigned long page_cache_size; /* # of pages currently in the hash table */

extern struct page * page_hash_table[PAGE_HASH_SIZE];

/*

 * We use a power-of-two hash table to avoid a modulus,

 * and get a reasonable hash by knowing roughly how the

 * inode pointer and offsets are distributed (ie, we

 * roughly know which bits are "significant")

 */

static inline unsigned long _page_hashfn(struct inode * inode, unsigned long offset)

{

#define i (((unsigned long) inode)/(sizeof(struct inode) & ~ (sizeof(struct inode) - 1)))

#define o (offset >> PAGE_SHIFT)

#define s(x) ((x)+((x)>>PAGE_HASH_BITS))

        return s(i+o) & (PAGE_HASH_SIZE-1);

#undef i

#undef o

#undef s

}

#define page_hash(inode,offset) (page_hash_table+_page_hashfn(inode,offset))

static inline struct page * __find_page(struct inode * inode, unsigned long offset, struct page *page)

{

        goto inside;

        for (;;) {

                page = page->next_hash;

inside:

                if (!page)

                        goto not_found;

                if (page->inode != inode)

                        continue;

                if (page->offset == offset)

                        break;

        }

        /* Found the page. */

        atomic_inc(&page->count);

        set_bit(PG_referenced, &page->flags);

not_found:

        return page;

}

static inline struct page *find_page(struct inode * inode, unsigned long offset)

{

        return __find_page(inode, offset, *page_hash(inode, offset));

}

static inline void remove_page_from_hash_queue(struct page * page)

{

        struct page **p;

        struct page *next_hash, *prev_hash;

        next_hash = page->next_hash;

        prev_hash = page->prev_hash;

        page->next_hash = NULL;

        page->prev_hash = NULL;

        if (next_hash)

                next_hash->prev_hash = prev_hash;

        if (prev_hash)

                prev_hash->next_hash = next_hash;

        p = page_hash(page->inode,page->offset);

        if (*p == page)

                *p = next_hash;

        page_cache_size--;

}

static inline void __add_page_to_hash_queue(struct page * page, struct page **p)

{

        page_cache_size++;

        set_bit(PG_referenced, &page->flags);

        page->age = PAGE_AGE_VALUE;

        page->prev_hash = NULL;

        if ((page->next_hash = *p) != NULL)

                page->next_hash->prev_hash = page;

        *p = page;

}

static inline void add_page_to_hash_queue(struct page * page, struct inode * inode, unsigned long offset)

{

        __add_page_to_hash_queue(page, page_hash(inode,offset));

}

static inline void remove_page_from_inode_queue(struct page * page)

{

        struct inode * inode = page->inode;

        page->inode = NULL;

        inode->i_nrpages--;

        if (inode->i_pages == page)

                inode->i_pages = page->next;

        if (page->next)

                page->next->prev = page->prev;

        if (page->prev)

                page->prev->next = page->next;

        page->next = NULL;

        page->prev = NULL;

}

static inline void add_page_to_inode_queue(struct inode * inode, struct page * page)

{

        struct page **p = &inode->i_pages;

        inode->i_nrpages++;

        page->inode = inode;

        page->prev = NULL;

        if ((page->next = *p) != NULL)

                page->next->prev = page;

        *p = page;

}

extern void __wait_on_page(struct page *);

static inline void wait_on_page(struct page * page)

{

        if (PageLocked(page))

                __wait_on_page(page);

}

extern void update_vm_cache(struct inode *, unsigned long, const char *, int);

#endif