os_mbuf.h

/*
 * SPDX-FileCopyrightText: 2015-2022 The Apache Software Foundation (ASF)
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * SPDX-FileContributor: 2019-2022 Espressif Systems (Shanghai) CO LTD
 */
/*
 * 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_MBUF_H
#define _OS_MBUF_H
 
#include "os.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct os_mbuf_pool {
    uint16_t omp_databuf_len;
    struct os_mempool *omp_pool;
 
    STAILQ_ENTRY(os_mbuf_pool) omp_next;
};
 
 
struct os_mbuf_pkthdr {
    uint16_t omp_len;
    uint16_t omp_flags;
 
    STAILQ_ENTRY(os_mbuf_pkthdr) omp_next;
};
 
struct os_mbuf {
    uint8_t *om_data;
    uint8_t om_flags;
    uint8_t om_pkthdr_len;
    uint16_t om_len;
 
    struct os_mbuf_pool *om_omp;
 
    SLIST_ENTRY(os_mbuf) om_next;
 
    uint8_t om_databuf[0];
};
 
struct os_mqueue {
    STAILQ_HEAD(, os_mbuf_pkthdr) mq_head;
    struct ble_npl_event mq_ev;
};
 
/*
 * Given a flag number, provide the mask for it
 *
 * @param __n The number of the flag in the mask
 */
#define OS_MBUF_F_MASK(__n) (1 << (__n))
 
/*
 * Checks whether a given mbuf is a packet header mbuf
 *
 * @param __om The mbuf to check
 */
#define OS_MBUF_IS_PKTHDR(__om) \
    ((__om)->om_pkthdr_len >= sizeof (struct os_mbuf_pkthdr))
 
#define OS_MBUF_PKTHDR(__om) ((struct os_mbuf_pkthdr *)     \
    (void *)((uint8_t *)&(__om)->om_data + sizeof(struct os_mbuf)))
 
#define OS_MBUF_PKTHDR_TO_MBUF(__hdr)   \
     (struct os_mbuf *)(void *)((uint8_t *)(__hdr) - sizeof(struct os_mbuf))
 
#define OS_MBUF_PKTLEN(__om) (OS_MBUF_PKTHDR(__om)->omp_len)
 
#define OS_MBUF_DATA(__om, __type) \
     (__type) ((__om)->om_data)
 
#define OS_MBUF_USRHDR(om)                              \
    (void *)((uint8_t *)om + sizeof (struct os_mbuf) +  \
             sizeof (struct os_mbuf_pkthdr))
 
#define OS_MBUF_USRHDR_LEN(om) \
    ((om)->om_pkthdr_len - sizeof (struct os_mbuf_pkthdr))
 
 
/*
 * Called by OS_MBUF_LEADINGSPACE() macro
 */
static inline uint16_t
_os_mbuf_leadingspace(struct os_mbuf *om)
{
    uint16_t startoff;
    uint16_t leadingspace;
 
    startoff = 0;
    if (OS_MBUF_IS_PKTHDR(om)) {
        startoff = om->om_pkthdr_len;
    }
 
    leadingspace = (uint16_t) (OS_MBUF_DATA(om, uint8_t *) -
                               ((uint8_t *) &om->om_databuf[0] + startoff));
 
    return (leadingspace);
}
 
#define OS_MBUF_LEADINGSPACE(__om) _os_mbuf_leadingspace(__om)
 
 
/* Called by OS_MBUF_TRAILINGSPACE() macro. */
static inline uint16_t
_os_mbuf_trailingspace(struct os_mbuf *om)
{
    struct os_mbuf_pool *omp;
 
    omp = om->om_omp;
 
    return (&om->om_databuf[0] + omp->omp_databuf_len) -
           (om->om_data + om->om_len);
}
 
