1 /*- 2 * BSD LICENSE 3 * 4 * Copyright(c) 2016 Intel Corporation. All rights reserved. 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 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include <stdio.h> 35 #include <rte_mempool.h> 36 #include <rte_malloc.h> 37 38 struct rte_mempool_stack { 39 rte_spinlock_t sl; 40 41 uint32_t size; 42 uint32_t len; 43 void *objs[]; 44 }; 45 46 static int 47 stack_alloc(struct rte_mempool *mp) 48 { 49 struct rte_mempool_stack *s; 50 unsigned n = mp->size; 51 int size = sizeof(*s) + (n+16)*sizeof(void *); 52 53 /* Allocate our local memory structure */ 54 s = rte_zmalloc_socket("mempool-stack", 55 size, 56 RTE_CACHE_LINE_SIZE, 57 mp->socket_id); 58 if (s == NULL) { 59 RTE_LOG(ERR, MEMPOOL, "Cannot allocate stack!\n"); 60 return -ENOMEM; 61 } 62 63 rte_spinlock_init(&s->sl); 64 65 s->size = n; 66 mp->pool_data = s; 67 68 return 0; 69 } 70 71 static int 72 stack_enqueue(struct rte_mempool *mp, void * const *obj_table, 73 unsigned n) 74 { 75 struct rte_mempool_stack *s = mp->pool_data; 76 void **cache_objs; 77 unsigned index; 78 79 rte_spinlock_lock(&s->sl); 80 cache_objs = &s->objs[s->len]; 81 82 /* Is there sufficient space in the stack ? */ 83 if ((s->len + n) > s->size) { 84 rte_spinlock_unlock(&s->sl); 85 return -ENOBUFS; 86 } 87 88 /* Add elements back into the cache */ 89 for (index = 0; index < n; ++index, obj_table++) 90 cache_objs[index] = *obj_table; 91 92 s->len += n; 93 94 rte_spinlock_unlock(&s->sl); 95 return 0; 96 } 97 98 static int 99 stack_dequeue(struct rte_mempool *mp, void **obj_table, 100 unsigned n) 101 { 102 struct rte_mempool_stack *s = mp->pool_data; 103 void **cache_objs; 104 unsigned index, len; 105 106 rte_spinlock_lock(&s->sl); 107 108 if (unlikely(n > s->len)) { 109 rte_spinlock_unlock(&s->sl); 110 return -ENOENT; 111 } 112 113 cache_objs = s->objs; 114 115 for (index = 0, len = s->len - 1; index < n; 116 ++index, len--, obj_table++) 117 *obj_table = cache_objs[len]; 118 119 s->len -= n; 120 rte_spinlock_unlock(&s->sl); 121 return 0; 122 } 123 124 static unsigned 125 stack_get_count(const struct rte_mempool *mp) 126 { 127 struct rte_mempool_stack *s = mp->pool_data; 128 129 return s->len; 130 } 131 132 static void 133 stack_free(struct rte_mempool *mp) 134 { 135 rte_free((void *)(mp->pool_data)); 136 } 137 138 static struct rte_mempool_ops ops_stack = { 139 .name = "stack", 140 .alloc = stack_alloc, 141 .free = stack_free, 142 .enqueue = stack_enqueue, 143 .dequeue = stack_dequeue, 144 .get_count = stack_get_count 145 }; 146 147 MEMPOOL_REGISTER_OPS(ops_stack); 148