[BACK]Return to subr_pool.c CVS log [TXT][DIR] 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.87 and 1.87.2.1

version 1.87, 2003/04/09 18:22:13 version 1.87.2.1, 2004/08/03 10:52:55
Line 59  __KERNEL_RCSID(0, "$NetBSD$");
Line 59  __KERNEL_RCSID(0, "$NetBSD$");
 /*  /*
  * Pool resource management utility.   * Pool resource management utility.
  *   *
  * Memory is allocated in pages which are split into pieces according   * Memory is allocated in pages which are split into pieces according to
  * to the pool item size. Each page is kept on a list headed by `pr_pagelist'   * the pool item size. Each page is kept on one of three lists in the
  * in the pool structure and the individual pool items are on a linked list   * pool structure: `pr_emptypages', `pr_fullpages' and `pr_partpages',
  * headed by `ph_itemlist' in each page header. The memory for building   * for empty, full and partially-full pages respectively. The individual
  * the page list is either taken from the allocated pages themselves (for   * pool items are on a linked list headed by `ph_itemlist' in each page
  * small pool items) or taken from an internal pool of page headers (`phpool').   * header. The memory for building the page list is either taken from
    * the allocated pages themselves (for small pool items) or taken from
    * an internal pool of page headers (`phpool').
  */   */
   
 /* List of all pools */  /* List of all pools */
