[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.13 and 1.17

version 1.13, 1998/09/12 17:20:02 version 1.17, 1998/12/27 21:13:43
Line 109  static void pr_rmpage __P((struct pool *
Line 109  static void pr_rmpage __P((struct pool *
 static int      pool_prime_page __P((struct pool *, caddr_t));  static int      pool_prime_page __P((struct pool *, caddr_t));
 static void     *pool_page_alloc __P((unsigned long, int, int));  static void     *pool_page_alloc __P((unsigned long, int, int));
 static void     pool_page_free __P((void *, unsigned long, int));  static void     pool_page_free __P((void *, unsigned long, int));
 int pool_chk __P((struct pool *, char *));  
   
   
 #ifdef POOL_DIAGNOSTIC  #ifdef POOL_DIAGNOSTIC
Line 126  struct pool_log {
Line 125  struct pool_log {
 };  };
   
 /* Number of entries in pool log buffers */  /* Number of entries in pool log buffers */
 int pool_logsize = 10;  #ifndef POOL_LOGSIZE
   #define POOL_LOGSIZE    10
   #endif
   
   int pool_logsize = POOL_LOGSIZE;
   
 static void     pr_log __P((struct pool *, void *, int, const char *, long));  static void     pr_log __P((struct pool *, void *, int, const char *, long));
 static void     pr_printlog __P((struct pool *));  static void     pr_printlog __P((struct pool *));
Line 324  pool_init(pp, size, align, ioff, flags, 
Line 327  pool_init(pp, size, align, ioff, flags, 
         void            (*release) __P((void *, unsigned long, int));          void            (*release) __P((void *, unsigned long, int));
         int             mtype;          int             mtype;
 {  {
         int off, slack;          int off, slack, i;
   
         /*          /*
          * Check arguments and construct default values.           * Check arguments and construct default values.
Line 347  pool_init(pp, size, align, ioff, flags, 
Line 350  pool_init(pp, size, align, ioff, flags, 
         if (align == 0)          if (align == 0)
                 align = ALIGN(1);                  align = ALIGN(1);
   
           if (size < sizeof(struct pool_item))
                   size = sizeof(struct pool_item);
   
         /*          /*
          * Initialize the pool structure.           * Initialize the pool structure.
          */           */
Line 384  pool_init(pp, size, align, ioff, flags, 
Line 390  pool_init(pp, size, align, ioff, flags, 
                 /* 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 = pagesz;                  off = pagesz;
                 memset(pp->pr_hashtab, 0, sizeof(pp->pr_hashtab));                  for (i = 0; i < PR_HASHTABSIZE; i++) {
                           LIST_INIT(&pp->pr_hashtab[i]);
                   }
         }          }
   
         /*          /*
Line 425  pool_init(pp, size, align, ioff, flags, 
Line 433  pool_init(pp, size, align, ioff, flags, 
 #endif  #endif
   
         simple_lock_init(&pp->pr_lock);          simple_lock_init(&pp->pr_lock);
           lockinit(&pp->pr_resourcelock, PSWP, wchan, 0, 0);
   
         /*          /*
          * Initialize private page header pool if we haven't done so yet.           * Initialize private page header pool if we haven't done so yet.
Line 511  pool_get(pp, flags)
Line 520  pool_get(pp, flags)
          * never points at a page header which has PR_PHINPAGE set and           * never points at a page header which has PR_PHINPAGE set and
          * has no items in its bucket.           * has no items in its bucket.
          */           */
 again:          while ((ph = pp->pr_curpage) == NULL) {
         if ((ph = pp->pr_curpage) == NULL) {                  void *v;
                 void *v = (*pp->pr_alloc)(pp->pr_pagesz, flags, pp->pr_mtype);                  int lkflags = LK_EXCLUSIVE | LK_INTERLOCK |
                                 ((flags & PR_WAITOK) == 0 ? LK_NOWAIT : 0);
   
                   /* Get long-term lock on pool */
                   if (lockmgr(&pp->pr_resourcelock, lkflags, &pp->pr_lock) != 0)
                           return (NULL);
   
                   /* Check if pool became non-empty while we slept */
                   if ((ph = pp->pr_curpage) != NULL)
                           goto again;
   
                   /* Call the page back-end allocator for more memory */
                   v = (*pp->pr_alloc)(pp->pr_pagesz, flags, pp->pr_mtype);
                 if (v == NULL) {                  if (v == NULL) {
                         if (flags & PR_URGENT)                          if (flags & PR_URGENT)
                                 panic("pool_get: urgent");                                  panic("pool_get: urgent");
                         if ((flags & PR_WAITOK) == 0) {                          if ((flags & PR_WAITOK) == 0) {
                                 pp->pr_nfail++;                                  pp->pr_nfail++;
                                 simple_unlock(&pp->pr_lock);                                  lockmgr(&pp->pr_resourcelock, LK_RELEASE, NULL);
                                 return (NULL);                                  return (NULL);
                         }                          }
   
                           /*
                            * Wait for items to be returned to this pool.
                            * XXX: we actually want to wait just until
                            * the page allocator has memory again. Depending
                            * on this pool's usage, we might get stuck here
                            * for a long time.
                            */
                         pp->pr_flags |= PR_WANTED;                          pp->pr_flags |= PR_WANTED;
                         simple_unlock(&pp->pr_lock);                          lockmgr(&pp->pr_resourcelock, LK_RELEASE, NULL);
                         tsleep((caddr_t)pp, PSWP, pp->pr_wchan, 0);                          tsleep((caddr_t)pp, PSWP, pp->pr_wchan, 0);
                         simple_lock(&pp->pr_lock);                          simple_lock(&pp->pr_lock);
                 } else {                          continue;
                         pp->pr_npagealloc++;  
                         pool_prime_page(pp, v);  
                 }                  }
   
                 goto again;                  /* We have more memory; add it to the pool */
                   pp->pr_npagealloc++;
                   pool_prime_page(pp, v);
   
   again:
                   /* Re-acquire pool interlock */
                   simple_lock(&pp->pr_lock);
                   lockmgr(&pp->pr_resourcelock, LK_RELEASE, NULL);
         }          }
   
         if ((v = pi = TAILQ_FIRST(&ph->ph_itemlist)) == NULL)          if ((v = pi = TAILQ_FIRST(&ph->ph_itemlist)) == NULL)
Line 632  pool_put(pp, v)
Line 665  pool_put(pp, v)
   
         if (pp->pr_flags & PR_WANTED) {          if (pp->pr_flags & PR_WANTED) {
                 pp->pr_flags &= ~PR_WANTED;                  pp->pr_flags &= ~PR_WANTED;
                   if (ph->ph_nmissing == 0)
                           pp->pr_nidle++;
                 wakeup((caddr_t)pp);                  wakeup((caddr_t)pp);
                 simple_unlock(&pp->pr_lock);                  simple_unlock(&pp->pr_lock);
                 return;                  return;
Line 685  pool_prime(pp, n, storage)
Line 720  pool_prime(pp, n, storage)
         /* !storage && static caught below */          /* !storage && static caught below */
 #endif  #endif
   
           (void)lockmgr(&pp->pr_resourcelock, LK_EXCLUSIVE, NULL);
         newnitems = pp->pr_minitems + n;          newnitems = pp->pr_minitems + n;
         newpages =          newpages =
                 roundup(pp->pr_itemsperpage,newnitems) / pp->pr_itemsperpage                  roundup(pp->pr_itemsperpage,newnitems) / pp->pr_itemsperpage
                 - pp->pr_minpages;                  - pp->pr_minpages;
   
         simple_lock(&pp->pr_lock);  
         while (newpages-- > 0) {          while (newpages-- > 0) {
   
                 if (pp->pr_flags & PR_STATIC) {                  if (pp->pr_flags & PR_STATIC) {
Line 701  pool_prime(pp, n, storage)
Line 736  pool_prime(pp, n, storage)
                 }                  }
   
                 if (cp == NULL) {                  if (cp == NULL) {
                         simple_unlock(&pp->pr_lock);                          (void)lockmgr(&pp->pr_resourcelock, LK_RELEASE, NULL);
                         return (ENOMEM);                          return (ENOMEM);
                 }                  }
   
Line 714  pool_prime(pp, n, storage)
Line 749  pool_prime(pp, n, storage)
         if (pp->pr_minpages >= pp->pr_maxpages)          if (pp->pr_minpages >= pp->pr_maxpages)
                 pp->pr_maxpages = pp->pr_minpages + 1;  /* XXX */                  pp->pr_maxpages = pp->pr_minpages + 1;  /* XXX */
   
         simple_unlock(&pp->pr_lock);          (void)lockmgr(&pp->pr_resourcelock, LK_RELEASE, NULL);
         return (0);          return (0);
 }  }
   
Line 733  pool_prime_page(pp, storage)
Line 768  pool_prime_page(pp, storage)
         unsigned int ioff = pp->pr_itemoffset;          unsigned int ioff = pp->pr_itemoffset;
         int n;          int n;
   
           simple_lock(&pp->pr_lock);
   
         if ((pp->pr_flags & PR_PHINPAGE) != 0) {          if ((pp->pr_flags & PR_PHINPAGE) != 0) {
                 ph = (struct pool_item_header *)(cp + pp->pr_phoffset);                  ph = (struct pool_item_header *)(cp + pp->pr_phoffset);
         } else {          } else {
Line 790  pool_prime_page(pp, storage)
Line 827  pool_prime_page(pp, storage)
         if (++pp->pr_npages > pp->pr_hiwat)          if (++pp->pr_npages > pp->pr_hiwat)
                 pp->pr_hiwat = pp->pr_npages;                  pp->pr_hiwat = pp->pr_npages;
   
           simple_unlock(&pp->pr_lock);
         return (0);          return (0);
 }  }
   
Line 798  pool_setlowat(pp, n)
Line 836  pool_setlowat(pp, n)
         pool_handle_t   pp;          pool_handle_t   pp;
         int n;          int n;
 {  {
   
           (void)lockmgr(&pp->pr_resourcelock, LK_EXCLUSIVE, NULL);
         pp->pr_minitems = n;          pp->pr_minitems = n;
         if (n == 0) {          pp->pr_minpages = (n == 0)
                 pp->pr_minpages = 0;                  ? 0
                 return;                  : roundup(pp->pr_itemsperpage,n) / pp->pr_itemsperpage;
         }          (void)lockmgr(&pp->pr_resourcelock, LK_RELEASE, NULL);
         pp->pr_minpages =  
                 roundup(pp->pr_itemsperpage,n) / pp->pr_itemsperpage;  
 }  }
   
 void  void
Line 812  pool_sethiwat(pp, n)
Line 850  pool_sethiwat(pp, n)
         pool_handle_t   pp;          pool_handle_t   pp;
         int n;          int n;
 {  {
         if (n == 0) {  
                 pp->pr_maxpages = 0;          (void)lockmgr(&pp->pr_resourcelock, LK_EXCLUSIVE, NULL);
                 return;          pp->pr_maxpages = (n == 0)
         }                  ? 0
         pp->pr_maxpages =                  : roundup(pp->pr_itemsperpage,n) / pp->pr_itemsperpage;
                 roundup(pp->pr_itemsperpage,n) / pp->pr_itemsperpage;          (void)lockmgr(&pp->pr_resourcelock, LK_RELEASE, NULL);
 }  }
   
   
Line 955  pool_drain(arg)
Line 993  pool_drain(arg)
 }  }
   
   
 #ifdef DEBUG  #if defined(POOL_DIAGNOSTIC) || defined(DEBUG)
 /*  /*
  * Diagnostic helpers.   * Diagnostic helpers.
  */   */
Line 1001  pool_chk(pp, label)
Line 1039  pool_chk(pp, label)
                 caddr_t page;                  caddr_t page;
   
                 page = (caddr_t)((u_long)ph & pp->pr_pagemask);                  page = (caddr_t)((u_long)ph & pp->pr_pagemask);
                 if (page != ph->ph_page) {                  if (page != ph->ph_page && (pp->pr_flags & PR_PHINPAGE) != 0) {
                         if (label != NULL)                          if (label != NULL)
                                 printf("%s: ", label);                                  printf("%s: ", label);
                         printf("pool(%s): page inconsistency: page %p;"                          printf("pool(%p:%s): page inconsistency: page %p;"
                                " at page head addr %p (p %p)\n",                                 " at page head addr %p (p %p)\n", pp,
                                 pp->pr_wchan, ph->ph_page,                                  pp->pr_wchan, ph->ph_page,
                                 ph, page);                                  ph, page);
                         r++;                          r++;
Line 1034  pool_chk(pp, label)
Line 1072  pool_chk(pp, label)
   
                         if (label != NULL)                          if (label != NULL)
                                 printf("%s: ", label);                                  printf("%s: ", label);
                         printf("pool(%s): page inconsistency: page %p;"                          printf("pool(%p:%s): page inconsistency: page %p;"
                                " item ordinal %d; addr %p (p %p)\n",                                 " item ordinal %d; addr %p (p %p)\n", pp,
                                 pp->pr_wchan, ph->ph_page,                                  pp->pr_wchan, ph->ph_page,
                                 n, pi, page);                                  n, pi, page);
                         r++;                          r++;
Line 1046  out:
Line 1084  out:
         simple_unlock(&pp->pr_lock);          simple_unlock(&pp->pr_lock);
         return (r);          return (r);
 }  }
 #endif  #endif /* POOL_DIAGNOSTIC || DEBUG */
Legend:
Removed from v.1.13  
changed lines
  Added in v.1.17
CVSweb <webmaster@jp.NetBSD.org>