src/sys/kern/subr_pool.c - diff

Return to subr_pool.c CVS log

Up to [cvs.NetBSD.org] / src / sys / kern

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/kern/subr_pool.c between version 1.127 and 1.128

version 1.127, 2007/02/22 06:34:44

version 1.128, 2007/03/04 06:03:07

Line 112 struct pool_item_header {

ph_pagelist; /* pool page list */

SPLAY_ENTRY(pool_item_header)

ph_node; /* Off-page page headers */

caddr_t ph_page; /* this page's address */

void * ph_page; /* this page's address */

struct timeval ph_time; /* last referenced */

union {

/* !PR_NOTOUCH */

Line 184 static void pool_cache_reclaim(struct po

static void pcg_grouplist_free(struct pool_cache_grouplist *);

static int pool_catchup(struct pool *);

static void pool_prime_page(struct pool *, caddr_t,

static void pool_prime_page(struct pool *, void *,

struct pool_item_header *);

static void pool_update_curpage(struct pool *);

Line 326 pr_item_notouch_index(const struct pool

int idx;

KASSERT(pp->pr_roflags & PR_NOTOUCH);

idx = (cp - ph->ph_page - ph->ph_off) / pp->pr_size;

idx = (cp - (char *)ph->ph_page - ph->ph_off) / pp->pr_size;

KASSERT(idx < pp->pr_itemsperpage);

return idx;

}

Line 359 pr_item_notouch_get(const struct pool *p

ph->ph_firstfree = freelist[idx];

freelist[idx] = PR_INDEX_USED;

return ph->ph_page + ph->ph_off + idx * pp->pr_size;

return (char *)ph->ph_page + ph->ph_off + idx * pp->pr_size;

}

static inline int

Line 391 pr_find_pagehead(struct pool *pp, void *

struct pool_item_header *ph, tmp;

if ((pp->pr_roflags & PR_NOALIGN) != 0) {

tmp.ph_page = (caddr_t)(uintptr_t)v;

tmp.ph_page = (void *)(uintptr_t)v;

ph = SPLAY_FIND(phtree, &pp->pr_phtree, &tmp);

if (ph == NULL) {

ph = SPLAY_ROOT(&pp->pr_phtree);

Line 401 pr_find_pagehead(struct pool *pp, void *

KASSERT(ph == NULL || phtree_compare(&tmp, ph) < 0);

}

} else {

caddr_t page =

void *page =

(caddr_t)((uintptr_t)v & pp->pr_alloc->pa_pagemask);

(void *)((uintptr_t)v & pp->pr_alloc->pa_pagemask);

if ((pp->pr_roflags & PR_PHINPAGE) != 0) {

ph = (void *)(page + pp->pr_phoffset);

ph = (struct pool_item_header *)((char *)page + pp->pr_phoffset);

} else {

tmp.ph_page = page;

ph = SPLAY_FIND(phtree, &pp->pr_phtree, &tmp);

Line 413 pr_find_pagehead(struct pool *pp, void *

}

KASSERT(ph == NULL || ((pp->pr_roflags & PR_PHINPAGE) != 0) ||

(ph->ph_page <= (char *)v &&

((char *)ph->ph_page <= (char *)v &&

(char *)v < ph->ph_page + pp->pr_alloc->pa_pagesz));

(char *)v < (char *)ph->ph_page + pp->pr_alloc->pa_pagesz));

return ph;

}

Line 887 pool_set_drain_hook(struct pool *pp, voi

}

static struct pool_item_header *

pool_alloc_item_header(struct pool *pp, caddr_t storage, int flags)

pool_alloc_item_header(struct pool *pp, void *storage, int flags)

{

struct pool_item_header *ph;

int s;

Line 895 pool_alloc_item_header(struct pool *pp,

LOCK_ASSERT(simple_lock_held(&pp->pr_slock) == 0);

if ((pp->pr_roflags & PR_PHINPAGE) != 0)

ph = (struct pool_item_header *) (storage + pp->pr_phoffset);

ph = (struct pool_item_header *) ((char *)storage + pp->pr_phoffset);

else {

s = splvm();

ph = pool_get(pp->pr_phpool, flags);

Line 1170 pool_do_put(struct pool *pp, void *v, st

* Check if we're freeing a locked simple lock.

simple_lock_freecheck((caddr_t)pi, ((caddr_t)pi) + pp->pr_size);

simple_lock_freecheck(pi, (char *)pi + pp->pr_size);

#endif

Line 1208 pool_do_put(struct pool *pp, void *v, st

pp->pr_flags &= ~PR_WANTED;

if (ph->ph_nmissing == 0)

pp->pr_nidle++;

wakeup((caddr_t)pp);

wakeup((void *)pp);

return;

}

Line 1370 pool_prime(struct pool *pp, int n)

* Note, we must be called with the pool descriptor LOCKED.

static void

pool_prime_page(struct pool *pp, caddr_t storage, struct pool_item_header *ph)

pool_prime_page(struct pool *pp, void *storage, struct pool_item_header *ph)

{

struct pool_item *pi;

caddr_t cp = storage;

void *cp = storage;

const unsigned int align = pp->pr_align;

const unsigned int ioff = pp->pr_itemoffset;

int n;

Line 1402 pool_prime_page(struct pool *pp, caddr_t

* Color this page.

cp = (caddr_t)(cp + pp->pr_curcolor);

cp = (char *)cp + pp->pr_curcolor;

if ((pp->pr_curcolor += align) > pp->pr_maxcolor)

pp->pr_curcolor = 0;

Line 1410 pool_prime_page(struct pool *pp, caddr_t

* Adjust storage to apply aligment to `pr_itemoffset' in each item.

if (ioff != 0)

cp = (caddr_t)(cp + (align - ioff));

cp = (char *)cp + align - ioff;

KASSERT((((vaddr_t)cp + ioff) & (align - 1)) == 0);

Line 1424 pool_prime_page(struct pool *pp, caddr_t

pool_item_freelist_t *freelist = PR_FREELIST(ph);

int i;

ph->ph_off = cp - storage;

ph->ph_off = (char *)cp - (char *)storage;

ph->ph_firstfree = 0;

for (i = 0; i < n - 1; i++)

freelist[i] = i + 1;

Line 1440 pool_prime_page(struct pool *pp, caddr_t

#ifdef DIAGNOSTIC

pi->pi_magic = PI_MAGIC;

#endif

cp = (caddr_t)(cp + pp->pr_size);

cp = (char *)cp + pp->pr_size;

KASSERT((((vaddr_t)cp + ioff) & (align - 1)) == 0);

}

Line 1843 static int

pool_chk_page(struct pool *pp, const char *label, struct pool_item_header *ph)

{

struct pool_item *pi;

caddr_t page;

void *page;

int n;

if ((pp->pr_roflags & PR_NOALIGN) == 0) {

page = (caddr_t)((uintptr_t)ph & pp->pr_alloc->pa_pagemask);

page = (void *)((uintptr_t)ph & pp->pr_alloc->pa_pagemask);

if (page != ph->ph_page &&

(pp->pr_roflags & PR_PHINPAGE) != 0) {

if (label != NULL)

Line 1881 pool_chk_page(struct pool *pp, const cha

if ((pp->pr_roflags & PR_NOALIGN) != 0) {

continue;

}

page = (caddr_t)((uintptr_t)pi & pp->pr_alloc->pa_pagemask);

page = (void *)((uintptr_t)pi & pp->pr_alloc->pa_pagemask);

if (page == ph->ph_page)

continue;

CVSweb <webmaster@jp.NetBSD.org>