[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.90 and 1.91

version 1.90, 2004/01/09 19:00:16 version 1.91, 2004/01/16 12:47:37
Line 317  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 336  pr_rmpage(struct pool *pp, struct pool_i
Line 338  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).
          */           */
         LIST_REMOVE(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) {
                 LIST_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) {
                         SPLAY_REMOVE(phtree, &pp->pr_phtree, ph);  
                         s = splvm();                          s = splvm();
                         pool_put(&phpool, ph);                          pool_put(&phpool, ph);
                         splx(s);                          splx(s);
Line 733  pool_get(struct pool *pp, int flags)
Line 736  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 771  pool_get(struct pool *pp, int flags)
Line 775  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++;
   
Line 953  pool_do_put(struct pool *pp, void *v)
Line 959  pool_do_put(struct pool *pp, void *v)
                     (pp->pr_npages > pp->pr_maxpages ||                      (pp->pr_npages > pp->pr_maxpages ||
                      (pp->pr_roflags & PR_IMMEDRELEASE) != 0 ||                       (pp->pr_roflags & PR_IMMEDRELEASE) != 0 ||
                      (pp->pr_alloc->pa_flags & PA_WANT) != 0)) {                       (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 {
                         LIST_REMOVE(ph, ph_pagelist);                          LIST_REMOVE(ph, ph_pagelist);
                         LIST_INSERT_HEAD(&pp->pr_emptypages, ph, ph_pagelist);                          LIST_INSERT_HEAD(&pp->pr_emptypages, ph, ph_pagelist);
Line 1039  pool_prime(struct pool *pp, int n)
Line 1047  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 1074  pool_prime_page(struct pool *pp, caddr_t
Line 1083  pool_prime_page(struct pool *pp, caddr_t
         int n;          int n;
         int s;          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);
Line 1163  pool_catchup(struct pool *pp)
Line 1174  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 1320  pool_reclaim(struct pool *pp)
Line 1332  pool_reclaim(struct pool *pp)
                 if (pp->pr_roflags & PR_PHINPAGE) {                  if (pp->pr_roflags & PR_PHINPAGE) {
                         continue;                          continue;
                 }                  }
                 SPLAY_REMOVE(phtree, &pp->pr_phtree, ph);  
                 s = splvm();                  s = splvm();
                 pool_put(&phpool, ph);                  pool_put(&phpool, ph);
                 splx(s);                  splx(s);
Line 1955  pool_allocator_alloc(struct pool *org, i
Line 1966  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 2025  pool_allocator_free(struct pool *pp, voi
Line 2038  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();

Legend:
Removed from v.1.90  
changed lines
  Added in v.1.91

CVSweb <webmaster@jp.NetBSD.org>