reduce dependency on sertopic->status_cb_entity

Signed-off-by: Erik Boasson <eb@ilities.com>

src/core/ddsc/src/dds_rhc.c

@@ -653,7 +653,7 @@ static bool add_sample
     rhc->n_vsamples++;
   }
 
-  s->sample = ddsi_serdata_ref ((struct ddsi_serdata *) sample); /* drops const (tho refcount does change) */
+  s->sample = ddsi_serdata_ref (sample); /* drops const (tho refcount does change) */
   s->wr_iid = pwr_info->iid;
   s->isread = false;
   s->disposed_gen = inst->disposed_gen;
@@ -663,19 +663,17 @@ static bool add_sample
   return true;
 }
 
-static bool content_filter_accepts (const struct ddsi_sertopic * sertopic, const struct ddsi_serdata *sample)
+static bool content_filter_accepts (const struct ddsi_sertopic *sertopic, const struct ddsi_serdata *sample)
 {
   bool ret = true;
   const struct dds_topic *tp = sertopic->status_cb_entity;
   if (tp->filter_fn)
   {
     const dds_topic_descriptor_t * desc = tp->m_descriptor;
-    char *tmp = os_malloc (desc->m_size);
+    char *tmp = dds_alloc (desc->m_size);
-    memset (tmp, 0, desc->m_size);
     ddsi_serdata_to_sample (sample, tmp, NULL, NULL);
     ret = (tp->filter_fn) (tmp, tp->filter_ctx);
-    dds_sample_free(tmp, desc, DDS_FREE_CONTENTS_BIT);
+    ddsi_sertopic_free_sample (tp->m_stopic, tmp, DDS_FREE_ALL);
-    os_free (tmp);
   }
   return ret;
 }
