sys/sys/pctrie.h

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 2013 EMC Corp.
   5  * Copyright (c) 2011 Jeffrey Roberson <jeff@freebsd.org>
   6  * Copyright (c) 2008 Mayur Shardul <mayur.shardul@gmail.com>
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30
  31 #ifndef _SYS_PCTRIE_H_
  32 #define _SYS_PCTRIE_H_
  33
  34 #include <sys/_pctrie.h>
  35 #include <sys/_smr.h>
  36
  37 #ifdef _KERNEL
  38
  39 #define PCTRIE_DEFINE_SMR(name, type, field, allocfn, freefn, smr)      \
  40     PCTRIE_DEFINE(name, type, field, allocfn, freefn)                   \
  41                                                                         \
  42 static __inline struct type *                                           \
  43 name##_PCTRIE_LOOKUP_UNLOCKED(struct pctrie *ptree, uint64_t key)       \
  44 {                                                                       \
  45                                                                         \
  46         return name##_PCTRIE_VAL2PTR(pctrie_lookup_unlocked(ptree,      \
  47             key, (smr)));                                               \
  48 }                                                                       \
  49
  50 #define PCTRIE_DEFINE(name, type, field, allocfn, freefn)               \
  51                                                                         \
  52 CTASSERT(sizeof(((struct type *)0)->field) == sizeof(uint64_t));        \
  53 /*                                                                      \
  54  * XXX This assert protects flag bits, it does not enforce natural      \
  55  * alignment.  32bit architectures do not naturally align 64bit fields. \
  56  */                                                                     \
  57 CTASSERT((__offsetof(struct type, field) & (sizeof(uint32_t) - 1)) == 0); \
  58                                                                         \
  59 static __inline struct type *                                           \
  60 name##_PCTRIE_VAL2PTR(uint64_t *val)                                    \
  61 {                                                                       \
  62                                                                         \
  63         if (val == NULL)                                                \
  64                 return (NULL);                                          \
  65         return (struct type *)                                          \
  66             ((uintptr_t)val - __offsetof(struct type, field));          \
  67 }                                                                       \
  68                                                                         \
  69 static __inline uint64_t *                                              \
  70 name##_PCTRIE_PTR2VAL(struct type *ptr)                                 \
  71 {                                                                       \
  72                                                                         \
  73         return &ptr->field;                                             \
  74 }                                                                       \
  75                                                                         \
  76 static __inline int                                                     \
  77 name##_PCTRIE_INSERT(struct pctrie *ptree, struct type *ptr)            \
  78 {                                                                       \
  79                                                                         \
  80         return pctrie_insert(ptree, name##_PCTRIE_PTR2VAL(ptr),         \
  81             allocfn);                                                   \
  82 }                                                                       \
  83                                                                         \
  84 static __inline struct type *                                           \
  85 name##_PCTRIE_LOOKUP(struct pctrie *ptree, uint64_t key)                \
  86 {                                                                       \
  87                                                                         \
  88         return name##_PCTRIE_VAL2PTR(pctrie_lookup(ptree, key));        \
  89 }                                                                       \
  90                                                                         \
  91 static __inline __unused struct type *                                          \
  92 name##_PCTRIE_LOOKUP_LE(struct pctrie *ptree, uint64_t key)             \
  93 {                                                                       \
  94                                                                         \
  95         return name##_PCTRIE_VAL2PTR(pctrie_lookup_le(ptree, key));     \
  96 }                                                                       \
  97                                                                         \
  98 static __inline __unused struct type *                                  \
  99 name##_PCTRIE_LOOKUP_GE(struct pctrie *ptree, uint64_t key)             \
 100 {                                                                       \
 101                                                                         \
 102         return name##_PCTRIE_VAL2PTR(pctrie_lookup_ge(ptree, key));     \
 103 }                                                                       \
 104                                                                         \
 105 static __inline __unused void                                           \
 106 name##_PCTRIE_RECLAIM(struct pctrie *ptree)                             \
 107 {                                                                       \
 108                                                                         \
 109         pctrie_reclaim_allnodes(ptree, freefn);                         \
 110 }                                                                       \
 111                                                                         \
 112 static __inline void                                                    \
 113 name##_PCTRIE_REMOVE(struct pctrie *ptree, uint64_t key)                \
 114 {                                                                       \
 115                                                                         \
 116         pctrie_remove(ptree, key, freefn);                              \
 117 }
 118
 119 typedef void    *(*pctrie_alloc_t)(struct pctrie *ptree);
 120 typedef void    (*pctrie_free_t)(struct pctrie *ptree, void *node);
 121
 122 int             pctrie_insert(struct pctrie *ptree, uint64_t *val,
 123                     pctrie_alloc_t allocfn);
 124 uint64_t        *pctrie_lookup(struct pctrie *ptree, uint64_t key);
 125 uint64_t        *pctrie_lookup_ge(struct pctrie *ptree, uint64_t key);
 126 uint64_t        *pctrie_lookup_le(struct pctrie *ptree, uint64_t key);
 127 uint64_t        *pctrie_lookup_unlocked(struct pctrie *ptree, uint64_t key,
 128                     smr_t smr);
 129 void            pctrie_reclaim_allnodes(struct pctrie *ptree,
 130                     pctrie_free_t freefn);
 131 void            pctrie_remove(struct pctrie *ptree, uint64_t key,
 132                     pctrie_free_t freefn);
 133 size_t          pctrie_node_size(void);
 134 int             pctrie_zone_init(void *mem, int size, int flags);
 135
 136 static __inline void
 137 pctrie_init(struct pctrie *ptree)
 138 {
 139
 140         ptree->pt_root = 0;
 141 }
 142
 143 static __inline bool
 144 pctrie_is_empty(struct pctrie *ptree)
 145 {
 146
 147         return (ptree->pt_root == 0);
 148 }
 149
 150 /*
 151  * These widths should allow the pointers to a node's children to fit within
 152  * a single cache line.  The extra levels from a narrow width should not be
 153  * a problem thanks to path compression.
 154  */
 155 #ifdef __LP64__
 156 #define PCTRIE_WIDTH    4
 157 #else
 158 #define PCTRIE_WIDTH    3
 159 #endif
 160
 161 #define PCTRIE_COUNT    (1 << PCTRIE_WIDTH)
 162
 163 #endif /* _KERNEL */
 164 #endif /* !_SYS_PCTRIE_H_ */