os_mempool.h

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
 
#ifndef _OS_MEMPOOL_H_
#define _OS_MEMPOOL_H_
 
#include <stdbool.h>
#include "os.h"
#include "queue.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct os_memblock {
    SLIST_ENTRY(os_memblock) mb_next;
};
 
/* XXX: Change this structure so that we keep the first address in the pool? */
/* XXX: add memory debug structure and associated code */
/* XXX: Change how I coded the SLIST_HEAD here. It should be named:
   SLIST_HEAD(,os_memblock) mp_head; */
 
struct os_mempool {
    uint32_t mp_block_size;
    uint16_t mp_num_blocks;
    uint16_t mp_num_free;
    uint16_t mp_min_free;
    uint8_t mp_flags;
    uint32_t mp_membuf_addr;
    STAILQ_ENTRY(os_mempool) mp_list;
    SLIST_HEAD(,os_memblock);
    const char *name;
};
 
#define OS_MEMPOOL_F_EXT        0x01
 
struct os_mempool_ext;
 
typedef os_error_t os_mempool_put_fn(struct os_mempool_ext *ome, void *data,
                                     void *arg);
 
struct os_mempool_ext {
    struct os_mempool mpe_mp;
 
    /* Callback that is executed immediately when a block is freed. */
    os_mempool_put_fn *mpe_put_cb;
    void *mpe_put_arg;
};
 
#define OS_MEMPOOL_INFO_NAME_LEN (32)
 
struct os_mempool_info {
    int omi_block_size;
    int omi_num_blocks;
    int omi_num_free;
    int omi_min_free;
    char omi_name[OS_MEMPOOL_INFO_NAME_LEN];
};
 
struct os_mempool *os_mempool_info_get_next(struct os_mempool *,
                                            struct os_mempool_info *);
 
/*
 * To calculate size of the memory buffer needed for the pool. NOTE: This size
 * is NOT in bytes! The size is the number of os_membuf_t elements required for
 * the memory pool.
 */
#if MYNEWT_VAL(OS_MEMPOOL_GUARD)
/*
 * Leave extra 4 bytes of guard area at the end.
 */
#define OS_MEMPOOL_BLOCK_SZ(sz) ((sz) + sizeof(os_membuf_t))
#else
#define OS_MEMPOOL_BLOCK_SZ(sz) (sz)
#endif
#if (OS_ALIGNMENT == 4)
typedef uint32_t os_membuf_t;
#elif (OS_ALIGNMENT == 8)
typedef uint64_t os_membuf_t;
#elif (OS_ALIGNMENT == 16)
typedef __uint128_t os_membuf_t;
#else
#error "Unhandled `OS_ALIGNMENT` for `os_membuf_t`"
#endif /* OS_ALIGNMENT == * */
#define OS_MEMPOOL_SIZE(n,blksize)      ((((blksize) + ((OS_ALIGNMENT)-1)) / (OS_ALIGNMENT)) * (n))
 
#define OS_MEMPOOL_BYTES(n,blksize)     \
    (sizeof (os_membuf_t) * OS_MEMPOOL_SIZE((n), (blksize)))
 
#if SOC_ESP_NIMBLE_CONTROLLER && CONFIG_BT_CONTROLLER_ENABLED
os_error_t r_os_mempool_init(struct os_mempool *mp, uint16_t blocks,
                           uint32_t block_size, void *membuf, const char *name);
#define os_mempool_init r_os_mempool_init
os_error_t r_os_mempool_ext_init(struct os_mempool_ext *mpe, uint16_t blocks,
                               uint32_t block_size, void *membuf, const char *name);
#define os_mempool_ext_init r_os_mempool_ext_init
os_error_t r_os_mempool_unregister(struct os_mempool *mp);
#define os_mempool_unregister r_os_mempool_unregister
 
 
os_error_t r_os_mempool_clear(struct os_mempool *mp);
#define os_mempool_clear r_os_mempool_clear
 
 
bool r_os_mempool_is_sane(const struct os_mempool *mp);
#define os_mempool_is_sane r_os_mempool_is_sane
 
 
int r_os_memblock_from(const struct os_mempool *mp, const void *block_addr);
#define os_memblock_from r_os_memblock_from
 
 
void *r_os_memblock_get(struct os_mempool *mp);
#define os_memblock_get r_os_memblock_get
os_error_t r_os_memblock_put_from_cb(struct os_mempool *mp, void *block_addr);
#define os_memblock_put_from_cb r_os_memblock_put_from_cb
 
 
os_error_t r_os_memblock_put(struct os_mempool *mp, void *block_addr);
#define os_memblock_put r_os_memblock_put
 
#else
os_error_t os_mempool_init(struct os_mempool *mp, uint16_t blocks,
                           uint32_t block_size, void *membuf, const char *name);
 
os_error_t os_mempool_ext_init(struct os_mempool_ext *mpe, uint16_t blocks,
                               uint32_t block_size, void *membuf, const char *name);
 
os_error_t os_mempool_unregister(struct os_mempool *mp);
 
os_error_t os_mempool_clear(struct os_mempool *mp);
 
os_error_t os_mempool_ext_clear(struct os_mempool_ext *mpe);
 
bool os_mempool_is_sane(const struct os_mempool *mp);
 
int os_memblock_from(const struct os_mempool *mp, const void *block_addr);
 
void *os_memblock_get(struct os_mempool *mp);
 
os_error_t os_memblock_put_from_cb(struct os_mempool *mp, void *block_addr);
 
os_error_t os_memblock_put(struct os_mempool *mp, void *block_addr);
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif  /* _OS_MEMPOOL_H_ */