Line 89  struct simplelock pool_head_slock = SIMP
Line 91  struct simplelock pool_head_slock = SIMP
   
 struct pool_item_header {  struct pool_item_header {
         /* Page headers */          /* Page headers */
         TAILQ_ENTRY(pool_item_header)          LIST_ENTRY(pool_item_header)
                                 ph_pagelist;    /* pool page list */                                  ph_pagelist;    /* pool page list */
         TAILQ_HEAD(,pool_item)  ph_itemlist;    /* chunk list for this page */          TAILQ_HEAD(,pool_item)  ph_itemlist;    /* chunk list for this page */
         LIST_ENTRY(pool_item_header)          SPLAY_ENTRY(pool_item_header)
                                 ph_hashlist;    /* Off-page page headers */                                  ph_node;        /* Off-page page headers */
         unsigned int            ph_nmissing;    /* # of chunks in use */          unsigned int            ph_nmissing;    /* # of chunks in use */
         caddr_t                 ph_page;        /* this page's address */          caddr_t                 ph_page;        /* this page's address */
         struct timeval          ph_time;        /* last referenced */          struct timeval          ph_time;        /* last referenced */
 };  };
 TAILQ_HEAD(pool_pagelist,pool_item_header);  
   
 struct pool_item {  struct pool_item {
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
Line 109  struct pool_item {
Line 110  struct pool_item {
         TAILQ_ENTRY(pool_item)  pi_list;          TAILQ_ENTRY(pool_item)  pi_list;
 };  };
   
 #define PR_HASH_INDEX(pp,addr) \  
         (((u_long)(addr) >> (pp)->pr_alloc->pa_pageshift) & \  
          (PR_HASHTABSIZE - 1))  
   
 #define POOL_NEEDS_CATCHUP(pp)                                          \  #define POOL_NEEDS_CATCHUP(pp)                                          \
         ((pp)->pr_nitems < (pp)->pr_minitems)          ((pp)->pr_nitems < (pp)->pr_minitems)
   
Line 150  static void pool_cache_reclaim(struct po
Line 147  static void pool_cache_reclaim(struct po
 static int      pool_catchup(struct pool *);  static int      pool_catchup(struct pool *);
 static void     pool_prime_page(struct pool *, caddr_t,  static void     pool_prime_page(struct pool *, caddr_t,
                     struct pool_item_header *);                      struct pool_item_header *);
   static void     pool_update_curpage(struct pool *);
   
 void            *pool_allocator_alloc(struct pool *, int);  void            *pool_allocator_alloc(struct pool *, int);
 void            pool_allocator_free(struct pool *, void *);  void            pool_allocator_free(struct pool *, void *);
   
   static void pool_print_pagelist(struct pool_pagelist *,
           void (*)(const char *, ...));
 static void pool_print1(struct pool *, const char *,  static void pool_print1(struct pool *, const char *,
         void (*)(const char *, ...));          void (*)(const char *, ...));
   
   static int pool_chk_page(struct pool *, const char *,
                            struct pool_item_header *);
   
 /*  /*
  * Pool log entry. An array of these is allocated in pool_init().   * Pool log entry. An array of these is allocated in pool_init().
  */   */
Line 275  pr_enter_check(struct pool *pp, void (*p
Line 278  pr_enter_check(struct pool *pp, void (*p
 #define pr_enter_check(pp, pr)  #define pr_enter_check(pp, pr)
 #endif /* POOL_DIAGNOSTIC */  #endif /* POOL_DIAGNOSTIC */
   
   static __inline int
   phtree_compare(struct pool_item_header *a, struct pool_item_header *b)
   {
           if (a->ph_page < b->ph_page)
                   return (-1);
           else if (a->ph_page > b->ph_page)
                   return (1);
           else
                   return (0);
   }
   
   SPLAY_PROTOTYPE(phtree, pool_item_header, ph_node, phtree_compare);
   SPLAY_GENERATE(phtree, pool_item_header, ph_node, phtree_compare);
   
 /*  /*
  * Return the pool page header based on page address.   * Return the pool page header based on page address.
  */   */
 static __inline struct pool_item_header *  static __inline struct pool_item_header *
 pr_find_pagehead(struct pool *pp, caddr_t page)  pr_find_pagehead(struct pool *pp, caddr_t page)
 {  {
         struct pool_item_header *ph;          struct pool_item_header *ph, tmp;
   
         if ((pp->pr_roflags & PR_PHINPAGE) != 0)          if ((pp->pr_roflags & PR_PHINPAGE) != 0)
                 return ((struct pool_item_header *)(page + pp->pr_phoffset));                  return ((struct pool_item_header *)(page + pp->pr_phoffset));
   
         for (ph = LIST_FIRST(&pp->pr_hashtab[PR_HASH_INDEX(pp, page)]);          tmp.ph_page = page;
              ph != NULL;          ph = SPLAY_FIND(phtree, &pp->pr_phtree, &tmp);
              ph = LIST_NEXT(ph, ph_hashlist)) {          return ph;
                 if (ph->ph_page == page)  
                         return (ph);  
         }  
         return (NULL);  
 }  }
   
 /*  /*
Line 304  pr_rmpage(struct pool *pp, struct pool_i
Line 317  pr_rmpage(struct pool *pp, struct pool_i
 {  {
         int s;          int s;
   
           LOCK_ASSERT(!simple_lock_held(&pp->pr_slock) || pq != NULL);
   
         /*          /*
          * If the page was idle, decrement the idle page count.           * If the page was idle, decrement the idle page count.
          */           */
Line 322  pr_rmpage(struct pool *pp, struct pool_i
Line 337  pr_rmpage(struct pool *pp, struct pool_i
         /*          /*
          * Unlink a page from the pool and release it (or queue it for release).           * Unlink a page from the pool and release it (or queue it for release).
          */           */
         TAILQ_REMOVE(&pp->pr_pagelist, ph, ph_pagelist);          LIST_REMOVE(ph, ph_pagelist);
           if ((pp->pr_roflags & PR_PHINPAGE) == 0)
                   SPLAY_REMOVE(phtree, &pp->pr_phtree, ph);
         if (pq) {          if (pq) {
                 TAILQ_INSERT_HEAD(pq, ph, ph_pagelist);                  LIST_INSERT_HEAD(pq, ph, ph_pagelist);
         } else {          } else {
                 pool_allocator_free(pp, ph->ph_page);                  pool_allocator_free(pp, ph->ph_page);
                 if ((pp->pr_roflags & PR_PHINPAGE) == 0) {                  if ((pp->pr_roflags & PR_PHINPAGE) == 0) {
                         LIST_REMOVE(ph, ph_hashlist);  
                         s = splvm();                          s = splvm();
                         pool_put(&phpool, ph);                          pool_put(&phpool, ph);
                         splx(s);                          splx(s);
Line 337  pr_rmpage(struct pool *pp, struct pool_i
Line 353  pr_rmpage(struct pool *pp, struct pool_i
         pp->pr_npages--;          pp->pr_npages--;
         pp->pr_npagefree++;          pp->pr_npagefree++;
   
         if (pp->pr_curpage == ph) {          pool_update_curpage(pp);
                 /*  }
                  * Find a new non-empty page header, if any.  
                  * Start search from the page head, to increase the  
                  * chance for "high water" pages to be freed.  
                  */  
                 TAILQ_FOREACH(ph, &pp->pr_pagelist, ph_pagelist)  
                         if (TAILQ_FIRST(&ph->ph_itemlist) != NULL)  
                                 break;  
   
                 pp->pr_curpage = ph;  /*
         }   * Initialize all the pools listed in the "pools" link set.
    */
   void
   link_pool_init(void)
   {
           __link_set_decl(pools, struct link_pool_init);
           struct link_pool_init * const *pi;
   
           __link_set_foreach(pi, pools)
                   pool_init((*pi)->pp, (*pi)->size, (*pi)->align,
                       (*pi)->align_offset, (*pi)->flags, (*pi)->wchan,
                       (*pi)->palloc);
 }  }
   
 /*  /*
Line 361  void
Line 381  void
 pool_init(struct pool *pp, size_t size, u_int align, u_int ioff, int flags,  pool_init(struct pool *pp, size_t size, u_int align, u_int ioff, int flags,
     const char *wchan, struct pool_allocator *palloc)      const char *wchan, struct pool_allocator *palloc)
 {  {
         int off, slack, i;          int off, slack;
           size_t trysize, phsize;
           int s;
   
 #ifdef POOL_DIAGNOSTIC  #ifdef POOL_DIAGNOSTIC
         /*          /*
Line 425  pool_init(struct pool *pp, size_t size, 
Line 447  pool_init(struct pool *pp, size_t size, 
         /*          /*
          * Initialize the pool structure.           * Initialize the pool structure.
          */           */
         TAILQ_INIT(&pp->pr_pagelist);          LIST_INIT(&pp->pr_emptypages);
           LIST_INIT(&pp->pr_fullpages);
           LIST_INIT(&pp->pr_partpages);
         TAILQ_INIT(&pp->pr_cachelist);          TAILQ_INIT(&pp->pr_cachelist);
         pp->pr_curpage = NULL;          pp->pr_curpage = NULL;
         pp->pr_npages = 0;          pp->pr_npages = 0;
Line 451  pool_init(struct pool *pp, size_t size, 
Line 475  pool_init(struct pool *pp, size_t size, 
   
         /*          /*
          * Decide whether to put the page header off page to avoid           * Decide whether to put the page header off page to avoid
          * wasting too large a part of the page. Off-page page headers           * wasting too large a part of the page or too big item.
          * go on a hash table, so we can match a returned item           * Off-page page headers go on a hash table, so we can match
          * with its header based on the page address.           * a returned item with its header based on the page address.
          * We use 1/16 of the page size as the threshold (XXX: tune)           * We use 1/16 of the page size and about 8 times of the item
            * size as the threshold (XXX: tune)
            *
            * However, we'll put the header into the page if we can put
            * it without wasting any items.
            *
            * Silently enforce `0 <= ioff < align'.
          */           */
         if (pp->pr_size < palloc->pa_pagesz/16) {          pp->pr_itemoffset = ioff %= align;
           /* See the comment below about reserved bytes. */
           trysize = palloc->pa_pagesz - ((align - ioff) % align);
           phsize = ALIGN(sizeof(struct pool_item_header));
           if (pp->pr_size < MIN(palloc->pa_pagesz / 16, phsize << 3) ||
               trysize / pp->pr_size == (trysize - phsize) / pp->pr_size) {
                 /* Use the end of the page for the page header */                  /* Use the end of the page for the page header */
                 pp->pr_roflags |= PR_PHINPAGE;                  pp->pr_roflags |= PR_PHINPAGE;
                 pp->pr_phoffset = off = palloc->pa_pagesz -                  pp->pr_phoffset = off = palloc->pa_pagesz - phsize;
                     ALIGN(sizeof(struct pool_item_header));  
         } else {          } else {
                 /* The page header will be taken from our page header pool */                  /* The page header will be taken from our page header pool */
                 pp->pr_phoffset = 0;                  pp->pr_phoffset = 0;
                 off = palloc->pa_pagesz;                  off = palloc->pa_pagesz;
                 for (i = 0; i < PR_HASHTABSIZE; i++) {                  SPLAY_INIT(&pp->pr_phtree);
                         LIST_INIT(&pp->pr_hashtab[i]);  
                 }  
         }          }
   
         /*          /*
          * Alignment is to take place at `ioff' within the item. This means           * Alignment is to take place at `ioff' within the item. This means
          * we must reserve up to `align - 1' bytes on the page to allow           * we must reserve up to `align - 1' bytes on the page to allow
          * appropriate positioning of each item.           * appropriate positioning of each item.
          *  
          * Silently enforce `0 <= ioff < align'.  
          */           */
         pp->pr_itemoffset = ioff = ioff % align;  
         pp->pr_itemsperpage = (off - ((align - ioff) % align)) / pp->pr_size;          pp->pr_itemsperpage = (off - ((align - ioff) % align)) / pp->pr_size;
         KASSERT(pp->pr_itemsperpage != 0);          KASSERT(pp->pr_itemsperpage != 0);
   
Line 538  pool_init(struct pool *pp, size_t size, 
Line 567  pool_init(struct pool *pp, size_t size, 
         simple_unlock(&pool_head_slock);          simple_unlock(&pool_head_slock);
   
         /* Insert this into the list of pools using this allocator. */          /* Insert this into the list of pools using this allocator. */
           s = splvm();
         simple_lock(&palloc->pa_slock);          simple_lock(&palloc->pa_slock);
         TAILQ_INSERT_TAIL(&palloc->pa_list, pp, pr_alloc_list);          TAILQ_INSERT_TAIL(&palloc->pa_list, pp, pr_alloc_list);
         simple_unlock(&palloc->pa_slock);          simple_unlock(&palloc->pa_slock);
           splx(s);
 }  }
   
 /*  /*
Line 551  pool_destroy(struct pool *pp)
Line 582  pool_destroy(struct pool *pp)
 {  {
         struct pool_item_header *ph;          struct pool_item_header *ph;
         struct pool_cache *pc;          struct pool_cache *pc;
           int s;
   
         /* Locking order: pool_allocator -> pool */          /* Locking order: pool_allocator -> pool */
           s = splvm();
         simple_lock(&pp->pr_alloc->pa_slock);          simple_lock(&pp->pr_alloc->pa_slock);
         TAILQ_REMOVE(&pp->pr_alloc->pa_list, pp, pr_alloc_list);          TAILQ_REMOVE(&pp->pr_alloc->pa_list, pp, pr_alloc_list);
         simple_unlock(&pp->pr_alloc->pa_slock);          simple_unlock(&pp->pr_alloc->pa_slock);
           splx(s);
   
         /* Destroy all caches for this pool. */          /* Destroy all caches for this pool. */
         while ((pc = TAILQ_FIRST(&pp->pr_cachelist)) != NULL)          while ((pc = TAILQ_FIRST(&pp->pr_cachelist)) != NULL)
Line 570  pool_destroy(struct pool *pp)
Line 604  pool_destroy(struct pool *pp)
 #endif  #endif
   
         /* Remove all pages */          /* Remove all pages */
         while ((ph = TAILQ_FIRST(&pp->pr_pagelist)) != NULL)          while ((ph = LIST_FIRST(&pp->pr_emptypages)) != NULL)
                 pr_rmpage(pp, ph, NULL);                  pr_rmpage(pp, ph, NULL);
           KASSERT(LIST_EMPTY(&pp->pr_fullpages));
           KASSERT(LIST_EMPTY(&pp->pr_partpages));
   
         /* Remove from global pool list */          /* Remove from global pool list */
         simple_lock(&pool_head_slock);          simple_lock(&pool_head_slock);
Line 600  pool_set_drain_hook(struct pool *pp, voi
Line 636  pool_set_drain_hook(struct pool *pp, voi
         pp->pr_drain_hook_arg = arg;          pp->pr_drain_hook_arg = arg;
 }  }
   
 static __inline struct pool_item_header *  static struct pool_item_header *
 pool_alloc_item_header(struct pool *pp, caddr_t storage, int flags)  pool_alloc_item_header(struct pool *pp, caddr_t storage, int flags)
 {  {
         struct pool_item_header *ph;          struct pool_item_header *ph;
Line 634  pool_get(struct pool *pp, int flags)
Line 670  pool_get(struct pool *pp, int flags)
         void *v;          void *v;
   
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
           if (__predict_false(pp->pr_itemsperpage == 0))
                   panic("pool_get: pool %p: pr_itemsperpage is zero, "
                       "pool not initialized?", pp);
         if (__predict_false(curlwp == NULL && doing_shutdown == 0 &&          if (__predict_false(curlwp == NULL && doing_shutdown == 0 &&
                             (flags & PR_WAITOK) != 0))                              (flags & PR_WAITOK) != 0))
                 panic("pool_get: %s: must have NOWAIT", pp->pr_wchan);                  panic("pool_get: %s: must have NOWAIT", pp->pr_wchan);
Line 729  pool_get(struct pool *pp, int flags)
Line 768  pool_get(struct pool *pp, int flags)
                 v = pool_allocator_alloc(pp, flags);                  v = pool_allocator_alloc(pp, flags);
                 if (__predict_true(v != NULL))                  if (__predict_true(v != NULL))
                         ph = pool_alloc_item_header(pp, v, flags);                          ph = pool_alloc_item_header(pp, v, flags);
                 simple_lock(&pp->pr_slock);  
                 pr_enter(pp, file, line);  
   
                 if (__predict_false(v == NULL || ph == NULL)) {                  if (__predict_false(v == NULL || ph == NULL)) {
                         if (v != NULL)                          if (v != NULL)
                                 pool_allocator_free(pp, v);                                  pool_allocator_free(pp, v);
   
                           simple_lock(&pp->pr_slock);
                           pr_enter(pp, file, line);
   
                         /*                          /*
                          * We were unable to allocate a page or item                           * We were unable to allocate a page or item
                          * header, but we released the lock during                           * header, but we released the lock during
Line 767  pool_get(struct pool *pp, int flags)
Line 807  pool_get(struct pool *pp, int flags)
                 }                  }
   
                 /* We have more memory; add it to the pool */                  /* We have more memory; add it to the pool */
                   simple_lock(&pp->pr_slock);
                   pr_enter(pp, file, line);
                 pool_prime_page(pp, v, ph);                  pool_prime_page(pp, v, ph);
                 pp->pr_npagealloc++;                  pp->pr_npagealloc++;
   
                 /* Start the allocation process over. */                  /* Start the allocation process over. */
                 goto startover;                  goto startover;
         }          }
   
         if (__predict_false((v = pi = TAILQ_FIRST(&ph->ph_itemlist)) == NULL)) {          if (__predict_false((v = pi = TAILQ_FIRST(&ph->ph_itemlist)) == NULL)) {
                 pr_leave(pp);                  pr_leave(pp);
                 simple_unlock(&pp->pr_slock);                  simple_unlock(&pp->pr_slock);
Line 814  pool_get(struct pool *pp, int flags)
Line 855  pool_get(struct pool *pp, int flags)
                         panic("pool_get: nidle inconsistent");                          panic("pool_get: nidle inconsistent");
 #endif  #endif
                 pp->pr_nidle--;                  pp->pr_nidle--;
   
                   /*
                    * This page was previously empty.  Move it to the list of
                    * partially-full pages.  This page is already curpage.
                    */
                   LIST_REMOVE(ph, ph_pagelist);
                   LIST_INSERT_HEAD(&pp->pr_partpages, ph, ph_pagelist);
         }          }
         ph->ph_nmissing++;          ph->ph_nmissing++;
         if (TAILQ_FIRST(&ph->ph_itemlist) == NULL) {          if (TAILQ_EMPTY(&ph->ph_itemlist)) {
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
                 if (__predict_false(ph->ph_nmissing != pp->pr_itemsperpage)) {                  if (__predict_false(ph->ph_nmissing != pp->pr_itemsperpage)) {
                         pr_leave(pp);                          pr_leave(pp);
Line 826  pool_get(struct pool *pp, int flags)
Line 874  pool_get(struct pool *pp, int flags)
                 }                  }
 #endif  #endif
                 /*                  /*
                  * Find a new non-empty page header, if any.                   * This page is now full.  Move it to the full list
                  * Start search from the page head, to increase                   * and select a new current page.
                  * the chance for "high water" pages to be freed.  
                  *  
                  * Migrate empty pages to the end of the list.  This  
                  * will speed the update of curpage as pages become  
                  * idle.  Empty pages intermingled with idle pages  
                  * is no big deal.  As soon as a page becomes un-empty,  
                  * it will move back to the head of the list.  
                  */                   */
                 TAILQ_REMOVE(&pp->pr_pagelist, ph, ph_pagelist);                  LIST_REMOVE(ph, ph_pagelist);
                 TAILQ_INSERT_TAIL(&pp->pr_pagelist, ph, ph_pagelist);                  LIST_INSERT_HEAD(&pp->pr_fullpages, ph, ph_pagelist);
                 TAILQ_FOREACH(ph, &pp->pr_pagelist, ph_pagelist)                  pool_update_curpage(pp);
                         if (TAILQ_FIRST(&ph->ph_itemlist) != NULL)  
                                 break;  
   
                 pp->pr_curpage = ph;  
         }          }
   
         pp->pr_nget++;          pp->pr_nget++;
Line 935  pool_do_put(struct pool *pp, void *v)
Line 972  pool_do_put(struct pool *pp, void *v)
         }          }
   
         /*          /*
          * If this page is now complete, do one of two things:           * If this page is now empty, do one of two things:
            *
            *      (1) If we have more pages than the page high water mark,
            *          free the page back to the system.  ONLY CONSIDER
            *          FREEING BACK A PAGE IF WE HAVE MORE THAN OUR MINIMUM PAGE
            *          CLAIM.
          *           *
          *      (1) If we have more pages than the page high water           *      (2) Otherwise, move the page to the empty page list.
          *          mark, free the page back to the system.  
          *           *
          *      (2) Move it to the end of the page list, so that           * Either way, select a new current page (so we use a partially-full
          *          we minimize our chances of fragmenting the           * page if one is available).
          *          pool.  Idle pages migrate to the end (along with  
          *          completely empty pages, so that we find un-empty  
          *          pages more quickly when we update curpage) of the  
          *          list so they can be more easily swept up by  
          *          the pagedaemon when pages are scarce.  
          */           */
         if (ph->ph_nmissing == 0) {          if (ph->ph_nmissing == 0) {
                 pp->pr_nidle++;                  pp->pr_nidle++;
                 if (pp->pr_npages > pp->pr_maxpages ||                  if (pp->pr_npages > pp->pr_minpages &&
                     (pp->pr_alloc->pa_flags & PA_WANT) != 0) {                      (pp->pr_npages > pp->pr_maxpages ||
                        (pp->pr_alloc->pa_flags & PA_WANT) != 0)) {
                           simple_unlock(&pp->pr_slock);
                         pr_rmpage(pp, ph, NULL);                          pr_rmpage(pp, ph, NULL);
                           simple_lock(&pp->pr_slock);
                 } else {                  } else {
                         TAILQ_REMOVE(&pp->pr_pagelist, ph, ph_pagelist);                          LIST_REMOVE(ph, ph_pagelist);
                         TAILQ_INSERT_TAIL(&pp->pr_pagelist, ph, ph_pagelist);                          LIST_INSERT_HEAD(&pp->pr_emptypages, ph, ph_pagelist);
   
                         /*                          /*
                          * Update the timestamp on the page.  A page must                           * Update the timestamp on the page.  A page must
Line 966  pool_do_put(struct pool *pp, void *v)
Line 1005  pool_do_put(struct pool *pp, void *v)
                         s = splclock();                          s = splclock();
                         ph->ph_time = mono_time;                          ph->ph_time = mono_time;
                         splx(s);                          splx(s);
   
                         /*  
                          * Update the current page pointer.  Just look for  
                          * the first page with any free items.  
                          *  
                          * XXX: Maybe we want an option to look for the  
                          * page with the fewest available items, to minimize  
                          * fragmentation?  
                          */  
                         TAILQ_FOREACH(ph, &pp->pr_pagelist, ph_pagelist)  
                                 if (TAILQ_FIRST(&ph->ph_itemlist) != NULL)  
                                         break;  
   
                         pp->pr_curpage = ph;  
                 }                  }
                   pool_update_curpage(pp);
         }          }
   
         /*          /*
          * If the page has just become un-empty, move it to the head of           * If the page was previously completely full, move it to the
          * the list, and make it the current page.  The next allocation           * partially-full list and make it the current page.  The next
          * will get the item from this page, instead of further fragmenting           * allocation will get the item from this page, instead of
          * the pool.           * further fragmenting the pool.
          */           */
         else if (ph->ph_nmissing == (pp->pr_itemsperpage - 1)) {          else if (ph->ph_nmissing == (pp->pr_itemsperpage - 1)) {
                 TAILQ_REMOVE(&pp->pr_pagelist, ph, ph_pagelist);                  LIST_REMOVE(ph, ph_pagelist);
                 TAILQ_INSERT_HEAD(&pp->pr_pagelist, ph, ph_pagelist);                  LIST_INSERT_HEAD(&pp->pr_partpages, ph, ph_pagelist);
                 pp->pr_curpage = ph;                  pp->pr_curpage = ph;
         }          }
 }  }
Line 1050  pool_prime(struct pool *pp, int n)
Line 1077  pool_prime(struct pool *pp, int n)
                 cp = pool_allocator_alloc(pp, PR_NOWAIT);                  cp = pool_allocator_alloc(pp, PR_NOWAIT);
                 if (__predict_true(cp != NULL))                  if (__predict_true(cp != NULL))
                         ph = pool_alloc_item_header(pp, cp, PR_NOWAIT);                          ph = pool_alloc_item_header(pp, cp, PR_NOWAIT);
                 simple_lock(&pp->pr_slock);  
   
                 if (__predict_false(cp == NULL || ph == NULL)) {                  if (__predict_false(cp == NULL || ph == NULL)) {
                         if (cp != NULL)                          if (cp != NULL)
                                 pool_allocator_free(pp, cp);                                  pool_allocator_free(pp, cp);
                           simple_lock(&pp->pr_slock);
                         break;                          break;
                 }                  }
   
                   simple_lock(&pp->pr_slock);
                 pool_prime_page(pp, cp, ph);                  pool_prime_page(pp, cp, ph);
                 pp->pr_npagealloc++;                  pp->pr_npagealloc++;
                 pp->pr_minpages++;                  pp->pr_minpages++;
Line 1083  pool_prime_page(struct pool *pp, caddr_t
Line 1111  pool_prime_page(struct pool *pp, caddr_t
         unsigned int align = pp->pr_align;          unsigned int align = pp->pr_align;
         unsigned int ioff = pp->pr_itemoffset;          unsigned int ioff = pp->pr_itemoffset;
         int n;          int n;
           int s;
   
           LOCK_ASSERT(simple_lock_held(&pp->pr_slock));
   
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
         if (((u_long)cp & (pp->pr_alloc->pa_pagesz - 1)) != 0)          if (((u_long)cp & (pp->pr_alloc->pa_pagesz - 1)) != 0)
                 panic("pool_prime_page: %s: unaligned page", pp->pr_wchan);                  panic("pool_prime_page: %s: unaligned page", pp->pr_wchan);
 #endif  #endif
   
         if ((pp->pr_roflags & PR_PHINPAGE) == 0)  
                 LIST_INSERT_HEAD(&pp->pr_hashtab[PR_HASH_INDEX(pp, cp)],  
                     ph, ph_hashlist);  
   
         /*          /*
          * Insert page header.           * Insert page header.
          */           */
         TAILQ_INSERT_HEAD(&pp->pr_pagelist, ph, ph_pagelist);          LIST_INSERT_HEAD(&pp->pr_emptypages, ph, ph_pagelist);
         TAILQ_INIT(&ph->ph_itemlist);          TAILQ_INIT(&ph->ph_itemlist);
         ph->ph_page = storage;          ph->ph_page = storage;
         ph->ph_nmissing = 0;          ph->ph_nmissing = 0;
         memset(&ph->ph_time, 0, sizeof(ph->ph_time));          s = splclock();
           ph->ph_time = mono_time;
           splx(s);
           if ((pp->pr_roflags & PR_PHINPAGE) == 0)
                   SPLAY_INSERT(phtree, &pp->pr_phtree, ph);
   
         pp->pr_nidle++;          pp->pr_nidle++;
   
Line 1148  pool_prime_page(struct pool *pp, caddr_t
Line 1179  pool_prime_page(struct pool *pp, caddr_t
   
 /*  /*
  * Used by pool_get() when nitems drops below the low water mark.  This   * Used by pool_get() when nitems drops below the low water mark.  This
  * is used to catch up nitmes with the low water mark.   * is used to catch up pr_nitems with the low water mark.
  *   *
  * Note 1, we never wait for memory here, we let the caller decide what to do.   * Note 1, we never wait for memory here, we let the caller decide what to do.
  *   *
Line 1173  pool_catchup(struct pool *pp)
Line 1204  pool_catchup(struct pool *pp)
                 cp = pool_allocator_alloc(pp, PR_NOWAIT);                  cp = pool_allocator_alloc(pp, PR_NOWAIT);
                 if (__predict_true(cp != NULL))                  if (__predict_true(cp != NULL))
                         ph = pool_alloc_item_header(pp, cp, PR_NOWAIT);                          ph = pool_alloc_item_header(pp, cp, PR_NOWAIT);
                 simple_lock(&pp->pr_slock);  
                 if (__predict_false(cp == NULL || ph == NULL)) {                  if (__predict_false(cp == NULL || ph == NULL)) {
                         if (cp != NULL)                          if (cp != NULL)
                                 pool_allocator_free(pp, cp);                                  pool_allocator_free(pp, cp);
                         error = ENOMEM;                          error = ENOMEM;
                           simple_lock(&pp->pr_slock);
                         break;                          break;
                 }                  }
                   simple_lock(&pp->pr_slock);
                 pool_prime_page(pp, cp, ph);                  pool_prime_page(pp, cp, ph);
                 pp->pr_npagealloc++;                  pp->pr_npagealloc++;
         }          }
Line 1187  pool_catchup(struct pool *pp)
Line 1219  pool_catchup(struct pool *pp)
         return (error);          return (error);
 }  }
   
   static void
   pool_update_curpage(struct pool *pp)
   {
   
           pp->pr_curpage = LIST_FIRST(&pp->pr_partpages);
           if (pp->pr_curpage == NULL) {
                   pp->pr_curpage = LIST_FIRST(&pp->pr_emptypages);
           }
   }
   
 void  void
 pool_setlowat(struct pool *pp, int n)  pool_setlowat(struct pool *pp, int n)
 {  {
Line 1260  pool_reclaim(struct pool *pp)
Line 1302  pool_reclaim(struct pool *pp)
         struct pool_cache *pc;          struct pool_cache *pc;
         struct timeval curtime;          struct timeval curtime;
         struct pool_pagelist pq;          struct pool_pagelist pq;
           struct timeval diff;
         int s;          int s;
   
         if (pp->pr_drain_hook != NULL) {          if (pp->pr_drain_hook != NULL) {
Line 1273  pool_reclaim(struct pool *pp)
Line 1316  pool_reclaim(struct pool *pp)
                 return (0);                  return (0);
         pr_enter(pp, file, line);          pr_enter(pp, file, line);
   
         TAILQ_INIT(&pq);          LIST_INIT(&pq);
   
         /*          /*
          * Reclaim items from the pool's caches.           * Reclaim items from the pool's caches.
Line 1285  pool_reclaim(struct pool *pp)
Line 1328  pool_reclaim(struct pool *pp)
         curtime = mono_time;          curtime = mono_time;
         splx(s);          splx(s);
   
         for (ph = TAILQ_FIRST(&pp->pr_pagelist); ph != NULL; ph = phnext) {          for (ph = LIST_FIRST(&pp->pr_emptypages); ph != NULL; ph = phnext) {
                 phnext = TAILQ_NEXT(ph, ph_pagelist);                  phnext = LIST_NEXT(ph, ph_pagelist);
   
                 /* Check our minimum page claim */                  /* Check our minimum page claim */
                 if (pp->pr_npages <= pp->pr_minpages)                  if (pp->pr_npages <= pp->pr_minpages)
                         break;                          break;
   
                 if (ph->ph_nmissing == 0) {                  KASSERT(ph->ph_nmissing == 0);
                         struct timeval diff;                  timersub(&curtime, &ph->ph_time, &diff);
                         timersub(&curtime, &ph->ph_time, &diff);                  if (diff.tv_sec < pool_inactive_time)
                         if (diff.tv_sec < pool_inactive_time)                          continue;
                                 continue;  
   
                         /*                  /*
                          * If freeing this page would put us below                   * If freeing this page would put us below
                          * the low water mark, stop now.                   * the low water mark, stop now.
                          */                   */
                         if ((pp->pr_nitems - pp->pr_itemsperpage) <                  if ((pp->pr_nitems - pp->pr_itemsperpage) <
                             pp->pr_minitems)                      pp->pr_minitems)
                                 break;                          break;
   
                         pr_rmpage(pp, ph, &pq);                  pr_rmpage(pp, ph, &pq);
                 }  
         }          }
   
         pr_leave(pp);          pr_leave(pp);
         simple_unlock(&pp->pr_slock);          simple_unlock(&pp->pr_slock);
         if (TAILQ_EMPTY(&pq))          if (LIST_EMPTY(&pq))
                 return (0);                  return (0);
   
         while ((ph = TAILQ_FIRST(&pq)) != NULL) {          while ((ph = LIST_FIRST(&pq)) != NULL) {
                 TAILQ_REMOVE(&pq, ph, ph_pagelist);                  LIST_REMOVE(ph, ph_pagelist);
                 pool_allocator_free(pp, ph->ph_page);                  pool_allocator_free(pp, ph->ph_page);
                 if (pp->pr_roflags & PR_PHINPAGE) {                  if (pp->pr_roflags & PR_PHINPAGE) {
                         continue;                          continue;
                 }                  }
                 LIST_REMOVE(ph, ph_hashlist);  
                 s = splvm();                  s = splvm();
                 pool_put(&phpool, ph);                  pool_put(&phpool, ph);
                 splx(s);                  splx(s);
Line 1407  pool_printit(struct pool *pp, const char
Line 1447  pool_printit(struct pool *pp, const char
 }  }
   
 static void  static void
 pool_print1(struct pool *pp, const char *modif, void (*pr)(const char *, ...))  pool_print_pagelist(struct pool_pagelist *pl, void (*pr)(const char *, ...))
 {  {
         struct pool_item_header *ph;          struct pool_item_header *ph;
         struct pool_cache *pc;  
         struct pool_cache_group *pcg;  
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
         struct pool_item *pi;          struct pool_item *pi;
 #endif  #endif
   
           LIST_FOREACH(ph, pl, ph_pagelist) {
                   (*pr)("\t\tpage %p, nmissing %d, time %lu,%lu\n",
                       ph->ph_page, ph->ph_nmissing,
                       (u_long)ph->ph_time.tv_sec,
                       (u_long)ph->ph_time.tv_usec);
   #ifdef DIAGNOSTIC
                   TAILQ_FOREACH(pi, &ph->ph_itemlist, pi_list) {
                           if (pi->pi_magic != PI_MAGIC) {
                                   (*pr)("\t\t\titem %p, magic 0x%x\n",
                                       pi, pi->pi_magic);
                           }
                   }
   #endif
           }
   }
   
   static void
   pool_print1(struct pool *pp, const char *modif, void (*pr)(const char *, ...))
   {
           struct pool_item_header *ph;
           struct pool_cache *pc;
           struct pool_cache_group *pcg;
         int i, print_log = 0, print_pagelist = 0, print_cache = 0;          int i, print_log = 0, print_pagelist = 0, print_cache = 0;
         char c;          char c;
   
Line 1444  pool_print1(struct pool *pp, const char 
Line 1505  pool_print1(struct pool *pp, const char 
         if (print_pagelist == 0)          if (print_pagelist == 0)
                 goto skip_pagelist;                  goto skip_pagelist;
   
         if ((ph = TAILQ_FIRST(&pp->pr_pagelist)) != NULL)          if ((ph = LIST_FIRST(&pp->pr_emptypages)) != NULL)
                 (*pr)("\n\tpage list:\n");                  (*pr)("\n\tempty page list:\n");
         for (; ph != NULL; ph = TAILQ_NEXT(ph, ph_pagelist)) {          pool_print_pagelist(&pp->pr_emptypages, pr);
                 (*pr)("\t\tpage %p, nmissing %d, time %lu,%lu\n",          if ((ph = LIST_FIRST(&pp->pr_fullpages)) != NULL)
                     ph->ph_page, ph->ph_nmissing,                  (*pr)("\n\tfull page list:\n");
                     (u_long)ph->ph_time.tv_sec,          pool_print_pagelist(&pp->pr_fullpages, pr);
                     (u_long)ph->ph_time.tv_usec);          if ((ph = LIST_FIRST(&pp->pr_partpages)) != NULL)
 #ifdef DIAGNOSTIC                  (*pr)("\n\tpartial-page list:\n");
                 TAILQ_FOREACH(pi, &ph->ph_itemlist, pi_list) {          pool_print_pagelist(&pp->pr_partpages, pr);
                         if (pi->pi_magic != PI_MAGIC) {  
                                 (*pr)("\t\t\titem %p, magic 0x%x\n",  
                                     pi, pi->pi_magic);  
                         }  
                 }  
 #endif  
         }  
         if (pp->pr_curpage == NULL)          if (pp->pr_curpage == NULL)
                 (*pr)("\tno current page\n");                  (*pr)("\tno current page\n");
         else          else
                 (*pr)("\tcurpage %p\n", pp->pr_curpage->ph_page);                  (*pr)("\tcurpage %p\n", pp->pr_curpage->ph_page);
   
  skip_pagelist:   skip_pagelist:
   
         if (print_log == 0)          if (print_log == 0)
                 goto skip_log;                  goto skip_log;
   
Line 1477  pool_print1(struct pool *pp, const char 
Line 1531  pool_print1(struct pool *pp, const char 
                 pr_printlog(pp, NULL, pr);                  pr_printlog(pp, NULL, pr);
   
  skip_log:   skip_log:
   
         if (print_cache == 0)          if (print_cache == 0)
                 goto skip_cache;                  goto skip_cache;
   
Line 1504  pool_print1(struct pool *pp, const char 
Line 1557  pool_print1(struct pool *pp, const char 
         }          }
   
  skip_cache:   skip_cache:
   
         pr_enter_check(pp, pr);          pr_enter_check(pp, pr);
 }  }
   
 int  static int
 pool_chk(struct pool *pp, const char *label)  pool_chk_page(struct pool *pp, const char *label, struct pool_item_header *ph)
 {  {
         struct pool_item_header *ph;          struct pool_item *pi;
         int r = 0;          caddr_t page;
           int n;
   
         simple_lock(&pp->pr_slock);          page = (caddr_t)((u_long)ph & pp->pr_alloc->pa_pagemask);
           if (page != ph->ph_page &&
               (pp->pr_roflags & PR_PHINPAGE) != 0) {
                   if (label != NULL)
                           printf("%s: ", label);
                   printf("pool(%p:%s): page inconsistency: page %p;"
                          " at page head addr %p (p %p)\n", pp,
                           pp->pr_wchan, ph->ph_page,
                           ph, page);
                   return 1;
           }
   
           for (pi = TAILQ_FIRST(&ph->ph_itemlist), n = 0;
                pi != NULL;
                pi = TAILQ_NEXT(pi,pi_list), n++) {
   
         TAILQ_FOREACH(ph, &pp->pr_pagelist, ph_pagelist) {  #ifdef DIAGNOSTIC
                 struct pool_item *pi;                  if (pi->pi_magic != PI_MAGIC) {
                 int n;  
                 caddr_t page;  
   
                 page = (caddr_t)((u_long)ph & pp->pr_alloc->pa_pagemask);  
                 if (page != ph->ph_page &&  
                     (pp->pr_roflags & PR_PHINPAGE) != 0) {  
                         if (label != NULL)                          if (label != NULL)
                                 printf("%s: ", label);                                  printf("%s: ", label);
                         printf("pool(%p:%s): page inconsistency: page %p;"                          printf("pool(%s): free list modified: magic=%x;"
                                " at page head addr %p (p %p)\n", pp,                                 " page %p; item ordinal %d;"
                                 pp->pr_wchan, ph->ph_page,                                 " addr %p (p %p)\n",
                                 ph, page);                                  pp->pr_wchan, pi->pi_magic, ph->ph_page,
                         r++;                                  n, pi, page);
                         goto out;                          panic("pool");
                 }                  }
   #endif
                   page =
                       (caddr_t)((u_long)pi & pp->pr_alloc->pa_pagemask);
                   if (page == ph->ph_page)
                           continue;
   
                 for (pi = TAILQ_FIRST(&ph->ph_itemlist), n = 0;                  if (label != NULL)
                      pi != NULL;                          printf("%s: ", label);
                      pi = TAILQ_NEXT(pi,pi_list), n++) {                  printf("pool(%p:%s): page inconsistency: page %p;"
                          " item ordinal %d; addr %p (p %p)\n", pp,
                           pp->pr_wchan, ph->ph_page,
                           n, pi, page);
                   return 1;
           }
           return 0;
   }
   
 #ifdef DIAGNOSTIC  
                         if (pi->pi_magic != PI_MAGIC) {  
                                 if (label != NULL)  
                                         printf("%s: ", label);  
                                 printf("pool(%s): free list modified: magic=%x;"  
                                        " page %p; item ordinal %d;"  
                                        " addr %p (p %p)\n",  
                                         pp->pr_wchan, pi->pi_magic, ph->ph_page,  
                                         n, pi, page);  
                                 panic("pool");  
                         }  
 #endif  
                         page =  
                             (caddr_t)((u_long)pi & pp->pr_alloc->pa_pagemask);  
                         if (page == ph->ph_page)  
                                 continue;  
   
                         if (label != NULL)  int
                                 printf("%s: ", label);  pool_chk(struct pool *pp, const char *label)
                         printf("pool(%p:%s): page inconsistency: page %p;"  {
                                " item ordinal %d; addr %p (p %p)\n", pp,          struct pool_item_header *ph;
                                 pp->pr_wchan, ph->ph_page,          int r = 0;
                                 n, pi, page);  
                         r++;          simple_lock(&pp->pr_slock);
           LIST_FOREACH(ph, &pp->pr_emptypages, ph_pagelist) {
                   r = pool_chk_page(pp, label, ph);
                   if (r) {
                           goto out;
                   }
           }
           LIST_FOREACH(ph, &pp->pr_fullpages, ph_pagelist) {
                   r = pool_chk_page(pp, label, ph);
                   if (r) {
                           goto out;
                   }
           }
           LIST_FOREACH(ph, &pp->pr_partpages, ph_pagelist) {
                   r = pool_chk_page(pp, label, ph);
                   if (r) {
                         goto out;                          goto out;
                 }                  }
         }          }
   
 out:  out:
         simple_unlock(&pp->pr_slock);          simple_unlock(&pp->pr_slock);
         return (r);          return (r);
Line 1923  pool_allocator_alloc(struct pool *org, i
Line 1996  pool_allocator_alloc(struct pool *org, i
         int s, freed;          int s, freed;
         void *res;          void *res;
   
           LOCK_ASSERT(!simple_lock_held(&org->pr_slock));
   
         do {          do {
                 if ((res = (*pa->pa_alloc)(org, flags)) != NULL)                  if ((res = (*pa->pa_alloc)(org, flags)) != NULL)
                         return (res);                          return (res);
Line 1993  pool_allocator_free(struct pool *pp, voi
Line 2068  pool_allocator_free(struct pool *pp, voi
         struct pool_allocator *pa = pp->pr_alloc;          struct pool_allocator *pa = pp->pr_alloc;
         int s;          int s;
   
           LOCK_ASSERT(!simple_lock_held(&pp->pr_slock));
   
         (*pa->pa_free)(pp, v);          (*pa->pa_free)(pp, v);
   
         s = splvm();          s = splvm();
Line 2036  pool_page_free(struct pool *pp, void *v)
Line 2113  pool_page_free(struct pool *pp, void *v)
 void *  void *
 pool_subpage_alloc(struct pool *pp, int flags)  pool_subpage_alloc(struct pool *pp, int flags)
 {  {
           void *v;
         return (pool_get(&psppool, flags));          int s;
           s = splvm();
           v = pool_get(&psppool, flags);
           splx(s);
           return v;
 }  }
   
 void  void
 pool_subpage_free(struct pool *pp, void *v)  pool_subpage_free(struct pool *pp, void *v)
 {  {
           int s;
           s = splvm();
         pool_put(&psppool, v);          pool_put(&psppool, v);
           splx(s);
 }  }
   
 /* We don't provide a real nointr allocator.  Maybe later. */  /* We don't provide a real nointr allocator.  Maybe later. */

Legend:
Removed from v.1.87  
changed lines
  Added in v.1.87.2.1

CVSweb <webmaster@jp.NetBSD.org>