|
| virtual net_stack_mem_buf_t * | alloc_heap (uint32_t size, uint32_t align)=0 |
| | Allocates memory buffer from the heap.
|
| |
| virtual net_stack_mem_buf_t * | alloc_pool (uint32_t size, uint32_t align)=0 |
| | Allocates memory buffer chain from a pool.
|
| |
| 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.
|
| |
| virtual uint32_t | get_pool_alloc_unit (uint32_t align) const =0 |
| | Get memory buffer pool allocation unit.
|
| |
| uint32_t | get_pool_size () |
| | Get memory buffer pool size.
|
| |
| virtual void | free (net_stack_mem_buf_t *buf)=0 |
| | Free memory buffer chain.
|
| |
| virtual uint32_t | get_total_len (const net_stack_mem_buf_t *buf) const =0 |
| | Return total length of a memory buffer chain.
|
| |
| 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.
|
| |
| virtual void | cat (net_stack_mem_buf_t *to_buf, net_stack_mem_buf_t *cat_buf)=0 |
| | Concatenate two memory buffer chains.
|
| |
| virtual net_stack_mem_buf_t * | get_next (const net_stack_mem_buf_t *buf) const =0 |
| | Returns the next buffer.
|
| |
| size_t | count_buffers (const net_stack_mem_buf_t *buf) |
| | Count the number of buffers in a buffer chain.
|
| |
| virtual void * | get_ptr (const net_stack_mem_buf_t *buf) const =0 |
| | Return pointer to the payload of the buffer.
|
| |
| virtual uint32_t | get_len (const net_stack_mem_buf_t *buf) const =0 |
| | Return payload size of this individual buffer (NOT including any chained buffers)
|
| |
| virtual void | set_len (net_stack_mem_buf_t *buf, uint32_t len)=0 |
| | Sets the payload size of the buffer.
|
| |
| virtual void | skip_header_space (net_stack_mem_buf_t *buf, int32_t amount)=0 |
| | Skips (or un-skips) header space from the buffer.
|
| |
| void | restore_header_space (net_stack_mem_buf_t *buf, const int32_t amount) |
| | Restores previously skipped header space to the buffer.
|
| |
| virtual int32_t | get_header_skip_size (net_stack_mem_buf_t *buf)=0 |
| | Get the total number of header bytes that are currently being skipped.
|
| |
| virtual Lifetime | get_lifetime (net_stack_mem_buf_t const *buf) const =0 |
| | Gets the lifetime of 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 45 of file EMACMemoryManager.h.
| virtual void set_len |
( |
net_stack_mem_buf_t * |
buf, |
|
|
uint32_t |
len |
|
) |
| |
|
pure virtualinherited |
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 |
Implemented in NanostackMemoryManager.
| virtual void skip_header_space |
( |
net_stack_mem_buf_t * |
buf, |
|
|
int32_t |
amount |
|
) |
| |
|
pure virtualinherited |
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.
Implemented in NanostackMemoryManager.
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