#include <rte_errno.h>
#include <rte_malloc.h>
#include <rte_string_fns.h>
+#include <rte_bitops.h>
#include <rte_mbuf.h>
#include <rte_mbuf_dyn.h>
#define RTE_MBUF_DYN_MZNAME "rte_mbuf_dyn"
struct mbuf_dynfield_elt {
- TAILQ_ENTRY(mbuf_dynfield_elt) next;
struct rte_mbuf_dynfield params;
size_t offset;
};
EAL_REGISTER_TAILQ(mbuf_dynfield_tailq);
struct mbuf_dynflag_elt {
- TAILQ_ENTRY(mbuf_dynflag_elt) next;
struct rte_mbuf_dynflag params;
unsigned int bitnum;
};
shm->free_space[i] = 1;
}
- for (off = 0; off < sizeof(struct rte_mbuf); off++) {
+ off = 0;
+ while (off < sizeof(struct rte_mbuf)) {
/* get the size of the free zone */
- for (size = 0; shm->free_space[off + size]; size++)
+ for (size = 0; (off + size) < sizeof(struct rte_mbuf) &&
+ shm->free_space[off + size]; size++)
;
- if (size == 0)
+ if (size == 0) {
+ off++;
continue;
+ }
/* get the alignment of biggest object that can fit in
* the zone at this offset.
;
/* save it in free_space[] */
- for (i = off; i < off + size; i++)
+ for (i = off; i < off + align; i++)
shm->free_space[i] = RTE_MAX(align, shm->free_space[i]);
+
+ off += align;
}
}
break;
}
- if (te == NULL) {
+ if (te == NULL || mbuf_dynfield == NULL) {
rte_errno = ENOENT;
return NULL;
}
{
struct mbuf_dynfield_elt *mbuf_dynfield;
- if (shm == NULL) {
- rte_errno = ENOENT;
- return -1;
- }
-
rte_mcfg_tailq_read_lock();
- mbuf_dynfield = __mbuf_dynfield_lookup(name);
+ if (shm == NULL && init_shared_mem() < 0)
+ mbuf_dynfield = NULL;
+ else
+ mbuf_dynfield = __mbuf_dynfield_lookup(name);
rte_mcfg_tailq_read_unlock();
- if (mbuf_dynfield == NULL) {
- rte_errno = ENOENT;
+ if (mbuf_dynfield == NULL)
return -1;
- }
if (params != NULL)
memcpy(params, &mbuf_dynfield->params, sizeof(*params));
mbuf_dynfield_tailq.head, mbuf_dynfield_list);
te = rte_zmalloc("MBUF_DYNFIELD_TAILQ_ENTRY", sizeof(*te), 0);
- if (te == NULL)
+ if (te == NULL) {
+ rte_errno = ENOMEM;
return -1;
+ }
mbuf_dynfield = rte_zmalloc("mbuf_dynfield", sizeof(*mbuf_dynfield), 0);
if (mbuf_dynfield == NULL) {
rte_free(te);
+ rte_errno = ENOMEM;
return -1;
}
{
struct mbuf_dynflag_elt *mbuf_dynflag;
- if (shm == NULL) {
- rte_errno = ENOENT;
- return -1;
- }
-
rte_mcfg_tailq_read_lock();
- mbuf_dynflag = __mbuf_dynflag_lookup(name);
+ if (shm == NULL && init_shared_mem() < 0)
+ mbuf_dynflag = NULL;
+ else
+ mbuf_dynflag = __mbuf_dynflag_lookup(name);
rte_mcfg_tailq_read_unlock();
- if (mbuf_dynflag == NULL) {
- rte_errno = ENOENT;
+ if (mbuf_dynflag == NULL)
return -1;
- }
if (params != NULL)
memcpy(params, &mbuf_dynflag->params, sizeof(*params));
mbuf_dynflag_tailq.head, mbuf_dynflag_list);
te = rte_zmalloc("MBUF_DYNFLAG_TAILQ_ENTRY", sizeof(*te), 0);
- if (te == NULL)
+ if (te == NULL) {
+ rte_errno = ENOMEM;
return -1;
+ }
mbuf_dynflag = rte_zmalloc("mbuf_dynflag", sizeof(*mbuf_dynflag), 0);
if (mbuf_dynflag == NULL) {
rte_free(te);
+ rte_errno = ENOMEM;
return -1;
}
dynflag->params.name, dynflag->bitnum,
dynflag->params.flags);
}
- fprintf(out, "Free space in mbuf (0 = free, value = zone alignment):\n");
+ fprintf(out, "Free space in mbuf (0 = occupied, value = free zone alignment):\n");
for (i = 0; i < sizeof(struct rte_mbuf); i++) {
if ((i % 8) == 0)
fprintf(out, " %4.4zx: ", i);
fprintf(out, "%2.2x%s", shm->free_space[i],
(i % 8 != 7) ? " " : "\n");
}
+ fprintf(out, "Free bit in mbuf->ol_flags (0 = occupied, 1 = free):\n");
+ for (i = 0; i < sizeof(uint64_t) * CHAR_BIT; i++) {
+ if ((i % 8) == 0)
+ fprintf(out, " %4.4zx: ", i);
+ fprintf(out, "%1.1x%s", (shm->free_flags & (1ULL << i)) ? 1 : 0,
+ (i % 8 != 7) ? " " : "\n");
+ }
+
rte_mcfg_tailq_write_unlock();
}
+
+static int
+rte_mbuf_dyn_timestamp_register(int *field_offset, uint64_t *flag,
+ const char *direction, const char *flag_name)
+{
+ static const struct rte_mbuf_dynfield field_desc = {
+ .name = RTE_MBUF_DYNFIELD_TIMESTAMP_NAME,
+ .size = sizeof(rte_mbuf_timestamp_t),
+ .align = __alignof__(rte_mbuf_timestamp_t),
+ };
+ struct rte_mbuf_dynflag flag_desc = {};
+ int offset;
+
+ offset = rte_mbuf_dynfield_register(&field_desc);
+ if (offset < 0) {
+ RTE_LOG(ERR, MBUF,
+ "Failed to register mbuf field for timestamp\n");
+ return -1;
+ }
+ if (field_offset != NULL)
+ *field_offset = offset;
+
+ strlcpy(flag_desc.name, flag_name, sizeof(flag_desc.name));
+ offset = rte_mbuf_dynflag_register(&flag_desc);
+ if (offset < 0) {
+ RTE_LOG(ERR, MBUF,
+ "Failed to register mbuf flag for %s timestamp\n",
+ direction);
+ return -1;
+ }
+ if (flag != NULL)
+ *flag = RTE_BIT64(offset);
+
+ return 0;
+}
+
+int
+rte_mbuf_dyn_rx_timestamp_register(int *field_offset, uint64_t *rx_flag)
+{
+ return rte_mbuf_dyn_timestamp_register(field_offset, rx_flag,
+ "Rx", RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME);
+}
+
+int
+rte_mbuf_dyn_tx_timestamp_register(int *field_offset, uint64_t *tx_flag)
+{
+ return rte_mbuf_dyn_timestamp_register(field_offset, tx_flag,
+ "Tx", RTE_MBUF_DYNFLAG_TX_TIMESTAMP_NAME);
+}