[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.41 and 1.42

version 1.41, 2000/11/19 00:29:51 version 1.42, 2000/12/06 18:20:52
Line 106  struct pool_item {
Line 106  struct pool_item {
   
   
   
 static struct pool_item_header  static int      pool_catchup(struct pool *);
                 *pr_find_pagehead __P((struct pool *, caddr_t));  static void     pool_prime_page(struct pool *, caddr_t);
 static void     pr_rmpage __P((struct pool *, struct pool_item_header *));  static void     *pool_page_alloc(unsigned long, int, int);
 static int      pool_catchup __P((struct pool *));  static void     pool_page_free(void *, unsigned long, int);
 static void     pool_prime_page __P((struct pool *, caddr_t));  
 static void     *pool_page_alloc __P((unsigned long, int, int));  
 static void     pool_page_free __P((void *, unsigned long, int));  
   
 static void pool_print1 __P((struct pool *, const char *,  static void pool_print1(struct pool *, const char *,
         void (*)(const char *, ...)));          void (*)(const char *, ...));
   
 /*  /*
  * Pool log entry. An array of these is allocated in pool_create().   * Pool log entry. An array of these is allocated in pool_create().
Line 137  struct pool_log {
Line 134  struct pool_log {
 int pool_logsize = POOL_LOGSIZE;  int pool_logsize = POOL_LOGSIZE;
   
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
 static void     pr_log __P((struct pool *, void *, int, const char *, long));  static __inline void
 static void     pr_printlog __P((struct pool *, struct pool_item *,  pr_log(struct pool *pp, void *v, int action, const char *file, long line)
                     void (*)(const char *, ...)));  
 static void     pr_enter __P((struct pool *, const char *, long));  
 static void     pr_leave __P((struct pool *));  
 static void     pr_enter_check __P((struct pool *,  
                     void (*)(const char *, ...)));  
   
 static __inline__ void  
 pr_log(pp, v, action, file, line)  
         struct pool     *pp;  
         void            *v;  
         int             action;  
         const char      *file;  
         long            line;  
 {  {
         int n = pp->pr_curlogentry;          int n = pp->pr_curlogentry;
         struct pool_log *pl;          struct pool_log *pl;
Line 174  pr_log(pp, v, action, file, line)
Line 158  pr_log(pp, v, action, file, line)
 }  }
   
 static void  static void
 pr_printlog(pp, pi, pr)  pr_printlog(struct pool *pp, struct pool_item *pi,
         struct pool *pp;      void (*pr)(const char *, ...))
         struct pool_item *pi;  
         void (*pr) __P((const char *, ...));  
 {  {
         int i = pp->pr_logsize;          int i = pp->pr_logsize;
         int n = pp->pr_curlogentry;          int n = pp->pr_curlogentry;
Line 205  pr_printlog(pp, pi, pr)
Line 187  pr_printlog(pp, pi, pr)
         }          }
 }  }
   
 static __inline__ void  static __inline void
 pr_enter(pp, file, line)  pr_enter(struct pool *pp, const char *file, long line)
         struct pool *pp;  
         const char *file;  
         long line;  
 {  {
   
         if (__predict_false(pp->pr_entered_file != NULL)) {          if (__predict_false(pp->pr_entered_file != NULL)) {
Line 224  pr_enter(pp, file, line)
Line 203  pr_enter(pp, file, line)
         pp->pr_entered_line = line;          pp->pr_entered_line = line;
 }  }
   
 static __inline__ void  static __inline void
 pr_leave(pp)  pr_leave(struct pool *pp)
         struct pool *pp;  
 {  {
   
         if (__predict_false(pp->pr_entered_file == NULL)) {          if (__predict_false(pp->pr_entered_file == NULL)) {
Line 238  pr_leave(pp)
Line 216  pr_leave(pp)
         pp->pr_entered_line = 0;          pp->pr_entered_line = 0;
 }  }
   
 static __inline__ void  static __inline void
 pr_enter_check(pp, pr)  pr_enter_check(struct pool *pp, void (*pr)(const char *, ...))
         struct pool *pp;  
         void (*pr) __P((const char *, ...));  
 {  {
   
         if (pp->pr_entered_file != NULL)          if (pp->pr_entered_file != NULL)
Line 259  pr_enter_check(pp, pr)
Line 235  pr_enter_check(pp, pr)
 /*  /*
  * 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(pp, page)  pr_find_pagehead(struct pool *pp, caddr_t page)
         struct pool *pp;  
         caddr_t page;  
 {  {
         struct pool_item_header *ph;          struct pool_item_header *ph;
   
Line 281  pr_find_pagehead(pp, page)
Line 255  pr_find_pagehead(pp, page)
 /*  /*
  * Remove a page from the pool.   * Remove a page from the pool.
  */   */
 static __inline__ void  static __inline void
 pr_rmpage(pp, ph)  pr_rmpage(struct pool *pp, struct pool_item_header *ph)
         struct pool *pp;  
         struct pool_item_header *ph;  
 {  {
   
         /*          /*
Line 337  pr_rmpage(pp, ph)
Line 309  pr_rmpage(pp, ph)
  * Allocate and initialize a pool.   * Allocate and initialize a pool.
  */   */
 struct pool *  struct pool *
 pool_create(size, align, ioff, nitems, wchan, pagesz, alloc, release, mtype)  pool_create(size_t size, u_int align, u_int ioff, int nitems,
         size_t  size;      const char *wchan, size_t pagesz,
         u_int   align;      void *(*alloc)(unsigned long, int, int),
         u_int   ioff;      void (*release)(void *, unsigned long, int),
         int     nitems;      int mtype)
         const char *wchan;  
         size_t  pagesz;  
         void    *(*alloc) __P((unsigned long, int, int));  
         void    (*release) __P((void *, unsigned long, int));  
         int     mtype;  
 {  {
         struct pool *pp;          struct pool *pp;
         int flags;          int flags;
Line 376  pool_create(size, align, ioff, nitems, w
Line 343  pool_create(size, align, ioff, nitems, w
  * static pools that must be initialized before malloc() is available.   * static pools that must be initialized before malloc() is available.
  */   */
 void  void
 pool_init(pp, size, align, ioff, flags, wchan, pagesz, alloc, release, mtype)  pool_init(struct pool *pp, size_t size, u_int align, u_int ioff, int flags,
         struct pool     *pp;      const char *wchan, size_t pagesz,
         size_t          size;      void *(*alloc)(unsigned long, int, int),
         u_int           align;      void (*release)(void *, unsigned long, int),
         u_int           ioff;      int mtype)
         int             flags;  
         const char      *wchan;  
         size_t          pagesz;  
         void            *(*alloc) __P((unsigned long, int, int));  
         void            (*release) __P((void *, unsigned long, int));  
         int             mtype;  
 {  {
         int off, slack, i;          int off, slack, i;
   
Line 536  pool_init(pp, size, align, ioff, flags, 
Line 497  pool_init(pp, size, align, ioff, flags, 
  * De-commision a pool resource.   * De-commision a pool resource.
  */   */
 void  void
 pool_destroy(pp)  pool_destroy(struct pool *pp)
         struct pool *pp;  
 {  {
         struct pool_item_header *ph;          struct pool_item_header *ph;
   
Line 573  pool_destroy(pp)
Line 533  pool_destroy(pp)
  * Grab an item from the pool; must be called at appropriate spl level   * Grab an item from the pool; must be called at appropriate spl level
  */   */
 void *  void *
 _pool_get(pp, flags, file, line)  _pool_get(struct pool *pp, int flags, const char *file, long line)
         struct pool *pp;  
         int flags;  
         const char *file;  
         long line;  
 {  {
         void *v;          void *v;
         struct pool_item *pi;          struct pool_item *pi;
Line 809  _pool_get(pp, flags, file, line)
Line 765  _pool_get(pp, flags, file, line)
  * Return resource to the pool; must be called at appropriate spl level   * Return resource to the pool; must be called at appropriate spl level
  */   */
 void  void
 _pool_put(pp, v, file, line)  _pool_put(struct pool *pp, void *v, const char *file, long line)
         struct pool *pp;  
         void *v;  
         const char *file;  
         long line;  
 {  {
         struct pool_item *pi = v;          struct pool_item *pi = v;
         struct pool_item_header *ph;          struct pool_item_header *ph;
Line 952  _pool_put(pp, v, file, line)
Line 904  _pool_put(pp, v, file, line)
  * Add N items to the pool.   * Add N items to the pool.
  */   */
 int  int
 pool_prime(pp, n, storage)  pool_prime(struct pool *pp, int n, caddr_t storage)
         struct pool *pp;  
         int n;  
         caddr_t storage;  
 {  {
         caddr_t cp;          caddr_t cp;
         int newnitems, newpages;          int newnitems, newpages;
Line 1008  pool_prime(pp, n, storage)
Line 957  pool_prime(pp, n, storage)
  * Note, we must be called with the pool descriptor LOCKED.   * Note, we must be called with the pool descriptor LOCKED.
  */   */
 static void  static void
 pool_prime_page(pp, storage)  pool_prime_page(struct pool *pp, caddr_t storage)
         struct pool *pp;  
         caddr_t storage;  
 {  {
         struct pool_item *pi;          struct pool_item *pi;
         struct pool_item_header *ph;          struct pool_item_header *ph;
Line 1096  pool_prime_page(pp, storage)
Line 1043  pool_prime_page(pp, storage)
  * with it locked.   * with it locked.
  */   */
 static int  static int
 pool_catchup(pp)  pool_catchup(struct pool *pp)
         struct pool *pp;  
 {  {
         caddr_t cp;          caddr_t cp;
         int error = 0;          int error = 0;
Line 1136  pool_catchup(pp)
Line 1082  pool_catchup(pp)
 }  }
   
 void  void
 pool_setlowat(pp, n)  pool_setlowat(struct pool *pp, int n)
         pool_handle_t   pp;  
         int n;  
 {  {
         int error;          int error;
   
Line 1163  pool_setlowat(pp, n)
Line 1107  pool_setlowat(pp, n)
 }  }
   
 void  void
 pool_sethiwat(pp, n)  pool_sethiwat(struct pool *pp, int n)
         pool_handle_t   pp;  
         int n;  
 {  {
   
         simple_lock(&pp->pr_slock);          simple_lock(&pp->pr_slock);
Line 1178  pool_sethiwat(pp, n)
Line 1120  pool_sethiwat(pp, n)
 }  }
   
 void  void
 pool_sethardlimit(pp, n, warnmess, ratecap)  pool_sethardlimit(struct pool *pp, int n, const char *warnmess, int ratecap)
         pool_handle_t pp;  
         int n;  
         const char *warnmess;  
         int ratecap;  
 {  {
   
         simple_lock(&pp->pr_slock);          simple_lock(&pp->pr_slock);
Line 1208  pool_sethardlimit(pp, n, warnmess, ratec
Line 1146  pool_sethardlimit(pp, n, warnmess, ratec
  * Default page allocator.   * Default page allocator.
  */   */
 static void *  static void *
 pool_page_alloc(sz, flags, mtype)  pool_page_alloc(unsigned long sz, int flags, int mtype)
         unsigned long sz;  
         int flags;  
         int mtype;  
 {  {
         boolean_t waitok = (flags & PR_WAITOK) ? TRUE : FALSE;          boolean_t waitok = (flags & PR_WAITOK) ? TRUE : FALSE;
   
Line 1219  pool_page_alloc(sz, flags, mtype)
Line 1154  pool_page_alloc(sz, flags, mtype)
 }  }
   
 static void  static void
 pool_page_free(v, sz, mtype)  pool_page_free(void *v, unsigned long sz, int mtype)
         void *v;  
         unsigned long sz;  
         int mtype;  
 {  {
   
         uvm_km_free_poolpage((vaddr_t)v);          uvm_km_free_poolpage((vaddr_t)v);
Line 1233  pool_page_free(v, sz, mtype)
Line 1165  pool_page_free(v, sz, mtype)
  * never be accessed in interrupt context.   * never be accessed in interrupt context.
  */   */
 void *  void *
 pool_page_alloc_nointr(sz, flags, mtype)  pool_page_alloc_nointr(unsigned long sz, int flags, int mtype)
         unsigned long sz;  
         int flags;  
         int mtype;  
 {  {
         boolean_t waitok = (flags & PR_WAITOK) ? TRUE : FALSE;          boolean_t waitok = (flags & PR_WAITOK) ? TRUE : FALSE;
   
Line 1245  pool_page_alloc_nointr(sz, flags, mtype)
Line 1174  pool_page_alloc_nointr(sz, flags, mtype)
 }  }
   
 void  void
 pool_page_free_nointr(v, sz, mtype)  pool_page_free_nointr(void *v, unsigned long sz, int mtype)
         void *v;  
         unsigned long sz;  
         int mtype;  
 {  {
   
         uvm_km_free_poolpage1(kernel_map, (vaddr_t)v);          uvm_km_free_poolpage1(kernel_map, (vaddr_t)v);
Line 1259  pool_page_free_nointr(v, sz, mtype)
Line 1185  pool_page_free_nointr(v, sz, mtype)
  * Release all complete pages that have not been used recently.   * Release all complete pages that have not been used recently.
  */   */
 void  void
 _pool_reclaim(pp, file, line)  _pool_reclaim(struct pool *pp, const char *file, long line)
         pool_handle_t pp;  
         const char *file;  
         long line;  
 {  {
         struct pool_item_header *ph, *phnext;          struct pool_item_header *ph, *phnext;
         struct timeval curtime;          struct timeval curtime;
Line 1315  _pool_reclaim(pp, file, line)
Line 1238  _pool_reclaim(pp, file, line)
  * Note, we must never be called from an interrupt context.   * Note, we must never be called from an interrupt context.
  */   */
 void  void
 pool_drain(arg)  pool_drain(void *arg)
         void *arg;  
 {  {
         struct pool *pp;          struct pool *pp;
         int s;          int s;
Line 1342  pool_drain(arg)
Line 1264  pool_drain(arg)
  * Diagnostic helpers.   * Diagnostic helpers.
  */   */
 void  void
 pool_print(pp, modif)  pool_print(struct pool *pp, const char *modif)
         struct pool *pp;  
         const char *modif;  
 {  {
         int s;          int s;
   
Line 1361  pool_print(pp, modif)
Line 1281  pool_print(pp, modif)
 }  }
   
 void  void
 pool_printit(pp, modif, pr)  pool_printit(struct pool *pp, const char *modif, void (*pr)(const char *, ...))
         struct pool *pp;  
         const char *modif;  
         void (*pr) __P((const char *, ...));  
 {  {
         int didlock = 0;          int didlock = 0;
   
Line 1394  pool_printit(pp, modif, pr)
Line 1311  pool_printit(pp, modif, pr)
 }  }
   
 static void  static void
 pool_print1(pp, modif, pr)  pool_print1(struct pool *pp, const char *modif, void (*pr)(const char *, ...))
         struct pool *pp;  
         const char *modif;  
         void (*pr) __P((const char *, ...));  
 {  {
         struct pool_item_header *ph;          struct pool_item_header *ph;
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
Line 1471  pool_print1(pp, modif, pr)
Line 1385  pool_print1(pp, modif, pr)
 }  }
   
 int  int
 pool_chk(pp, label)  pool_chk(struct pool *pp, const char *label)
         struct pool *pp;  
         char *label;  
 {  {
         struct pool_item_header *ph;          struct pool_item_header *ph;
         int r = 0;          int r = 0;

Legend:
Removed from v.1.41  
changed lines
  Added in v.1.42

CVSweb <webmaster@jp.NetBSD.org>