#define OS_MBUF_TRAILINGSPACE(__om) _os_mbuf_trailingspace(__om)
 
 
#if SOC_ESP_NIMBLE_CONTROLLER && CONFIG_BT_CONTROLLER_ENABLED
int r_os_mqueue_init(struct os_mqueue *mq, ble_npl_event_fn *ev_cb, void *arg);
#define os_mqueue_init r_os_mqueue_init
 
 
struct os_mbuf *r_os_mqueue_get(struct os_mqueue *);
#define os_mqueue_get r_os_mqueue_get
int r_os_mqueue_put(struct os_mqueue *, struct ble_npl_eventq *, struct os_mbuf *);
#define os_mqueue_put r_os_mqueue_put
 
 
int r_os_msys_register(struct os_mbuf_pool *);
#define os_msys_register r_os_msys_register
 
 
struct os_mbuf *r_os_msys_get(uint16_t dsize, uint16_t leadingspace);
#define os_msys_get r_os_msys_get
void r_os_msys_reset(void);
#define os_msys_reset r_os_msys_reset
 
 
struct os_mbuf *r_os_msys_get_pkthdr(uint16_t dsize, uint16_t user_hdr_len);
#define os_msys_get_pkthdr r_os_msys_get_pkthdr
int r_os_msys_count(void);
#define os_msys_count r_os_msys_count
 
 
int r_os_msys_num_free(void);
#define os_msys_num_free r_os_msys_num_free
 
 
int r_os_mbuf_pool_init(struct os_mbuf_pool *, struct os_mempool *mp,
                      uint16_t, uint16_t);
#define os_mbuf_pool_init r_os_mbuf_pool_init
struct os_mbuf *r_os_mbuf_get(struct os_mbuf_pool *omp, uint16_t);
#define os_mbuf_get r_os_mbuf_get
struct os_mbuf *r_os_mbuf_get_pkthdr(struct os_mbuf_pool *omp,
                                   uint8_t pkthdr_len);
#define os_mbuf_get_pkthdr r_os_mbuf_get_pkthdr
struct os_mbuf *r_os_mbuf_dup(struct os_mbuf *m);
#define os_mbuf_dup r_os_mbuf_dup
struct os_mbuf *r_os_mbuf_off(const struct os_mbuf *om, int off,
                            uint16_t *out_off);
#define os_mbuf_off r_os_mbuf_off
 
/*
 * Copy data from an mbuf chain starting "off" bytes from the beginning,
 * continuing for "len" bytes, into the indicated buffer.
 *
 * @param m The mbuf chain to copy from
 * @param off The offset into the mbuf chain to begin copying from
 * @param len The length of the data to copy
 * @param dst The destination buffer to copy into
 *
 * @return                      0 on success;
 *                              -1 if the mbuf does not contain enough data.
 */
int r_os_mbuf_copydata(const struct os_mbuf *m, int off, int len, void *dst);
#define os_mbuf_copydata r_os_mbuf_copydata
 
 
uint16_t r_os_mbuf_len(const struct os_mbuf *om);
#define os_mbuf_len r_os_mbuf_len
 
 
int r_os_mbuf_append(struct os_mbuf *m, const void *, uint16_t);
#define os_mbuf_append r_os_mbuf_append
 
 
int r_os_mbuf_appendfrom(struct os_mbuf *dst, const struct os_mbuf *src,
                       uint16_t src_off, uint16_t len);
#define os_mbuf_appendfrom r_os_mbuf_appendfrom
int r_os_mbuf_free(struct os_mbuf *mb);
#define os_mbuf_free r_os_mbuf_free
 
 
int r_os_mbuf_free_chain(struct os_mbuf *om);
#define os_mbuf_free_chain r_os_mbuf_free_chain
 
 
void r_os_mbuf_adj(struct os_mbuf *mp, int req_len);
#define os_mbuf_adj r_os_mbuf_adj
 
 
 
int r_os_mbuf_cmpf(const struct os_mbuf *om, int off, const void *data, int len);
#define os_mbuf_cmpf r_os_mbuf_cmpf
 
 
int r_os_mbuf_cmpm(const struct os_mbuf *om1, uint16_t offset1,
                 const struct os_mbuf *om2, uint16_t offset2,
                 uint16_t len);
#define os_mbuf_cmpm r_os_mbuf_cmpm
struct os_mbuf *r_os_mbuf_prepend(struct os_mbuf *om, int len);
#define os_mbuf_prepend r_os_mbuf_prepend
struct os_mbuf *r_os_mbuf_prepend_pullup(struct os_mbuf *om, uint16_t len);
#define os_mbuf_prepend_pullup r_os_mbuf_prepend_pullup
int r_os_mbuf_copyinto(struct os_mbuf *om, int off, const void *src, int len);
#define os_mbuf_copyinto r_os_mbuf_copyinto
 
 
void r_os_mbuf_concat(struct os_mbuf *first, struct os_mbuf *second);
#define os_mbuf_concat r_os_mbuf_concat
 
 
 