@@ -1632,7 +1630,6 @@ static int dds_rhc_read_w_qminv
 {
   bool trigger_waitsets = false;
   uint32_t n = 0;
-  const struct dds_topic_descriptor * desc = rhc->topic->status_cb_entity->m_descriptor;
 
   if (lock)
   {
@@ -1691,7 +1688,7 @@ static int dds_rhc_read_w_qminv
                 else
                 {
                   /* The filter didn't match, so free the deserialised copy. */
-                  dds_sample_free(values[n], desc, DDS_FREE_CONTENTS);
+                  ddsi_sertopic_free_sample (rhc->topic, values[n], DDS_FREE_CONTENTS);
                 }
               }
               sample = sample->next;
@@ -1760,7 +1757,6 @@ static int dds_rhc_take_w_qminv
   bool trigger_waitsets = false;
   uint64_t iid;
   uint32_t n = 0;
-  const struct dds_topic_descriptor * desc = rhc->topic->status_cb_entity->m_descriptor;
 
   if (lock)
   {
@@ -1839,7 +1835,7 @@ static int dds_rhc_take_w_qminv
                 else
                 {
                   /* The filter didn't match, so free the deserialised copy. */
-                  dds_sample_free(values[n], desc, DDS_FREE_CONTENTS);
+                  ddsi_sertopic_free_sample (rhc->topic, values[n], DDS_FREE_CONTENTS);
                 }
               }
               sample = sample1;
@@ -2256,7 +2252,7 @@ static bool update_conditions_locked
 
   if (tmp)
   {
-    dds_sample_free (tmp, desc, DDS_FREE_CONTENTS_BIT);
+    ddsi_sertopic_free_sample (rhc->topic, tmp, DDS_FREE_CONTENTS);
     os_free (tmp);
   }
   return trigger;

src/core/ddsc/src/dds_stream.c

@@ -380,7 +380,7 @@ void dds_stream_read_buffer (dds_stream_t * is, uint8_t * buffer, uint32_t len)
 
 void dds_stream_read_sample (dds_stream_t * is, void * data, const struct ddsi_sertopic_default * topic)
 {
-  const struct dds_topic_descriptor * desc = (const struct dds_topic_descriptor *) topic->type;
+  const struct dds_topic_descriptor * desc = topic->type;
   /* Check if can copy directly from stream buffer */
   if (topic->opt_size && DDS_IS_OK (is, desc->m_size) && (is->m_endian == DDS_ENDIAN))
   {
@@ -1171,7 +1171,7 @@ static void dds_stream_read (dds_stream_t * is, char * data, const uint32_t * op
 
 void dds_stream_write_sample (dds_stream_t * os, const void * data, const struct ddsi_sertopic_default * topic)
 {
-  const struct dds_topic_descriptor * desc = (const struct dds_topic_descriptor *) topic->type;
+  const struct dds_topic_descriptor * desc = topic->type;
 
   if (topic->opt_size && DDS_CDR_ALIGNED (os, desc->m_align))
   {

src/core/ddsi/include/ddsi/ddsi_serdata.h

@@ -82,6 +82,7 @@ typedef void (*ddsi_serdata_to_ser_unref_t) (struct ddsi_serdata *d, const ddsi_
    otherwise malloc() is to be used for those.  (This allows read/take to be given a block of memory
    by the caller.) */
 typedef bool (*ddsi_serdata_to_sample_t) (const struct ddsi_serdata *d, void *sample, void **bufptr, void *buflim);
+
 typedef bool (*ddsi_serdata_topicless_to_sample_t) (const struct ddsi_sertopic *topic, const struct ddsi_serdata *d, void *sample, void **bufptr, void *buflim);
 
 /* Test key values of two serdatas for equality (with the same ddsi_serdata_ops, but not necessarily

src/core/ddsi/include/ddsi/ddsi_serdata_default.h

@@ -41,27 +41,23 @@
 #define CDR_LE 0x0001
 #endif
 
-struct CDRHeader
+struct CDRHeader {
-{
   unsigned short identifier;
   unsigned short options;
 };
 
-struct serdatapool /* FIXME: now a serdatapool */
+struct serdatapool {
-{
   struct nn_freelist freelist;
 };
 
-typedef struct dds_key_hash
+typedef struct dds_key_hash {
-{
   char m_hash [16];          /* Key hash value. Also possibly key. Suitably aligned for accessing as uint32_t's */
   unsigned m_set : 1;        /* has it been initialised? */
   unsigned m_iskey : 1;      /* m_hash is key value */
 }
 dds_key_hash_t;
 
-struct ddsi_serdata_default
+struct ddsi_serdata_default {
-{
   struct ddsi_serdata c;
   uint32_t pos;
   uint32_t size;
@@ -82,18 +78,18 @@ struct ddsi_serdata_default
 };
 
 struct dds_key_descriptor;
+struct dds_topic_descriptor;
 
 #ifndef DDS_TOPIC_INTERN_FILTER_FN_DEFINED
 #define DDS_TOPIC_INTERN_FILTER_FN_DEFINED
 typedef bool (*dds_topic_intern_filter_fn) (const void * sample, void *ctx);
 #endif
 
-struct ddsi_sertopic_default
+struct ddsi_sertopic_default {
-{
   struct ddsi_sertopic c;
   uint16_t native_encoding_identifier; /* (PL_)?CDR_(LE|BE) */
 
-  void * type;
+  struct dds_topic_descriptor * type;
   unsigned nkeys;
 
   uint32_t flags;

src/core/ddsi/include/ddsi/ddsi_sertopic.h

@@ -13,6 +13,7 @@
 #define DDSI_SERTOPIC_H
 
 #include "util/ut_avl.h"
+#include "ddsc/dds_public_alloc.h"
 
 struct ddsi_serdata;
 struct ddsi_serdata_ops;
@@ -39,12 +40,23 @@ struct ddsi_sertopic {
 
 typedef void (*ddsi_sertopic_deinit_t) (struct ddsi_sertopic *tp);
 
+/* Release any memory allocated by ddsi_sertopic_to_sample */
+typedef void (*ddsi_sertopic_free_sample_t) (const struct ddsi_sertopic *d, void *sample, dds_free_op_t op);
+
 struct ddsi_sertopic_ops {
   ddsi_sertopic_deinit_t deinit;
+  ddsi_sertopic_free_sample_t free_sample;
 };
 
 struct ddsi_sertopic *ddsi_sertopic_ref (const struct ddsi_sertopic *tp);
 void ddsi_sertopic_unref (struct ddsi_sertopic *tp);
 uint32_t ddsi_sertopic_compute_serdata_basehash (const struct ddsi_serdata_ops *ops);
 
+inline void ddsi_sertopic_deinit (struct ddsi_sertopic *tp) {
+  tp->ops->deinit (tp);
+}
+inline void ddsi_sertopic_free_sample (const struct ddsi_sertopic *tp, void *sample, dds_free_op_t op) {
+  tp->ops->free_sample (tp, sample, op);
+}
+
 #endif

src/core/ddsi/src/ddsi_serdata_default.c

@@ -272,14 +272,14 @@ static struct ddsi_serdata *serdata_default_from_ser (const struct ddsi_sertopic
 struct ddsi_serdata *ddsi_serdata_from_keyhash_cdr (const struct ddsi_sertopic *tpcmn, const nn_keyhash_t *keyhash)
 {
   /* FIXME: not quite sure this is correct, though a check against a specially hacked OpenSplice suggests it is */
-  if (!(tpcmn->status_cb_entity->m_descriptor->m_flagset & DDS_TOPIC_FIXED_KEY))
+  const struct ddsi_sertopic_default *tp = (const struct ddsi_sertopic_default *)tpcmn;
+  if (!(tp->type->m_flagset & DDS_TOPIC_FIXED_KEY))
   {
     /* keyhash is MD5 of a key value, so impossible to turn into a key value */
     return NULL;
   }
   else
   {
-    const struct ddsi_sertopic_default *tp = (const struct ddsi_sertopic_default *)tpcmn;
     struct ddsi_serdata_default *d = serdata_default_new(tp, SDK_KEY);
     d->hdr.identifier = CDR_BE;
     serdata_default_append_blob (&d, 1, sizeof (keyhash->value), keyhash->value);

src/core/ddsi/src/ddsi_sertopic.c

@@ -38,7 +38,7 @@ void ddsi_sertopic_unref (struct ddsi_sertopic *sertopic)
   {
     if (os_atomic_dec32_ov (&sertopic->refc) == 1)
     {
-      sertopic->ops->deinit (sertopic);
+      ddsi_sertopic_deinit (sertopic);
       os_free (sertopic->name_typename);
       os_free (sertopic->name);
       os_free (sertopic->typename);
@@ -59,3 +59,6 @@ uint32_t ddsi_sertopic_compute_serdata_basehash (const struct ddsi_serdata_ops *
   memcpy (&res, digest, sizeof (res));
   return res;
 }
+
+extern inline void ddsi_sertopic_deinit (struct ddsi_sertopic *tp);
+extern inline void ddsi_sertopic_free_sample (const struct ddsi_sertopic *tp, void *sample, dds_free_op_t op);

src/core/ddsi/src/ddsi_sertopic_default.c

@@ -25,11 +25,18 @@
 
 /* FIXME: sertopic /= ddstopic so a lot of stuff needs to be moved here from dds_topic.c and the free function needs to be implemented properly */
 
-static void deinit_sertopic_default (struct ddsi_sertopic *tp)
+static void sertopic_default_deinit (struct ddsi_sertopic *tp)
 {
   (void)tp;
 }
 
+static void sertopic_default_free_sample (const struct ddsi_sertopic *sertopic_common, void *sample, dds_free_op_t op)
+{
+  const struct ddsi_sertopic_default *tp = (const struct ddsi_sertopic_default *)sertopic_common;
+  dds_sample_free (sample, tp->type, op);
+}
+
 const struct ddsi_sertopic_ops ddsi_sertopic_ops_default = {
-  .deinit = deinit_sertopic_default
+  .deinit = sertopic_default_deinit,
+  .free_sample = sertopic_default_free_sample
 };