sys/sys/pctrie.h

   1 /*
   2  * Copyright (c) 2013 EMC Corp.
   3  * Copyright (c) 2011 Jeffrey Roberson <jeff@freebsd.org>
   4  * Copyright (c) 2008 Mayur Shardul <mayur.shardul@gmail.com>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  * $FreeBSD$
  29  */
  30
  31 #ifndef _SYS_PCTRIE_H_
  32 #define _SYS_PCTRIE_H_
  33
  34 #include <sys/_pctrie.h>
  35
  36 #ifdef _KERNEL
  37
  38 #define PCTRIE_DEFINE(name, type, field, allocfn, freefn)               \
  39                                                                         \
  40 CTASSERT(sizeof(((struct type *)0)->field) == sizeof(uint64_t));        \
  41 CTASSERT((__offsetof(struct type, field) & (sizeof(uint64_t) - 1)) == 0); \
  42                                                                         \
  43 static __inline struct type *                                           \
  44 name##_PCTRIE_VAL2PTR(uint64_t *val)                                    \
  45 {                                                                       \
  46                                                                         \
  47         if (val == NULL)                                                \
  48                 return (NULL);                                          \
  49         return (struct type *)                                          \
  50             ((uintptr_t)val - __offsetof(struct type, field));          \
  51 }                                                                       \
  52                                                                         \
  53 static __inline uint64_t *                                              \
  54 name##_PCTRIE_PTR2VAL(struct type *ptr)                                 \
  55 {                                                                       \
  56                                                                         \
  57         return &ptr->field;                                             \
  58 }                                                                       \
  59                                                                         \
  60 static __inline int                                                     \
  61 name##_PCTRIE_INSERT(struct pctrie *ptree, struct type *ptr)            \
  62 {                                                                       \
  63                                                                         \
  64         return pctrie_insert(ptree, name##_PCTRIE_PTR2VAL(ptr),         \
  65             allocfn);                                                   \
  66 }                                                                       \
  67                                                                         \
  68 static __inline struct type *                                           \
  69 name##_PCTRIE_LOOKUP(struct pctrie *ptree, uint64_t key)                \
  70 {                                                                       \
  71                                                                         \
  72         return name##_PCTRIE_VAL2PTR(pctrie_lookup(ptree, key));        \
  73 }                                                                       \
  74                                                                         \
  75 static __inline struct type *                                           \
  76 name##_PCTRIE_LOOKUP_LE(struct pctrie *ptree, uint64_t key)             \
  77 {                                                                       \
  78                                                                         \
  79         return name##_PCTRIE_VAL2PTR(pctrie_lookup_le(ptree, key));     \
  80 }                                                                       \
  81                                                                         \
  82 static __inline struct type *                                           \
  83 name##_PCTRIE_LOOKUP_GE(struct pctrie *ptree, uint64_t key)             \
  84 {                                                                       \
  85                                                                         \
  86         return name##_PCTRIE_VAL2PTR(pctrie_lookup_ge(ptree, key));     \
  87 }                                                                       \
  88                                                                         \
  89 static __inline void                                                    \
  90 name##_PCTRIE_RECLAIM(struct pctrie *ptree)                             \
  91 {                                                                       \
  92                                                                         \
  93         pctrie_reclaim_allnodes(ptree, freefn);                         \
  94 }                                                                       \
  95                                                                         \
  96 static __inline void                                                    \
  97 name##_PCTRIE_REMOVE(struct pctrie *ptree, uint64_t key)                \
  98 {                                                                       \
  99                                                                         \
 100         pctrie_remove(ptree, key, freefn);                              \
 101 }
 102
 103 typedef void    *(*pctrie_alloc_t)(struct pctrie *ptree);
 104 typedef void    (*pctrie_free_t)(struct pctrie *ptree, void *node);
 105
 106 int             pctrie_insert(struct pctrie *ptree, uint64_t *val,
 107                     pctrie_alloc_t allocfn);
 108 uint64_t        *pctrie_lookup(struct pctrie *ptree, uint64_t key);
 109 uint64_t        *pctrie_lookup_ge(struct pctrie *ptree, uint64_t key);
 110 uint64_t        *pctrie_lookup_le(struct pctrie *ptree, uint64_t key);
 111 void            pctrie_reclaim_allnodes(struct pctrie *ptree,
 112                     pctrie_free_t freefn);
 113 void            pctrie_remove(struct pctrie *ptree, uint64_t key,
 114                     pctrie_free_t freefn);
 115 size_t          pctrie_node_size(void);
 116 int             pctrie_zone_init(void *mem, int size, int flags);
 117
 118 #endif /* _KERNEL */
 119 #endif /* !_SYS_PCTRIE_H_ */