void *r_os_mbuf_extend(struct os_mbuf *om, uint16_t len);
#define os_mbuf_extend r_os_mbuf_extend
struct os_mbuf *r_os_mbuf_pullup(struct os_mbuf *om, uint16_t len);
#define os_mbuf_pullup r_os_mbuf_pullup
 
struct os_mbuf *r_os_mbuf_trim_front(struct os_mbuf *om);
#define os_mbuf_trim_front r_os_mbuf_trim_front
int r_os_mbuf_widen(struct os_mbuf *om, uint16_t off, uint16_t len);
#define os_mbuf_widen r_os_mbuf_widen
 
 
 
struct os_mbuf *r_os_mbuf_pack_chains(struct os_mbuf *m1, struct os_mbuf *m2);
#define os_mbuf_pack_chains r_os_mbuf_pack_chains
 
#else
int os_mqueue_init(struct os_mqueue *mq, ble_npl_event_fn *ev_cb, void *arg);
 
struct os_mbuf *os_mqueue_get(struct os_mqueue *);
 
int os_mqueue_put(struct os_mqueue *, struct ble_npl_eventq *, struct os_mbuf *);
 
int os_msys_register(struct os_mbuf_pool *);
 
struct os_mbuf *os_msys_get(uint16_t dsize, uint16_t leadingspace);
 
void os_msys_reset(void);
 
struct os_mbuf *os_msys_get_pkthdr(uint16_t dsize, uint16_t user_hdr_len);
 
int os_msys_count(void);
 
int os_msys_num_free(void);
 
int os_mbuf_pool_init(struct os_mbuf_pool *, struct os_mempool *mp,
                      uint16_t, uint16_t);
 
struct os_mbuf *os_mbuf_get(struct os_mbuf_pool *omp, uint16_t);
 
struct os_mbuf *os_mbuf_get_pkthdr(struct os_mbuf_pool *omp,
                                   uint8_t pkthdr_len);
 
struct os_mbuf *os_mbuf_dup(struct os_mbuf *m);
 
struct os_mbuf *os_mbuf_off(const struct os_mbuf *om, int off,
                            uint16_t *out_off);
 
 
/*
 * Copy data from an mbuf chain starting "off" bytes from the beginning,
 * continuing for "len" bytes, into the indicated buffer.
 *
 * @param m The mbuf chain to copy from
 * @param off The offset into the mbuf chain to begin copying from
 * @param len The length of the data to copy
 * @param dst The destination buffer to copy into
 *
 * @return                      0 on success;
 *                              -1 if the mbuf does not contain enough data.
 */
int os_mbuf_copydata(const struct os_mbuf *m, int off, int len, void *dst);
 
uint16_t os_mbuf_len(const struct os_mbuf *om);
 
int os_mbuf_append(struct os_mbuf *m, const void *, uint16_t);
 
int os_mbuf_appendfrom(struct os_mbuf *dst, const struct os_mbuf *src,
                       uint16_t src_off, uint16_t len);
 
int os_mbuf_free(struct os_mbuf *mb);
 
int os_mbuf_free_chain(struct os_mbuf *om);
 
void os_mbuf_adj(struct os_mbuf *mp, int req_len);
 
 
int os_mbuf_cmpf(const struct os_mbuf *om, int off, const void *data, int len);
 
int os_mbuf_cmpm(const struct os_mbuf *om1, uint16_t offset1,
                 const struct os_mbuf *om2, uint16_t offset2,
                 uint16_t len);
 
struct os_mbuf *os_mbuf_prepend(struct os_mbuf *om, int len);
 
struct os_mbuf *os_mbuf_prepend_pullup(struct os_mbuf *om, uint16_t len);
 
int os_mbuf_copyinto(struct os_mbuf *om, int off, const void *src, int len);
 
void os_mbuf_concat(struct os_mbuf *first, struct os_mbuf *second);
 
 
void *os_mbuf_extend(struct os_mbuf *om, uint16_t len);
 
struct os_mbuf *os_mbuf_pullup(struct os_mbuf *om, uint16_t len);
 
 
struct os_mbuf *os_mbuf_trim_front(struct os_mbuf *om);
 
int os_mbuf_widen(struct os_mbuf *om, uint16_t off, uint16_t len);
 
 
struct os_mbuf *os_mbuf_pack_chains(struct os_mbuf *m1, struct os_mbuf *m2);
 
#endif
#ifdef __cplusplus
}
#endif
 
#endif /* _OS_MBUF_H */