[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.182 and 1.182.4.3

version 1.182, 2010/01/20 23:40:42 version 1.182.4.3, 2011/03/05 20:55:19
Line 1 
Line 1 
 /*      $NetBSD$        */  /*      $NetBSD$        */
   
 /*-  /*-
  * Copyright (c) 1997, 1999, 2000, 2002, 2007, 2008 The NetBSD Foundation, Inc.   * Copyright (c) 1997, 1999, 2000, 2002, 2007, 2008, 2010
    *     The NetBSD Foundation, Inc.
  * All rights reserved.   * All rights reserved.
  *   *
  * This code is derived from software contributed to The NetBSD Foundation   * This code is derived from software contributed to The NetBSD Foundation
Line 53  __KERNEL_RCSID(0, "$NetBSD$");
Line 54  __KERNEL_RCSID(0, "$NetBSD$");
 #include <sys/cpu.h>  #include <sys/cpu.h>
 #include <sys/atomic.h>  #include <sys/atomic.h>
   
 #include <uvm/uvm.h>  #include <uvm/uvm_extern.h>
   #ifdef DIAGNOSTIC
   #include <uvm/uvm_km.h> /* uvm_km_va_drain */
   #endif
   
 /*  /*
  * Pool resource management utility.   * Pool resource management utility.
Line 561  pool_reclaim_register(struct pool *pp)
Line 565  pool_reclaim_register(struct pool *pp)
         callback_register(&vm_map_to_kernel(map)->vmk_reclaim_callback,          callback_register(&vm_map_to_kernel(map)->vmk_reclaim_callback,
             &pp->pr_reclaimerentry, pp, pool_reclaim_callback);              &pp->pr_reclaimerentry, pp, pool_reclaim_callback);
         splx(s);          splx(s);
   
   #ifdef DIAGNOSTIC
           /* Diagnostic drain attempt. */
           uvm_km_va_drain(map, 0);
   #endif
 }  }
   
 static void  static void
Line 983  pool_get(struct pool *pp, int flags)
Line 992  pool_get(struct pool *pp, int flags)
         void *v;          void *v;
   
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
         if (__predict_false(pp->pr_itemsperpage == 0))          if (pp->pr_itemsperpage == 0)
                 panic("pool_get: pool %p: pr_itemsperpage is zero, "                  panic("pool_get: pool '%s': pr_itemsperpage is zero, "
                     "pool not initialized?", pp);                      "pool not initialized?", pp->pr_wchan);
         if (__predict_false(curlwp == NULL && doing_shutdown == 0 &&          if ((cpu_intr_p() || cpu_softintr_p()) && pp->pr_ipl == IPL_NONE &&
                             (flags & PR_WAITOK) != 0))              !cold && panicstr == NULL)
                 panic("pool_get: %s: must have NOWAIT", pp->pr_wchan);                  panic("pool '%s' is IPL_NONE, but called from "
                       "interrupt context\n", pp->pr_wchan);
 #endif /* DIAGNOSTIC */  #endif
 #ifdef LOCKDEBUG  
         if (flags & PR_WAITOK) {          if (flags & PR_WAITOK) {
                 ASSERT_SLEEPABLE();                  ASSERT_SLEEPABLE();
         }          }
 #endif  
   
         mutex_enter(&pp->pr_lock);          mutex_enter(&pp->pr_lock);
         pr_enter(pp, file, line);          pr_enter(pp, file, line);
