|
| emac_mem_buf_t * | alloc_heap (uint32_t size, uint32_t align) override |
| | Allocates memory buffer from the heap.
|
| |
| emac_mem_buf_t * | alloc_pool (uint32_t size, uint32_t align) override |
| | Allocates memory buffer chain from a pool.
|
| |
| uint32_t | get_pool_alloc_unit (uint32_t align) const override |
| | Get memory buffer pool allocation unit.
|
| |
| void | free (emac_mem_buf_t *buf) override |
| | Free memory buffer chain.
|
| |
| uint32_t | get_total_len (const emac_mem_buf_t *buf) const override |
| | Return total length of a memory buffer chain.
|
| |
| void | cat (emac_mem_buf_t *to_buf, emac_mem_buf_t *cat_buf) override |
| | Concatenate two memory buffer chains.
|
| |
| emac_mem_buf_t * | get_next (const emac_mem_buf_t *buf) const override |
| | Returns the next buffer.
|
| |
| void * | get_ptr (const emac_mem_buf_t *buf) const override |
| | Return pointer to the payload of the buffer.
|
| |
| uint32_t | get_len (const emac_mem_buf_t *buf) const override |
| | Return payload size of this individual buffer (NOT including any chained buffers)
|
| |
| void | set_len (emac_mem_buf_t *buf, uint32_t len) override |
| | Sets the payload size of the buffer.
|
| |
| Lifetime | get_lifetime (const net_stack_mem_buf_t *buf) const override |
| | Gets the lifetime of the buffer.
|
| |
| void | skip_header_space (net_stack_mem_buf_t *buf, int32_t amount) override |
| | Skips (or un-skips) header space from the buffer.
|
| |
| int32_t | get_header_skip_size (net_stack_mem_buf_t *buf) override |
| | Get the total number of header bytes that are currently being skipped.
|
| |
| net_stack_mem_buf_t * | realloc_heap (net_stack_mem_buf_t *orig_buf, uint32_t new_align, std::optional< uint32_t > new_len=std::nullopt, std::optional< uint16_t > new_header_skip_size=std::nullopt) |
| | Reallocates a buffer or buffer chain as a contiguous (non-chained) heap buffer, freeing the original.
|
| |
| uint32_t | get_pool_size () |
| | Get memory buffer pool size.
|
| |
| virtual void | copy_to_buf (net_stack_mem_buf_t *to_buf, const void *ptr, uint32_t len) |
| | Copy from a raw buffer in memory to a memory buffer chain.
|
| |
| virtual uint32_t | copy_from_buf (void *ptr, uint32_t len, const net_stack_mem_buf_t *from_buf) const |
| | Copy from a memory buffer chain to a raw buffer in memory.
|
| |
| size_t | count_buffers (const net_stack_mem_buf_t *buf) |
| | Count the number of buffers in a buffer chain.
|
| |
| void | restore_header_space (net_stack_mem_buf_t *buf, const int32_t amount) |
| | Restores previously skipped header space to the buffer.
|
| |
| void | set_on_pool_space_avail_cb (mbed::Callback< void()> cb) |
| | Set callback which will be called when pool space becomes available.
|
| |
Definition at line 24 of file NanostackMemoryManager.h.
| void set_len |
( |
emac_mem_buf_t * |
buf, |
|
|
uint32_t |
len |
|
) |
| |
|
overridevirtual |
Sets the payload size of the buffer.
The allocated payload size will not change. It is not permitted to change the length of a buffer that is not the first (or only) in a chain.
Note that this is affected by the current header skip size (see below)
*Note as of Dec 2024: Different implementations (Nanostack vs LwIP) disagree about how to implement this operation. Specifically, if called on the head of a buffer chain, the LwIP implementation allows changing the length of the chain as a whole. However, the Nanostack implementation does not and only can change the length of the head buffer. For fear of breaking existing code, I do not want to change this behavior. So, if constructing a buffer chain, it is safest to set the buffer lengths first before building the chain.
- Parameters
-
| buf | Memory buffer |
| len | Payload size, must be less or equal to the allocated size |
Implements NetStackMemoryManager.
| void skip_header_space |
( |
net_stack_mem_buf_t * |
buf, |
|
|
int32_t |
amount |
|
) |
| |
|
overridevirtual |
Skips (or un-skips) header space from the buffer.
Skipping n bytes of header space causes the buffer's payload pointer to refer to a location n bytes after the base address of the packet buffer, and the length of the buffer to be decreased by n.
This is commonly used to skip protocol headers in network packets. For example, if you have an Ethernet frame, skipping 14 bytes of header space will cause the "start" of the packet buffer to point to the IP header instead.
Multiple calls to this function add together, so for example if you first skip 14 bytes, then -4, then 10, the result will be 20 total bytes of skipped header.
- Parameters
-
| buf | Buffer to operate on. |
| amount | Amount of header space to skip. Negative values are allowed and cause previously skipped header space to be removed. |
- Warning
- Skipping a larger total header space than the size of the first buffer in the chain, or skipping a negative total header space, results in undefined behavior.
Implements NetStackMemoryManager.
Callback which shall be called (if set) by the implementation after one or more buffer spaces become free in the pool.
This is used by zero-copy Ethernet MACs as a hint that now is a good time to allocate fresh buffers off the pool into Ethernet descriptors. It is legal to call this function if you aren't totally sure new memory is available – the mac will try to allocate more buffers, and if it can't, oh well. However, it is not legal for memory to become available without a call to this function. Such a situation might lead to a lockup of the MAC due to not having memory allocated for Rx.
Definition at line 65 of file NetStackMemoryManager.h.
1.9.8