[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.86 and 1.87

version 1.86, 2003/03/16 08:06:51 version 1.87, 2003/04/09 18:22:13
Line 1488  pool_print1(struct pool *pp, const char 
Line 1488  pool_print1(struct pool *pp, const char 
                     pc->pc_hits, pc->pc_misses, pc->pc_ngroups, pc->pc_nitems);                      pc->pc_hits, pc->pc_misses, pc->pc_ngroups, pc->pc_nitems);
                 TAILQ_FOREACH(pcg, &pc->pc_grouplist, pcg_list) {                  TAILQ_FOREACH(pcg, &pc->pc_grouplist, pcg_list) {
                         (*pr)("\t\tgroup %p: avail %d\n", pcg, pcg->pcg_avail);                          (*pr)("\t\tgroup %p: avail %d\n", pcg, pcg->pcg_avail);
                         for (i = 0; i < PCG_NOBJECTS; i++)                          for (i = 0; i < PCG_NOBJECTS; i++) {
                                 (*pr)("\t\t\t%p\n", pcg->pcg_objects[i]);                                  if (pcg->pcg_objects[i].pcgo_pa !=
                                       POOL_PADDR_INVALID) {
                                           (*pr)("\t\t\t%p, 0x%llx\n",
                                               pcg->pcg_objects[i].pcgo_va,
                                               (unsigned long long)
                                               pcg->pcg_objects[i].pcgo_pa);
                                   } else {
                                           (*pr)("\t\t\t%p\n",
                                               pcg->pcg_objects[i].pcgo_va);
                                   }
                           }
                 }                  }
         }          }
   
Line 1618  pool_cache_destroy(struct pool_cache *pc
Line 1628  pool_cache_destroy(struct pool_cache *pc
 }  }
   
 static __inline void *  static __inline void *
 pcg_get(struct pool_cache_group *pcg)  pcg_get(struct pool_cache_group *pcg, paddr_t *pap)
 {  {
         void *object;          void *object;
         u_int idx;          u_int idx;
Line 1627  pcg_get(struct pool_cache_group *pcg)
Line 1637  pcg_get(struct pool_cache_group *pcg)
         KASSERT(pcg->pcg_avail != 0);          KASSERT(pcg->pcg_avail != 0);
         idx = --pcg->pcg_avail;          idx = --pcg->pcg_avail;
   
         KASSERT(pcg->pcg_objects[idx] != NULL);          KASSERT(pcg->pcg_objects[idx].pcgo_va != NULL);
         object = pcg->pcg_objects[idx];          object = pcg->pcg_objects[idx].pcgo_va;
         pcg->pcg_objects[idx] = NULL;          if (pap != NULL)
                   *pap = pcg->pcg_objects[idx].pcgo_pa;
           pcg->pcg_objects[idx].pcgo_va = NULL;
   
         return (object);          return (object);
 }  }
   
 static __inline void  static __inline void
 pcg_put(struct pool_cache_group *pcg, void *object)  pcg_put(struct pool_cache_group *pcg, void *object, paddr_t pa)
 {  {
         u_int idx;          u_int idx;
   
         KASSERT(pcg->pcg_avail < PCG_NOBJECTS);          KASSERT(pcg->pcg_avail < PCG_NOBJECTS);
         idx = pcg->pcg_avail++;          idx = pcg->pcg_avail++;
   
         KASSERT(pcg->pcg_objects[idx] == NULL);          KASSERT(pcg->pcg_objects[idx].pcgo_va == NULL);
         pcg->pcg_objects[idx] = object;          pcg->pcg_objects[idx].pcgo_va = object;
           pcg->pcg_objects[idx].pcgo_pa = pa;
 }  }
   
 /*  /*
  * pool_cache_get:   * pool_cache_get{,_paddr}:
  *   *
  *      Get an object from a pool cache.   *      Get an object from a pool cache (optionally returning
    *      the physical address of the object).
  */   */
 void *  void *
 pool_cache_get(struct pool_cache *pc, int flags)  pool_cache_get_paddr(struct pool_cache *pc, int flags, paddr_t *pap)
 {  {
         struct pool_cache_group *pcg;          struct pool_cache_group *pcg;
         void *object;          void *object;
Line 1687  pool_cache_get(struct pool_cache *pc, in
Line 1701  pool_cache_get(struct pool_cache *pc, in
                                 return (NULL);                                  return (NULL);
                         }                          }
                 }                  }
                   if (object != NULL && pap != NULL) {
   #ifdef POOL_VTOPHYS
                           *pap = POOL_VTOPHYS(object);
   #else
                           *pap = POOL_PADDR_INVALID;
   #endif
                   }
                 return (object);                  return (object);
         }          }
   
  have_group:   have_group:
         pc->pc_hits++;          pc->pc_hits++;
         pc->pc_nitems--;          pc->pc_nitems--;
         object = pcg_get(pcg);          object = pcg_get(pcg, pap);
   
         if (pcg->pcg_avail == 0)          if (pcg->pcg_avail == 0)
                 pc->pc_allocfrom = NULL;                  pc->pc_allocfrom = NULL;
Line 1704  pool_cache_get(struct pool_cache *pc, in
Line 1725  pool_cache_get(struct pool_cache *pc, in
 }  }
   
 /*  /*
  * pool_cache_put:   * pool_cache_put{,_paddr}:
  *   *
  *      Put an object back to the pool cache.   *      Put an object back to the pool cache (optionally caching the
    *      physical address of the object).
  */   */
 void  void
 pool_cache_put(struct pool_cache *pc, void *object)  pool_cache_put_paddr(struct pool_cache *pc, void *object, paddr_t pa)
 {  {
         struct pool_cache_group *pcg;          struct pool_cache_group *pcg;
         int s;          int s;
Line 1752  pool_cache_put(struct pool_cache *pc, vo
Line 1774  pool_cache_put(struct pool_cache *pc, vo
   
  have_group:   have_group:
         pc->pc_nitems++;          pc->pc_nitems++;
         pcg_put(pcg, object);          pcg_put(pcg, object, pa);
   
         if (pcg->pcg_avail == PCG_NOBJECTS)          if (pcg->pcg_avail == PCG_NOBJECTS)
                 pc->pc_freeto = NULL;                  pc->pc_freeto = NULL;
Line 1794  pool_cache_do_invalidate(struct pool_cac
Line 1816  pool_cache_do_invalidate(struct pool_cac
                 npcg = TAILQ_NEXT(pcg, pcg_list);                  npcg = TAILQ_NEXT(pcg, pcg_list);
                 while (pcg->pcg_avail != 0) {                  while (pcg->pcg_avail != 0) {
                         pc->pc_nitems--;                          pc->pc_nitems--;
                         object = pcg_get(pcg);                          object = pcg_get(pcg, NULL);
                         if (pcg->pcg_avail == 0 && pc->pc_allocfrom == pcg)                          if (pcg->pcg_avail == 0 && pc->pc_allocfrom == pcg)
                                 pc->pc_allocfrom = NULL;                                  pc->pc_allocfrom = NULL;
                         if (pc->pc_dtor != NULL)                          if (pc->pc_dtor != NULL)

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

CVSweb <webmaster@jp.NetBSD.org>