Line 1603  pool_sethardlimit(struct pool *pp, int n
Line 1610  pool_sethardlimit(struct pool *pp, int n
   
 /*  /*
  * Release all complete pages that have not been used recently.   * Release all complete pages that have not been used recently.
    *
    * Might be called from interrupt context.
  */   */
 int  int
 #ifdef POOL_DIAGNOSTIC  #ifdef POOL_DIAGNOSTIC
Line 1617  pool_reclaim(struct pool *pp)
Line 1626  pool_reclaim(struct pool *pp)
         bool klock;          bool klock;
         int rv;          int rv;
   
           if (cpu_intr_p() || cpu_softintr_p()) {
                   KASSERT(pp->pr_ipl != IPL_NONE);
           }
   
         if (pp->pr_drain_hook != NULL) {          if (pp->pr_drain_hook != NULL) {
                 /*                  /*
                  * The drain hook must be called with the pool unlocked.                   * The drain hook must be called with the pool unlocked.
Line 1735  pool_drain_start(struct pool **ppp, uint
Line 1748  pool_drain_start(struct pool **ppp, uint
         }          }
 }  }
   
 void  bool
 pool_drain_end(struct pool *pp, uint64_t where)  pool_drain_end(struct pool *pp, uint64_t where)
 {  {
           bool reclaimed;
   
         if (pp == NULL)          if (pp == NULL)
                 return;                  return false;
   
         KASSERT(pp->pr_refcnt > 0);          KASSERT(pp->pr_refcnt > 0);
   
Line 1749  pool_drain_end(struct pool *pp, uint64_t
Line 1763  pool_drain_end(struct pool *pp, uint64_t
                 xc_wait(where);                  xc_wait(where);
   
         /* Drain the cache (if any) and pool.. */          /* Drain the cache (if any) and pool.. */
         pool_reclaim(pp);          reclaimed = pool_reclaim(pp);
   
         /* Finally, unlock the pool. */          /* Finally, unlock the pool. */
         mutex_enter(&pool_head_lock);          mutex_enter(&pool_head_lock);
         pp->pr_refcnt--;          pp->pr_refcnt--;
         cv_broadcast(&pool_busy);          cv_broadcast(&pool_busy);
         mutex_exit(&pool_head_lock);          mutex_exit(&pool_head_lock);
   
           return reclaimed;
 }  }
   
 /*  /*
Line 1904  pool_print1(struct pool *pp, const char 
Line 1920  pool_print1(struct pool *pp, const char 
         if (pc != NULL) {          if (pc != NULL) {
                 cpuhit = 0;                  cpuhit = 0;
                 cpumiss = 0;                  cpumiss = 0;
                 for (i = 0; i < MAXCPUS; i++) {                  for (i = 0; i < __arraycount(pc->pc_cpus); i++) {
                         if ((cc = pc->pc_cpus[i]) == NULL)                          if ((cc = pc->pc_cpus[i]) == NULL)
                                 continue;                                  continue;
                         cpuhit += cc->cc_hits;                          cpuhit += cc->cc_hits;
Line 2158  pool_cache_destroy(pool_cache_t pc)
Line 2174  pool_cache_destroy(pool_cache_t pc)
         mutex_exit(&pp->pr_lock);          mutex_exit(&pp->pr_lock);
   
         /* Destroy per-CPU data */          /* Destroy per-CPU data */
         for (i = 0; i < MAXCPUS; i++)          for (i = 0; i < __arraycount(pc->pc_cpus); i++)
                 pool_cache_invalidate_cpu(pc, i);                  pool_cache_invalidate_cpu(pc, i);
   
         /* Finally, destroy it. */          /* Finally, destroy it. */
Line 2180  pool_cache_cpu_init1(struct cpu_info *ci
Line 2196  pool_cache_cpu_init1(struct cpu_info *ci
   
         index = ci->ci_index;          index = ci->ci_index;
   
         KASSERT(index < MAXCPUS);          KASSERT(index < __arraycount(pc->pc_cpus));
   
         if ((cc = pc->pc_cpus[index]) != NULL) {          if ((cc = pc->pc_cpus[index]) != NULL) {
                 KASSERT(cc->cc_cpuindex == index);                  KASSERT(cc->cc_cpuindex == index);
Line 2519  pool_cache_get_paddr(pool_cache_t pc, in
Line 2535  pool_cache_get_paddr(pool_cache_t pc, in
         void *object;          void *object;
         int s;          int s;
   
 #ifdef LOCKDEBUG          KASSERTMSG((!cpu_intr_p() && !cpu_softintr_p()) ||
               (pc->pc_pool.pr_ipl != IPL_NONE || cold || panicstr != NULL),
               ("pool '%s' is IPL_NONE, but called from interrupt context\n",
               pc->pc_pool.pr_wchan));
   
         if (flags & PR_WAITOK) {          if (flags & PR_WAITOK) {
                 ASSERT_SLEEPABLE();                  ASSERT_SLEEPABLE();
         }          }
 #endif  
   
         /* Lock out interrupts and disable preemption. */          /* Lock out interrupts and disable preemption. */
         s = splvm();          s = splvm();
Line 3039  found:
Line 3058  found:
                                         goto print;                                          goto print;
                                 }                                  }
                         }                          }
                         for (i = 0; i < MAXCPUS; i++) {                          for (i = 0; i < __arraycount(pc->pc_cpus); i++) {
                                 pool_cache_cpu_t *cc;                                  pool_cache_cpu_t *cc;
   
                                 if ((cc = pc->pc_cpus[i]) == NULL) {                                  if ((cc = pc->pc_cpus[i]) == NULL) {
Legend:
Removed from v.1.182  
changed lines
  Added in v.1.182.4.3
CVSweb <webmaster@jp.NetBSD.org>