[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.88

version 1.87, 2003/04/09 18:22:13 version 1.88, 2003/11/13 02:44:01
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 322  pr_rmpage(struct pool *pp, struct pool_i
Line 335  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 (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);                          SPLAY_REMOVE(phtree, &pp->pr_phtree, ph);
                         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 350  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;  
         }  
 }  }
   
 /*  /*
Line 361  void
Line 363  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;
   
 #ifdef POOL_DIAGNOSTIC  #ifdef POOL_DIAGNOSTIC
         /*          /*
Line 425  pool_init(struct pool *pp, size_t size, 
Line 427  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 465  pool_init(struct pool *pp, size_t size, 
Line 469  pool_init(struct pool *pp, size_t size, 
                 /* 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]);  
                 }  
         }          }
   
         /*          /*
Line 570  pool_destroy(struct pool *pp)
Line 572  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 604  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 773  pool_get(struct pool *pp, int flags)
Line 777  pool_get(struct pool *pp, int flags)
                 /* 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 817  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 836  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 934  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           *      (1) If we have more pages than the page high water mark,
          *          mark, free the page back to the system.           *          free the page back to the system.
          *           *
          *      (2) Move it to the end of the page list, so that           *      (2) Otherwise, move the page to the empty page list.
          *          we minimize our chances of fragmenting the           *
          *          pool.  Idle pages migrate to the end (along with           * Either way, select a new current page (so we use a partially-full
          *          completely empty pages, so that we find un-empty           * page if one is available).
          *          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++;
Line 954  pool_do_put(struct pool *pp, void *v)
Line 950  pool_do_put(struct pool *pp, void *v)
                     (pp->pr_alloc->pa_flags & PA_WANT) != 0) {                      (pp->pr_alloc->pa_flags & PA_WANT) != 0) {
                         pr_rmpage(pp, ph, NULL);                          pr_rmpage(pp, ph, NULL);
                 } 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 962  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 1089  pool_prime_page(struct pool *pp, caddr_t
Line 1073  pool_prime_page(struct pool *pp, caddr_t
                 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));          memset(&ph->ph_time, 0, sizeof(ph->ph_time));
           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 1130  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 1187  pool_catchup(struct pool *pp)
Line 1169  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 1252  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 1266  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 1278  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);                  SPLAY_REMOVE(phtree, &pp->pr_phtree, ph);
                 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 1398  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 1456  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 1482  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 1508  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;
           }
   
         TAILQ_FOREACH(ph, &pp->pr_pagelist, ph_pagelist) {          for (pi = TAILQ_FIRST(&ph->ph_itemlist), n = 0;
                 struct pool_item *pi;               pi != NULL;
                 int n;               pi = TAILQ_NEXT(pi,pi_list), n++) {
                 caddr_t page;  
   #ifdef DIAGNOSTIC
                 page = (caddr_t)((u_long)ph & pp->pr_alloc->pa_pagemask);                  if (pi->pi_magic != PI_MAGIC) {
                 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;                          goto out;
                 }                  }
         }          }
           LIST_FOREACH(ph, &pp->pr_partpages, ph_pagelist) {
                   r = pool_chk_page(pp, label, ph);
                   if (r) {
                           goto out;
                   }
           }
   
 out:  out:
         simple_unlock(&pp->pr_slock);          simple_unlock(&pp->pr_slock);
         return (r);          return (r);

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

CVSweb <webmaster@jp.NetBSD.org>