niklas/cyclonedds
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fix warnings related to fixed type integers

Browse source 
Signed-off-by: Jeroen Koekkoek <jeroen@koekkoek.nl>
This commit is contained in:
Jeroen Koekkoek 2019-04-29 15:57:14 +02:00 • committed by eboasson
parent ca35c7afb2
commit c9d827e420
22 changed files with 308 additions and 307 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/core/ddsc/src/dds_init.c
View file

@ -96,7 +96,7 @@ dds_init(dds_domainid_t domain)
{
if (domain < 0 || domain > 230)
{
DDS_ERROR("requested domain id %d is out of range\n", domain);
DDS_ERROR("requested domain id %"PRId32" is out of range\n", domain);
ret = DDS_ERRNO(DDS_RETCODE_ERROR);
goto fail_config_domainid;
}
@ -106,7 +106,7 @@ dds_init(dds_domainid_t domain)
}
else if (domain != config.domainId.value)
{
DDS_ERROR("requested domain id %d is inconsistent with configured value %d\n", domain, config.domainId.value);
DDS_ERROR("requested domain id %"PRId32" is inconsistent with configured value %"PRId32"\n", domain, config.domainId.value);
ret = DDS_ERRNO(DDS_RETCODE_ERROR);
goto fail_config_domainid;
}
@ -298,7 +298,7 @@ dds__check_domain(
if (domain != dds_global.m_default_domain)
{
DDS_ERROR("Inconsistent domain configuration detected: domain on "
"configuration: %d, domain %d\n", dds_global.m_default_domain, domain);
"configuration: %"PRId32", domain %"PRId32"\n", dds_global.m_default_domain, domain);
ret = DDS_ERRNO(DDS_RETCODE_ERROR);
}
}

2
src/core/ddsc/src/dds_qos.c
View file

@ -537,7 +537,7 @@ void dds_qset_partition
return ;
}
if(n && !ps) {
DDS_ERROR("Argument ps is NULL, but n (%u) > 0", n);
DDS_ERROR("Argument ps is NULL, but n (%"PRIu32") > 0", n);
return ;
}

26
src/core/ddsc/src/dds_rhc.c
View file

@ -1757,7 +1757,7 @@ static int dds_rhc_read_w_qminv (struct rhc *rhc, bool lock, void **values, dds_
ddsrt_mutex_lock (&rhc->lock);
}
TRACE ("read_w_qminv(%p,%p,%p,%u,%x,%p) - inst %u nonempty %u disp %u nowr %u new %u samples %u+%u read %u+%u\n",
TRACE ("read_w_qminv(%p,%p,%p,%"PRIu32",%x,%p) - inst %"PRIu32" nonempty %"PRIu32" disp %"PRIu32" nowr %"PRIu32" new %"PRIu32" samples %"PRIu32"+%"PRIu32" read %"PRIu32"+%"PRIu32"\n",
(void *) rhc, (void *) values, (void *) info_seq, max_samples, qminv, (void *) cond,
rhc->n_instances, rhc->n_nonempty_instances, rhc->n_not_alive_disposed,
rhc->n_not_alive_no_writers, rhc->n_new, rhc->n_vsamples, rhc->n_invsamples,
@ -1858,7 +1858,7 @@ static int dds_rhc_read_w_qminv (struct rhc *rhc, bool lock, void **values, dds_
}
while (inst != end && n < max_samples);
}
TRACE ("read: returning %u\n", n);
TRACE ("read: returning %"PRIu32"\n", n);
assert (rhc_check_counts_locked (rhc, true, false));
ddsrt_mutex_unlock (&rhc->lock);
@ -1880,7 +1880,7 @@ static int dds_rhc_take_w_qminv (struct rhc *rhc, bool lock, void **values, dds_
ddsrt_mutex_lock (&rhc->lock);
}
TRACE ("take_w_qminv(%p,%p,%p,%u,%x) - inst %u nonempty %u disp %u nowr %u new %u samples %u+%u read %u+%u\n",
TRACE ("take_w_qminv(%p,%p,%p,%"PRIu32",%x) - inst %"PRIu32" nonempty %"PRIu32" disp %"PRIu32" nowr %"PRIu32" new %"PRIu32" samples %"PRIu32"+%"PRIu32" read %"PRIu32"+%"PRIu32"\n",
(void*) rhc, (void*) values, (void*) info_seq, max_samples, qminv,
rhc->n_instances, rhc->n_nonempty_instances, rhc->n_not_alive_disposed,
rhc->n_not_alive_no_writers, rhc->n_new, rhc->n_vsamples,
@ -2020,7 +2020,7 @@ static int dds_rhc_take_w_qminv (struct rhc *rhc, bool lock, void **values, dds_
inst = inst1;
}
}
TRACE ("take: returning %u\n", n);
TRACE ("take: returning %"PRIu32"\n", n);
assert (rhc_check_counts_locked (rhc, true, false));
ddsrt_mutex_unlock (&rhc->lock);
@ -2043,7 +2043,7 @@ static int dds_rhc_takecdr_w_qminv (struct rhc *rhc, bool lock, struct ddsi_serd
ddsrt_mutex_lock (&rhc->lock);
}
TRACE ("take_w_qminv(%p,%p,%p,%u,%x) - inst %u nonempty %u disp %u nowr %u new %u samples %u+%u read %u+%u\n",
TRACE ("take_w_qminv(%p,%p,%p,%"PRIu32",%x) - inst %"PRIu32" nonempty %"PRIu32" disp %"PRIu32" nowr %"PRIu32" new %"PRIu32" samples %"PRIu32"+%"PRIu32" read %"PRIu32"+%"PRIu32"\n",
(void*) rhc, (void*) values, (void*) info_seq, max_samples, qminv,
rhc->n_instances, rhc->n_nonempty_instances, rhc->n_not_alive_disposed,
rhc->n_not_alive_no_writers, rhc->n_new, rhc->n_vsamples,
@ -2172,7 +2172,7 @@ static int dds_rhc_takecdr_w_qminv (struct rhc *rhc, bool lock, struct ddsi_serd
inst = inst1;
}
}
TRACE ("take: returning %u\n", n);
TRACE ("take: returning %"PRIu32"\n", n);
assert (rhc_check_counts_locked (rhc, true, false));
ddsrt_mutex_unlock (&rhc->lock);
@ -2205,7 +2205,7 @@ static uint32_t rhc_get_cond_trigger (struct rhc_instance * const inst, const dd
m = m && !inst_is_empty (inst);
break;
default:
DDS_FATAL("update_readconditions: sample_states invalid: %x\n", c->m_sample_states);
DDS_FATAL("update_readconditions: sample_states invalid: %"PRIx32"\n", c->m_sample_states);
}
return m ? 1 : 0;
}
@ -2221,7 +2221,7 @@ static bool cond_is_sample_state_dependent (const struct dds_readcond *cond)
case 0:
return false;
default:
DDS_FATAL("update_readconditions: sample_states invalid: %x\n", cond->m_sample_states);
DDS_FATAL("update_readconditions: sample_states invalid: %"PRIx32"\n", cond->m_sample_states);
return false;
}
}
@ -2322,7 +2322,7 @@ bool dds_rhc_add_readcondition (dds_readcond *cond)
if (cond->m_entity.m_trigger)
dds_entity_status_signal (&cond->m_entity);
TRACE ("add_readcondition(%p, %x, %x, %x) => %p qminv %x ; rhc %u conds\n",
TRACE ("add_readcondition(%p, %"PRIx32", %"PRIx32", %"PRIx32") => %p qminv %"PRIx32" ; rhc %"PRIu32" conds\n",
(void *) rhc, cond->m_sample_states, cond->m_view_states,
cond->m_instance_states, (void *) cond, cond->m_qminv, rhc->nconds);
@ -2362,10 +2362,10 @@ static bool update_conditions_locked (struct rhc *rhc, bool called_from_insert,
dds_readcond *iter;
bool m_pre, m_post;
TRACE ("update_conditions_locked(%p %p) - inst %u nonempty %u disp %u nowr %u new %u samples %u read %u\n",
TRACE ("update_conditions_locked(%p %p) - inst %"PRIu32" nonempty %"PRIu32" disp %"PRIu32" nowr %"PRIu32" new %"PRIu32" samples %"PRIu32" read %"PRIu32"\n",
(void *) rhc, (void *) inst, rhc->n_instances, rhc->n_nonempty_instances, rhc->n_not_alive_disposed,
rhc->n_not_alive_no_writers, rhc->n_new, rhc->n_vsamples, rhc->n_vread);
TRACE (" read -[%d,%d]+[%d,%d] qcmask -[%x,%x]+[%x,%x]\n",
TRACE (" read -[%d,%d]+[%d,%d] qcmask -[%"PRIx32",%"PRIx32"]+[%"PRIx32",%"PRIx32"]\n",
trig_qc->dec_invsample_read, trig_qc->dec_sample_read, trig_qc->inc_invsample_read, trig_qc->inc_sample_read,
trig_qc->dec_conds_invsample, trig_qc->dec_conds_sample, trig_qc->inc_conds_invsample, trig_qc->inc_conds_sample);
@ -2404,7 +2404,7 @@ static bool update_conditions_locked (struct rhc *rhc, bool called_from_insert,
m_post = m_post && (post->c.has_read + post->c.has_not_read);
break;
default:
DDS_FATAL ("update_readconditions: sample_states invalid: %x\n", iter->m_sample_states);
DDS_FATAL ("update_readconditions: sample_states invalid: %"PRIx32"\n", iter->m_sample_states);
}
TRACE (" cond %p %08"PRIx32": ", (void *) iter, iter->m_query.m_qcmask);
@ -2464,7 +2464,7 @@ static bool update_conditions_locked (struct rhc *rhc, bool called_from_insert,
mdelta += (trig_qc->inc_conds_sample & qcmask) != 0;
break;
default:
DDS_FATAL ("update_readconditions: sample_states invalid: %x\n", iter->m_sample_states);
DDS_FATAL ("update_readconditions: sample_states invalid: %"PRIx32"\n", iter->m_sample_states);
}
if (m_pre == m_post)

4
src/core/ddsc/src/dds_write.c
View file

@ -106,7 +106,7 @@ static dds_return_t deliver_locally (struct writer *wr, struct ddsi_serdata *pay
unsigned i;
make_proxy_writer_info (&pwr_info, &wr->e, wr->xqos);
for (i = 0; rdary[i]; i++) {
DDS_TRACE ("reader %x:%x:%x:%x\n", PGUID (rdary[i]->e.guid));
DDS_TRACE ("reader "PGUIDFMT"\n", PGUID (rdary[i]->e.guid));
if ((ret = try_store (rdary[i]->rhc, &pwr_info, payload, tk, &max_block_ms)) != DDS_RETCODE_OK)
break;
}
@ -135,7 +135,7 @@ static dds_return_t deliver_locally (struct writer *wr, struct ddsi_serdata *pay
struct reader *rd;
if ((rd = ephash_lookup_reader_guid (&m->rd_guid)) != NULL)
{
DDS_TRACE("reader-via-guid %x:%x:%x:%x\n", PGUID (rd->e.guid));
DDS_TRACE("reader-via-guid "PGUIDFMT"\n", PGUID (rd->e.guid));
/* Copied the return value ignore from DDSI deliver_user_data() function. */
if ((ret = try_store (rd->rhc, &pwr_info, payload, tk, &max_block_ms)) != DDS_RETCODE_OK)
break;

1
src/core/ddsi/include/dds/ddsi/q_rtps.h
View file

@ -37,6 +37,7 @@ typedef int64_t seqno_t;
#define PGUIDPREFIX(gp) (gp).u[0], (gp).u[1], (gp).u[2]
#define PGUID(g) PGUIDPREFIX ((g).prefix), (g).entityid.u
#define PGUIDFMT "%"PRIx32":%"PRIx32":%"PRIx32":%"PRIx32
/* predefined entity ids; here viewed as an unsigned int, on the
network as four bytes corresponding to the integer in network byte

18
src/core/ddsi/src/ddsi_tcp.c
View file

@ -154,7 +154,7 @@ static unsigned short get_socket_port (ddsrt_socket_t socket)
ret = ddsrt_getsockname(socket, (struct sockaddr *)&addr, &addrlen);
if (ret != DDS_RETCODE_OK) {
DDS_ERROR("ddsi_tcp_get_socket_port: ddsrt_getsockname retcode %d\n", ret);
DDS_ERROR("ddsi_tcp_get_socket_port: ddsrt_getsockname retcode %"PRId32"\n", ret);
return 0;
}
return ddsrt_sockaddr_get_port((struct sockaddr *)&addr);
@ -435,7 +435,7 @@ static ssize_t ddsi_tcp_conn_read (ddsi_tran_conn_t conn, unsigned char * buf, s
}
else
{
DDS_LOG(DDS_LC_TCP, "%s read: sock %"PRIdSOCK" error %d\n", ddsi_name, tcp->m_sock, rc);
DDS_LOG(DDS_LC_TCP, "%s read: sock %"PRIdSOCK" error %"PRId32"\n", ddsi_name, tcp->m_sock, rc);
break;
}
}
@ -500,7 +500,7 @@ static ssize_t ddsi_tcp_block_write
}
else
{
DDS_LOG(DDS_LC_TCP, "%s write: sock %"PRIdSOCK" error %d\n", ddsi_name, conn->m_sock, rc);
DDS_LOG(DDS_LC_TCP, "%s write: sock %"PRIdSOCK" error %"PRId32"\n", ddsi_name, conn->m_sock, rc);
break;
}
}
@ -638,7 +638,7 @@ static ssize_t ddsi_tcp_conn_write (ddsi_tran_conn_t base, const nn_locator_t *d
break;
default:
if (! conn->m_base.m_closed && (conn->m_sock != DDSRT_INVALID_SOCKET))
DDS_WARNING("%s write failed on socket %"PRIdSOCK" with errno %d\n", ddsi_name, conn->m_sock, rc);
DDS_WARNING("%s write failed on socket %"PRIdSOCK" with errno %"PRId32"\n", ddsi_name, conn->m_sock, rc);
break;
}
}
@ -775,11 +775,11 @@ static ddsi_tran_conn_t ddsi_tcp_accept (ddsi_tran_listener_t listener)
{
(void)ddsrt_getsockname (tl->m_sock, (struct sockaddr *) &addr, &addrlen);
sockaddr_to_string_with_port(buff, sizeof(buff), (struct sockaddr *)&addr);
DDS_LOG((rc == DDS_RETCODE_OK) ? DDS_LC_ERROR : DDS_LC_FATAL, "%s accept failed on socket %"PRIdSOCK" at %s retcode %d\n", ddsi_name, tl->m_sock, buff, rc);
DDS_LOG((rc == DDS_RETCODE_OK) ? DDS_LC_ERROR : DDS_LC_FATAL, "%s accept failed on socket %"PRIdSOCK" at %s retcode %"PRId32"\n", ddsi_name, tl->m_sock, buff, rc);
}
else if (getpeername (sock, (struct sockaddr *) &addr, &addrlen) == -1)
{
DDS_WARNING("%s accepted new socket %"PRIdSOCK" on socket %"PRIdSOCK" but no peer address, errno %d\n", ddsi_name, sock, tl->m_sock, rc);
DDS_WARNING("%s accepted new socket %"PRIdSOCK" on socket %"PRIdSOCK" but no peer address, errno %"PRId32"\n", ddsi_name, sock, tl->m_sock, rc);
ddsrt_close (sock);
}
else
@ -886,7 +886,7 @@ static ddsi_tran_listener_t ddsi_tcp_create_listener (int port, ddsi_tran_qos_t
ret = ddsrt_getsockname(sock, (struct sockaddr *)&addr, &addrlen);
if (ret != DDS_RETCODE_OK) {
DDS_ERROR("ddsi_tcp_create_listener: ddsrt_getsockname returned %d\n", ret);
DDS_ERROR("ddsi_tcp_create_listener: ddsrt_getsockname returned %"PRId32"\n", ret);
ddsi_tcp_sock_free(sock, NULL);
ddsrt_free(tl);
return NULL;
@ -958,7 +958,7 @@ static void ddsi_tcp_unblock_listener (ddsi_tran_listener_t listener)
ret = ddsrt_getsockname(tl->m_sock, (struct sockaddr *)&addr, &addrlen);
if (ret != DDS_RETCODE_OK) {
DDS_WARNING("%s failed to get listener address error %d\n", ddsi_name, ret);
DDS_WARNING("%s failed to get listener address error %"PRId32"\n", ddsi_name, ret);
} else {
switch (addr.ss_family) {
case AF_INET:
@ -988,7 +988,7 @@ static void ddsi_tcp_unblock_listener (ddsi_tran_listener_t listener)
{
char buff[DDSI_LOCSTRLEN];
sockaddr_to_string_with_port(buff, sizeof(buff), (struct sockaddr *)&addr);
DDS_WARNING("%s failed to connect to own listener (%s) error %d\n", ddsi_name, buff, ret);
DDS_WARNING("%s failed to connect to own listener (%s) error %"PRId32"\n", ddsi_name, buff, ret);
}
}
ddsi_tcp_sock_free (sock, NULL);

2
src/core/ddsi/src/ddsi_threadmon.c
View file

@ -88,7 +88,7 @@ static uint32_t threadmon_thread (struct ddsi_threadmon *sl)
vtime_t vt = thread_states.ts[i].vtime;
bool alive = vtime_asleep_p (vt) || vtime_asleep_p (sl->av_ary[i].vt) || vtime_gt (vt, sl->av_ary[i].vt);
n_alive += (unsigned) alive;
DDS_TRACE(" %u(%s):%c:%x->%x", i, thread_states.ts[i].name, alive ? 'a' : 'd', sl->av_ary[i].vt, vt);
DDS_TRACE(" %u(%s):%c:%"PRIx32"->%"PRIx32, i, thread_states.ts[i].name, alive ? 'a' : 'd', sl->av_ary[i].vt, vt);
sl->av_ary[i].vt = vt;
if (sl->av_ary[i].alive != alive)
{

14
src/core/ddsi/src/ddsi_udp.c
View file

@ -103,7 +103,7 @@ static ssize_t ddsi_udp_conn_read (ddsi_tran_conn_t conn, unsigned char * buf, s
else if (rc != DDS_RETCODE_BAD_PARAMETER &&
rc != DDS_RETCODE_NO_CONNECTION)
{
DDS_ERROR("UDP recvmsg sock %d: ret %d retcode %d\n", (int) ((ddsi_udp_conn_t) conn)->m_sock, (int) ret, rc);
DDS_ERROR("UDP recvmsg sock %d: ret %d retcode %"PRId32"\n", (int) ((ddsi_udp_conn_t) conn)->m_sock, (int) ret, rc);
ret = -1;
}
return ret;
@ -168,7 +168,7 @@ static ssize_t ddsi_udp_conn_write (ddsi_tran_conn_t conn, const nn_locator_t *d
rc != DDS_RETCODE_NOT_ALLOWED &&
rc != DDS_RETCODE_NO_CONNECTION)
{
DDS_ERROR("ddsi_udp_conn_write failed with retcode %d\n", rc);
DDS_ERROR("ddsi_udp_conn_write failed with retcode %"PRId32"\n", rc);
}
return (rc == DDS_RETCODE_OK ? ret : -1);
}
@ -220,7 +220,7 @@ static unsigned short get_socket_port (ddsrt_socket_t socket)
ret = ddsrt_getsockname (socket, (struct sockaddr *)&addr, &addrlen);
if (ret != DDS_RETCODE_OK)
{
DDS_ERROR("ddsi_udp_get_socket_port: getsockname returned %d\n", ret);
DDS_ERROR("ddsi_udp_get_socket_port: getsockname returned %"PRId32"\n", ret);
return 0;
}
@ -273,7 +273,7 @@ static ddsi_tran_conn_t ddsi_udp_create_conn
DDS_TRACE
(
"ddsi_udp_create_conn %s socket %"PRIdSOCK" port %u\n",
"ddsi_udp_create_conn %s socket %"PRIdSOCK" port %"PRIu32"\n",
mcast ? "multicast" : "unicast",
uc->m_sock,
uc->m_base.m_base.m_port
@ -284,7 +284,7 @@ static ddsi_tran_conn_t ddsi_udp_create_conn
dds_retcode_t rc;
rc = ddsrt_setsockopt(sock, IPPROTO_IP, IP_TOS, (char *)&uc->m_diffserv, sizeof(uc->m_diffserv));
if (rc != DDS_RETCODE_OK)
DDS_ERROR("ddsi_udp_create_conn: set diffserv retcode %d\n", rc);
DDS_ERROR("ddsi_udp_create_conn: set diffserv retcode %"PRId32"\n", rc);
}
#endif
}
@ -294,7 +294,7 @@ static ddsi_tran_conn_t ddsi_udp_create_conn
{
DDS_ERROR
(
"UDP make_socket failed for %s port %u\n",
"UDP make_socket failed for %s port %"PRIu32"\n",
mcast ? "multicast" : "unicast",
port
);
@ -395,7 +395,7 @@ static void ddsi_udp_release_conn (ddsi_tran_conn_t conn)
ddsi_udp_conn_t uc = (ddsi_udp_conn_t) conn;
DDS_TRACE
(
"ddsi_udp_release_conn %s socket %"PRIdSOCK" port %u\n",
"ddsi_udp_release_conn %s socket %"PRIdSOCK" port %"PRIu32"\n",
conn->m_base.m_multicast ? "multicast" : "unicast",
uc->m_sock,
uc->m_base.m_base.m_port

72
src/core/ddsi/src/q_ddsi_discovery.c
View file

@ -198,11 +198,11 @@ int spdp_write (struct participant *pp)
return 0;
}
DDS_TRACE("spdp_write(%x:%x:%x:%x)\n", PGUID (pp->e.guid));
DDS_TRACE("spdp_write("PGUIDFMT")\n", PGUID (pp->e.guid));
if ((wr = get_builtin_writer (pp, NN_ENTITYID_SPDP_BUILTIN_PARTICIPANT_WRITER)) == NULL)
{
DDS_TRACE("spdp_write(%x:%x:%x:%x) - builtin participant writer not found\n", PGUID (pp->e.guid));
DDS_TRACE("spdp_write("PGUIDFMT") - builtin participant writer not found\n", PGUID (pp->e.guid));
return 0;
}
@ -307,7 +307,7 @@ int spdp_write (struct participant *pp)
size = strlen(node) + strlen(DDS_VERSION) + strlen(DDS_HOST_NAME) + strlen(DDS_TARGET_NAME) + 4; /* + ///'\0' */
ps.prismtech_participant_version_info.internals = ddsrt_malloc(size);
(void) snprintf(ps.prismtech_participant_version_info.internals, size, "%s/%s/%s/%s", node, DDS_VERSION, DDS_HOST_NAME, DDS_TARGET_NAME);
DDS_TRACE("spdp_write(%x:%x:%x:%x) - internals: %s\n", PGUID (pp->e.guid), ps.prismtech_participant_version_info.internals);
DDS_TRACE("spdp_write("PGUIDFMT") - internals: %s\n", PGUID (pp->e.guid), ps.prismtech_participant_version_info.internals);
}
/* Participant QoS's insofar as they are set, different from the default, and mapped to the SPDP data, rather than to the PrismTech-specific CMParticipant endpoint. Currently, that means just USER_DATA. */
@ -335,7 +335,7 @@ int spdp_dispose_unregister (struct participant *pp)
if ((wr = get_builtin_writer (pp, NN_ENTITYID_SPDP_BUILTIN_PARTICIPANT_WRITER)) == NULL)
{
DDS_TRACE("spdp_dispose_unregister(%x:%x:%x:%x) - builtin participant writer not found\n", PGUID (pp->e.guid));
DDS_TRACE("spdp_dispose_unregister("PGUIDFMT") - builtin participant writer not found\n", PGUID (pp->e.guid));
return 0;
}
@ -416,7 +416,7 @@ static int handle_SPDP_dead (const struct receiver_state *rst, nn_wctime_t times
if (datap->present & PP_PARTICIPANT_GUID)
{
guid = datap->participant_guid;
DDS_LOG(DDS_LC_DISCOVERY, " %x:%x:%x:%x", PGUID (guid));
DDS_LOG(DDS_LC_DISCOVERY, " %"PRIx32":%"PRIx32":%"PRIx32":%"PRIx32, PGUID (guid));
assert (guid.entityid.u == NN_ENTITYID_PARTICIPANT);
if (delete_proxy_participant_by_guid (&guid, timestamp, 0) < 0)
{
@ -481,7 +481,7 @@ static void make_participants_dependent_on_ddsi2 (const nn_guid_t *ddsi2guid, nn
{
if (vendor_is_eclipse_or_opensplice (pp->vendor) && pp->e.guid.prefix.u[0] == ddsi2guid->prefix.u[0] && !pp->is_ddsi2_pp)
{
DDS_TRACE("proxy participant %x:%x:%x:%x depends on ddsi2 %x:%x:%x:%x", PGUID (pp->e.guid), PGUID (*ddsi2guid));
DDS_TRACE("proxy participant "PGUIDFMT" depends on ddsi2 "PGUIDFMT, PGUID (pp->e.guid), PGUID (*ddsi2guid));
ddsrt_mutex_lock (&pp->e.lock);
pp->privileged_pp_guid = *ddsi2guid;
ddsrt_mutex_unlock (&pp->e.lock);
@ -501,7 +501,7 @@ static void make_participants_dependent_on_ddsi2 (const nn_guid_t *ddsi2guid, nn
if (pp != NULL)
{
DDS_TRACE("make_participants_dependent_on_ddsi2: ddsi2 %x:%x:%x:%x is no more, delete %x:%x:%x:%x\n", PGUID (*ddsi2guid), PGUID (pp->e.guid));
DDS_TRACE("make_participants_dependent_on_ddsi2: ddsi2 "PGUIDFMT" is no more, delete "PGUIDFMT"\n", PGUID (*ddsi2guid), PGUID (pp->e.guid));
delete_proxy_participant_by_guid (&pp->e.guid, timestamp, 1);
}
}
@ -569,7 +569,7 @@ static int handle_SPDP_alive (const struct receiver_state *rst, nn_wctime_t time
if (is_deleted_participant_guid (&datap->participant_guid, DPG_REMOTE))
{
DDS_LOG(DDS_LC_TRACE, "SPDP ST0 %x:%x:%x:%x (recently deleted)", PGUID (datap->participant_guid));
DDS_LOG(DDS_LC_TRACE, "SPDP ST0 "PGUIDFMT" (recently deleted)", PGUID (datap->participant_guid));
return 1;
}
@ -579,7 +579,7 @@ static int handle_SPDP_alive (const struct receiver_state *rst, nn_wctime_t time
islocal = 1;
if (islocal)
{
DDS_LOG(DDS_LC_TRACE, "SPDP ST0 %x:%x:%x:%x (local %d)", islocal, PGUID (datap->participant_guid));
DDS_LOG(DDS_LC_TRACE, "SPDP ST0 "PGUIDFMT" (local %d)", PGUID (datap->participant_guid), islocal);
return 0;
}
}
@ -590,7 +590,7 @@ static int handle_SPDP_alive (const struct receiver_state *rst, nn_wctime_t time
are even skipping the automatic lease renewal. Therefore do it
regardless of
config.arrival_of_data_asserts_pp_and_ep_liveliness. */
DDS_LOG(DDS_LC_TRACE, "SPDP ST0 %x:%x:%x:%x (known)", PGUID (datap->participant_guid));
DDS_LOG(DDS_LC_TRACE, "SPDP ST0 "PGUIDFMT" (known)", PGUID (datap->participant_guid));
lease_renew (ddsrt_atomic_ldvoidp (&proxypp->lease), now_et ());
ddsrt_mutex_lock (&proxypp->e.lock);
if (proxypp->implicitly_created)
@ -603,7 +603,7 @@ static int handle_SPDP_alive (const struct receiver_state *rst, nn_wctime_t time
return 0;
}
DDS_LOG(DDS_LC_DISCOVERY, "SPDP ST0 %x:%x:%x:%x bes %x ptbes %x NEW", PGUID (datap->participant_guid), builtin_endpoint_set, prismtech_builtin_endpoint_set);
DDS_LOG(DDS_LC_DISCOVERY, "SPDP ST0 "PGUIDFMT" bes %x ptbes %x NEW", PGUID (datap->participant_guid), builtin_endpoint_set, prismtech_builtin_endpoint_set);
if (datap->present & PP_PARTICIPANT_LEASE_DURATION)
{
@ -643,7 +643,7 @@ static int handle_SPDP_alive (const struct receiver_state *rst, nn_wctime_t time
if ((builtin_endpoint_set & bes_sedp_announcer_mask) != bes_sedp_announcer_mask &&
memcmp (&privileged_pp_guid, &datap->participant_guid, sizeof (nn_guid_t)) != 0)
{
DDS_LOG(DDS_LC_DISCOVERY, " (depends on %x:%x:%x:%x)", PGUID (privileged_pp_guid));
DDS_LOG(DDS_LC_DISCOVERY, " (depends on "PGUIDFMT")", PGUID (privileged_pp_guid));
/* never expire lease for this proxy: it won't actually expire
until the "privileged" one expires anyway */
lease_duration = nn_to_ddsi_duration (T_NEVER);
@ -659,7 +659,7 @@ static int handle_SPDP_alive (const struct receiver_state *rst, nn_wctime_t time
{
privileged_pp_guid.prefix = ddsi2->e.guid.prefix;
lease_duration = nn_to_ddsi_duration (T_NEVER);
DDS_LOG(DDS_LC_DISCOVERY, " (depends on %x:%x:%x:%x)", PGUID (privileged_pp_guid));
DDS_LOG(DDS_LC_DISCOVERY, " (depends on "PGUIDFMT")", PGUID (privileged_pp_guid));
}
}
else
@ -772,7 +772,7 @@ static int handle_SPDP_alive (const struct receiver_state *rst, nn_wctime_t time
of DDSI2. */
if (ephash_lookup_proxy_participant_guid (&privileged_pp_guid) == NULL)
{
DDS_LOG(DDS_LC_DISCOVERY, "make_participants_dependent_on_ddsi2: ddsi2 %x:%x:%x:%x is no more, delete %x:%x:%x:%x\n", PGUID (privileged_pp_guid), PGUID (datap->participant_guid));
DDS_LOG(DDS_LC_DISCOVERY, "make_participants_dependent_on_ddsi2: ddsi2 "PGUIDFMT" is no more, delete "PGUIDFMT"\n", PGUID (privileged_pp_guid), PGUID (datap->participant_guid));
delete_proxy_participant_by_guid (&datap->participant_guid, timestamp, 1);
}
}
@ -943,7 +943,7 @@ static int sedp_write_endpoint
nn_xmsg_addpar_sentinel (mpayload);
nn_plist_fini (&ps);
DDS_LOG(DDS_LC_DISCOVERY, "sedp: write for %x:%x:%x:%x via %x:%x:%x:%x\n", PGUID (*epguid), PGUID (wr->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, "sedp: write for "PGUIDFMT" via "PGUIDFMT"\n", PGUID (*epguid), PGUID (wr->e.guid));
ret = write_mpayload (wr, alive, PID_ENDPOINT_GUID, mpayload);
nn_xmsg_free (mpayload);
return ret;
@ -953,7 +953,7 @@ static struct writer *get_sedp_writer (const struct participant *pp, unsigned en
{
struct writer *sedp_wr = get_builtin_writer (pp, entityid);
if (sedp_wr == NULL)
DDS_FATAL("sedp_write_writer: no SEDP builtin writer %x for %x:%x:%x:%x\n", entityid, PGUID (pp->e.guid));
DDS_FATAL("sedp_write_writer: no SEDP builtin writer %x for "PGUIDFMT"\n", entityid, PGUID (pp->e.guid));
return sedp_wr;
}
@ -1036,14 +1036,14 @@ static struct proxy_participant *implicitly_create_proxypp (const nn_guid_t *ppg
{
nn_vendorid_t actual_vendorid;
/* Some endpoint that we discovered through the DS, but then it must have at least some locators */
DDS_TRACE(" from-DS %x:%x:%x:%x", PGUID (privguid));
DDS_TRACE(" from-DS %"PRIx32":%"PRIx32":%"PRIx32":%"PRIx32, PGUID (privguid));
/* avoid "no address" case, so we never create the proxy participant for nothing (FIXME: rework some of this) */
if (!(datap->present & (PP_UNICAST_LOCATOR | PP_MULTICAST_LOCATOR)))
{
DDS_TRACE(" data locator absent\n");
goto err;
}
DDS_TRACE(" new-proxypp %x:%x:%x:%x\n", PGUID (*ppguid));
DDS_TRACE(" new-proxypp "PGUIDFMT"\n", PGUID (*ppguid));
/* We need to handle any source of entities, but we really want to try to keep the GIDs (and
certainly the systemId component) unchanged for OSPL. The new proxy participant will take
the GID from the GUID if it is from a "modern" OSPL that advertises it includes all GIDs in
@ -1076,7 +1076,7 @@ static struct proxy_participant *implicitly_create_proxypp (const nn_guid_t *ppg
} else {
struct addrset *as_default, *as_meta;
nn_plist_t tmp_plist;
DDS_TRACE(" from-ddsi2 %x:%x:%x:%x", PGUID (privguid));
DDS_TRACE(" from-ddsi2 "PGUIDFMT, PGUID (privguid));
nn_plist_init_empty (&pp_plist);
ddsrt_mutex_lock (&privpp->e.lock);
@ -1118,7 +1118,7 @@ static void handle_SEDP_alive (const struct receiver_state *rst, nn_plist_t *dat
if (!(datap->present & PP_ENDPOINT_GUID))
E (" no guid?\n", err);
DDS_LOG(DDS_LC_DISCOVERY, " %x:%x:%x:%x", PGUID (datap->endpoint_guid));
DDS_LOG(DDS_LC_DISCOVERY, " "PGUIDFMT, PGUID (datap->endpoint_guid));
ppguid.prefix = datap->endpoint_guid.prefix;
ppguid.entityid.u = NN_ENTITYID_PARTICIPANT;
@ -1141,7 +1141,7 @@ static void handle_SEDP_alive (const struct receiver_state *rst, nn_plist_t *dat
if ((pp = implicitly_create_proxypp (&ppguid, datap, src_guid_prefix, vendorid, timestamp)) == NULL)
E ("?\n", err);
/* Repeat regular SEDP trace for convenience */
DDS_LOG(DDS_LC_DISCOVERY, "SEDP ST0 %x:%x:%x:%x (cont)", PGUID (datap->endpoint_guid));
DDS_LOG(DDS_LC_DISCOVERY, "SEDP ST0 "PGUIDFMT" (cont)", PGUID (datap->endpoint_guid));
}
xqos = &datap->qos;
@ -1200,7 +1200,7 @@ static void handle_SEDP_alive (const struct receiver_state *rst, nn_plist_t *dat
if (vendor_is_cloud (vendorid) && pp->implicitly_created && memcmp(&pp->privileged_pp_guid.prefix, src_guid_prefix, sizeof(pp->privileged_pp_guid.prefix)) != 0)
{
nn_etime_t never = { T_NEVER };
DDS_LOG(DDS_LC_DISCOVERY, " %x:%x:%x:%x attach-to-DS %x:%x:%x:%x", PGUID(pp->e.guid), PGUIDPREFIX(*src_guid_prefix), pp->privileged_pp_guid.entityid.u);
DDS_LOG(DDS_LC_DISCOVERY, " "PGUIDFMT" attach-to-DS "PGUIDFMT, PGUID(pp->e.guid), PGUIDPREFIX(*src_guid_prefix), pp->privileged_pp_guid.entityid.u);
ddsrt_mutex_lock (&pp->e.lock);
pp->privileged_pp_guid.prefix = *src_guid_prefix;
lease_set_expiry(ddsrt_atomic_ldvoidp(&pp->lease), never);
@ -1253,7 +1253,7 @@ static void handle_SEDP_alive (const struct receiver_state *rst, nn_plist_t *dat
if ((datap->endpoint_guid.entityid.u & NN_ENTITYID_SOURCE_MASK) == NN_ENTITYID_SOURCE_VENDOR && !vendor_is_eclipse_or_prismtech (vendorid))
{
DDS_LOG(DDS_LC_DISCOVERY, "ignoring vendor-specific endpoint %x:%x:%x:%x\n", PGUID (datap->endpoint_guid));
DDS_LOG(DDS_LC_DISCOVERY, "ignoring vendor-specific endpoint "PGUIDFMT"\n", PGUID (datap->endpoint_guid));
}
else
{
@ -1310,7 +1310,7 @@ static void handle_SEDP_dead (nn_plist_t *datap, nn_wctime_t timestamp)
DDS_LOG(DDS_LC_DISCOVERY, " no guid?\n");
return;
}
DDS_LOG(DDS_LC_DISCOVERY, " %x:%x:%x:%x", PGUID (datap->endpoint_guid));
DDS_LOG(DDS_LC_DISCOVERY, " "PGUIDFMT, PGUID (datap->endpoint_guid));
if (is_writer_entityid (datap->endpoint_guid.entityid))
{
res = delete_proxy_writer (&datap->endpoint_guid, timestamp, 0);
@ -1394,7 +1394,7 @@ int sedp_write_topic (struct participant *pp, const struct nn_plist *datap)
nn_plist_addtomsg (mpayload, datap, ~(uint64_t)0, delta);
nn_xmsg_addpar_sentinel (mpayload);
DDS_TRACE("sedp: write topic %s via %x:%x:%x:%x\n", datap->qos.topic_name, PGUID (sedp_wr->e.guid));
DDS_TRACE("sedp: write topic %s via "PGUIDFMT"\n", datap->qos.topic_name, PGUID (sedp_wr->e.guid));
ret = write_mpayload (sedp_wr, 1, PID_TOPIC_NAME, mpayload);
nn_xmsg_free (mpayload);
return ret;
@ -1441,7 +1441,7 @@ int sedp_write_cm_participant (struct participant *pp, int alive)
}
nn_xmsg_addpar_sentinel (mpayload);
DDS_TRACE("sedp: write CMParticipant ST%x for %x:%x:%x:%x via %x:%x:%x:%x\n",
DDS_TRACE("sedp: write CMParticipant ST%x for "PGUIDFMT" via "PGUIDFMT"\n",
alive ? 0 : NN_STATUSINFO_DISPOSE | NN_STATUSINFO_UNREGISTER, PGUID (pp->e.guid), PGUID (sedp_wr->e.guid));
ret = write_mpayload (sedp_wr, alive, PID_PARTICIPANT_GUID, mpayload);
nn_xmsg_free (mpayload);
@ -1514,7 +1514,7 @@ int sedp_write_cm_publisher (const struct nn_plist *datap, int alive)
if ((pp = group_guid_to_participant (&datap->group_guid)) == NULL)
{
DDS_TRACE("sedp: write CMPublisher alive:%d for %x:%x:%x:%x dropped: no participant\n",
DDS_TRACE("sedp: write CMPublisher alive:%d for "PGUIDFMT" dropped: no participant\n",
alive, PGUID (datap->group_guid));
return 0;
}
@ -1550,7 +1550,7 @@ int sedp_write_cm_subscriber (const struct nn_plist *datap, int alive)
if ((pp = group_guid_to_participant (&datap->group_guid)) == NULL)
{
DDS_LOG(DDS_LC_DISCOVERY, "sedp: write CMSubscriber alive:%d for %x:%x:%x:%x dropped: no participant\n",
DDS_LOG(DDS_LC_DISCOVERY, "sedp: write CMSubscriber alive:%d for "PGUIDFMT" dropped: no participant\n",
alive, PGUID (datap->group_guid));
return 0;
}
@ -1583,7 +1583,7 @@ static void handle_SEDP_GROUP_alive (nn_plist_t *datap /* note: potentially modi
if (!(datap->present & PP_GROUP_GUID))
E (" no guid?\n", err);
DDS_LOG(DDS_LC_DISCOVERY, " %x:%x:%x:%x", PGUID (datap->group_guid));
DDS_LOG(DDS_LC_DISCOVERY, " %"PRIx32"%"PRIx32"%"PRIx32"%"PRIx32, PGUID (datap->group_guid));
ppguid.prefix = datap->group_guid.prefix;
ppguid.entityid.u = NN_ENTITYID_PARTICIPANT;
@ -1608,7 +1608,7 @@ static void handle_SEDP_GROUP_dead (nn_plist_t *datap, nn_wctime_t timestamp)
DDS_LOG(DDS_LC_DISCOVERY, " no guid?\n");
return;
}
DDS_LOG(DDS_LC_DISCOVERY, " %x:%x:%x:%x\n", PGUID (datap->group_guid));
DDS_LOG(DDS_LC_DISCOVERY, " "PGUIDFMT"\n", PGUID (datap->group_guid));
delete_proxy_group (&datap->group_guid, timestamp, 0);
}
@ -1757,7 +1757,7 @@ int builtins_dqueue_handler (const struct nn_rsample_info *sampleinfo, const str
if ((plist_ret = nn_plist_init_frommsg (&qos, NULL, PP_STATUSINFO | PP_KEYHASH, 0, &src)) < 0)
{
if (plist_ret != Q_ERR_INCOMPATIBLE)
DDS_WARNING("data(builtin, vendor %u.%u): %x:%x:%x:%x #%"PRId64": invalid inline qos\n",
DDS_WARNING("data(builtin, vendor %u.%u): "PGUIDFMT" #%"PRId64": invalid inline qos\n",
src.vendorid.id[0], src.vendorid.id[1], PGUID (srcguid), sampleinfo->seq);
goto done_upd_deliv;
}
@ -1781,7 +1781,7 @@ int builtins_dqueue_handler (const struct nn_rsample_info *sampleinfo, const str
{
if (datasz == 0 || !(data_smhdr_flags & DATA_FLAG_DATAFLAG))
{
DDS_WARNING("data(builtin, vendor %u.%u): %x:%x:%x:%x #%"PRId64": "
DDS_WARNING("data(builtin, vendor %u.%u): "PGUIDFMT" #%"PRId64": "
"built-in data but no payload\n",
sampleinfo->rst->vendor.id[0], sampleinfo->rst->vendor.id[1],
PGUID (srcguid), sampleinfo->seq);
@ -1795,7 +1795,7 @@ int builtins_dqueue_handler (const struct nn_rsample_info *sampleinfo, const str
hasn't been checked fully yet. */
if (!(data_smhdr_flags & DATA_FLAG_KEYFLAG))
{
DDS_WARNING("data(builtin, vendor %u.%u): %x:%x:%x:%x #%"PRId64": "
DDS_WARNING("data(builtin, vendor %u.%u): "PGUIDFMT" #%"PRId64": "
"dispose/unregister of built-in data but payload not just key\n",
sampleinfo->rst->vendor.id[0], sampleinfo->rst->vendor.id[1],
PGUID (srcguid), sampleinfo->seq);
@ -1837,7 +1837,7 @@ int builtins_dqueue_handler (const struct nn_rsample_info *sampleinfo, const str
pid = PID_ENDPOINT_GUID;
break;
default:
DDS_LOG(DDS_LC_DISCOVERY, "data(builtin, vendor %u.%u): %x:%x:%x:%x #%"PRId64": mapping keyhash to ENDPOINT_GUID",
DDS_LOG(DDS_LC_DISCOVERY, "data(builtin, vendor %u.%u): "PGUIDFMT" #%"PRId64": mapping keyhash to ENDPOINT_GUID",
sampleinfo->rst->vendor.id[0], sampleinfo->rst->vendor.id[1],
PGUID (srcguid), sampleinfo->seq);
pid = PID_ENDPOINT_GUID;
@ -1854,7 +1854,7 @@ int builtins_dqueue_handler (const struct nn_rsample_info *sampleinfo, const str
}
else
{
DDS_WARNING("data(builtin, vendor %u.%u): %x:%x:%x:%x #%"PRId64": "
DDS_WARNING("data(builtin, vendor %u.%u): "PGUIDFMT" #%"PRId64": "
"dispose/unregister with no content\n",
sampleinfo->rst->vendor.id[0], sampleinfo->rst->vendor.id[1],
PGUID (srcguid), sampleinfo->seq);
@ -1882,7 +1882,7 @@ int builtins_dqueue_handler (const struct nn_rsample_info *sampleinfo, const str
handle_SEDP_GROUP (sampleinfo->rst, timestamp, statusinfo, datap, datasz);
break;
default:
DDS_LOG (DDS_LC_DISCOVERY, "data(builtin, vendor %u.%u): %x:%x:%x:%x #%"PRId64": not handled\n",
DDS_LOG (DDS_LC_DISCOVERY, "data(builtin, vendor %u.%u): "PGUIDFMT" #%"PRId64": not handled\n",
sampleinfo->rst->vendor.id[0], sampleinfo->rst->vendor.id[1],
PGUID (srcguid), sampleinfo->seq);
break;

154
src/core/ddsi/src/q_entity.c
View file

@ -338,7 +338,7 @@ int is_deleted_participant_guid (const struct nn_guid *guid, unsigned for_what)
static void remove_deleted_participant_guid (const struct nn_guid *guid, unsigned for_what)
{
struct deleted_participant *n;
DDS_LOG(DDS_LC_DISCOVERY, "remove_deleted_participant_guid(%x:%x:%x:%x for_what=%x)\n", PGUID (*guid), for_what);
DDS_LOG(DDS_LC_DISCOVERY, "remove_deleted_participant_guid("PGUIDFMT" for_what=%x)\n", PGUID (*guid), for_what);
ddsrt_mutex_lock (&deleted_participants_lock);
if ((n = ddsrt_avl_lookup (&deleted_participants_treedef, &deleted_participants, guid)) != NULL)
{
@ -380,7 +380,7 @@ int pp_allocate_entityid(nn_entityid_t *id, unsigned kind, struct participant *p
}
else
{
DDS_ERROR("pp_allocate_entityid(%x:%x:%x:%x): all ids in use\n", PGUID(pp->e.guid));
DDS_ERROR("pp_allocate_entityid("PGUIDFMT"): all ids in use\n", PGUID(pp->e.guid));
ret = Q_ERR_OUT_OF_IDS;
}
ddsrt_mutex_unlock (&pp->e.lock);
@ -431,12 +431,12 @@ int new_participant_guid (const nn_guid_t *ppguid, unsigned flags, const nn_plis
else
{
ddsrt_mutex_unlock (&gv.participant_set_lock);
DDS_ERROR("new_participant(%x:%x:%x:%x, %x) failed: max participants reached\n", PGUID (*ppguid), flags);
DDS_ERROR("new_participant("PGUIDFMT", %x) failed: max participants reached\n", PGUID (*ppguid), flags);
return Q_ERR_OUT_OF_IDS;
}
}
DDS_LOG(DDS_LC_DISCOVERY, "new_participant(%x:%x:%x:%x, %x)\n", PGUID (*ppguid), flags);
DDS_LOG(DDS_LC_DISCOVERY, "new_participant("PGUIDFMT", %x)\n", PGUID (*ppguid), flags);
pp = ddsrt_malloc (sizeof (*pp));
@ -454,7 +454,7 @@ int new_participant_guid (const nn_guid_t *ppguid, unsigned flags, const nn_plis
if (dds_get_log_mask() & DDS_LC_DISCOVERY)
{
DDS_LOG(DDS_LC_DISCOVERY, "PARTICIPANT %x:%x:%x:%x QOS={", PGUID (pp->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, "PARTICIPANT "PGUIDFMT" QOS={", PGUID (pp->e.guid));
nn_log_xqos(DDS_LC_DISCOVERY, &pp->plist->qos);
DDS_LOG(DDS_LC_DISCOVERY, "}\n");
}
@ -692,7 +692,7 @@ static struct participant *ref_participant (struct participant *pp, const struct
stguid = *guid_of_refing_entity;
else
memset (&stguid, 0, sizeof (stguid));
DDS_LOG(DDS_LC_DISCOVERY, "ref_participant(%x:%x:%x:%x @ %p <- %x:%x:%x:%x @ %p) user %d builtin %d\n",
DDS_LOG(DDS_LC_DISCOVERY, "ref_participant("PGUIDFMT" @ %p <- "PGUIDFMT" @ %p) user %"PRId32" builtin %"PRId32"\n",
PGUID (pp->e.guid), (void*)pp, PGUID (stguid), (void*)guid_of_refing_entity, pp->user_refc, pp->builtin_refc);
ddsrt_mutex_unlock (&pp->refc_lock);
return pp;
@ -733,7 +733,7 @@ static void unref_participant (struct participant *pp, const struct nn_guid *gui
stguid = *guid_of_refing_entity;
else
memset (&stguid, 0, sizeof (stguid));
DDS_LOG(DDS_LC_DISCOVERY, "unref_participant(%x:%x:%x:%x @ %p <- %x:%x:%x:%x @ %p) user %d builtin %d\n",
DDS_LOG(DDS_LC_DISCOVERY, "unref_participant("PGUIDFMT" @ %p <- "PGUIDFMT" @ %p) user %"PRId32" builtin %"PRId32"\n",
PGUID (pp->e.guid), (void*)pp, PGUID (stguid), (void*)guid_of_refing_entity, pp->user_refc, pp->builtin_refc);
if (pp->user_refc == 0 && (pp->bes != 0 || pp->prismtech_bes != 0) && !pp->builtins_deleted)
@ -845,7 +845,7 @@ static void unref_participant (struct participant *pp, const struct nn_guid *gui
static void gc_delete_participant (struct gcreq *gcreq)
{
struct participant *pp = gcreq->arg;
DDS_LOG(DDS_LC_DISCOVERY, "gc_delete_participant(%p, %x:%x:%x:%x)\n", (void *) gcreq, PGUID (pp->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, "gc_delete_participant(%p, "PGUIDFMT")\n", (void *) gcreq, PGUID (pp->e.guid));
gcreq_free (gcreq);
unref_participant (pp, NULL);
}
@ -1235,7 +1235,7 @@ static void rebuild_writer_addrset (struct writer *wr)
wr->as = newas;
unref_addrset (oldas);
DDS_LOG(DDS_LC_DISCOVERY, "rebuild_writer_addrset(%x:%x:%x:%x):", PGUID (wr->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, "rebuild_writer_addrset("PGUIDFMT"):", PGUID (wr->e.guid));
nn_log_addrset(DDS_LC_DISCOVERY, "", wr->as);
DDS_LOG(DDS_LC_DISCOVERY, "\n");
}
@ -1461,14 +1461,14 @@ static void update_reader_init_acknack_count (const struct nn_guid *rd_guid, nn_
/* Update the initial acknack sequence number for the reader. See
also reader_add_connection(). */
DDS_LOG(DDS_LC_DISCOVERY, "update_reader_init_acknack_count (%x:%x:%x:%x, %d): ", PGUID (*rd_guid), count);
DDS_LOG(DDS_LC_DISCOVERY, "update_reader_init_acknack_count ("PGUIDFMT", %"PRId32"): ", PGUID (*rd_guid), count);
if ((rd = ephash_lookup_reader_guid (rd_guid)) != NULL)
{
ddsrt_mutex_lock (&rd->e.lock);
DDS_LOG(DDS_LC_DISCOVERY, "%d -> ", rd->init_acknack_count);
DDS_LOG(DDS_LC_DISCOVERY, "%"PRId32" -> ", rd->init_acknack_count);
if (count > rd->init_acknack_count)
rd->init_acknack_count = count;
DDS_LOG(DDS_LC_DISCOVERY, "%d\n", count);
DDS_LOG(DDS_LC_DISCOVERY, "%"PRId32"\n", count);
ddsrt_mutex_unlock (&rd->e.lock);
}
else
@ -1538,7 +1538,7 @@ static void writer_add_connection (struct writer *wr, struct proxy_reader *prd)
ddsrt_mutex_lock (&prd->e.lock);
if (prd->deleting)
{
DDS_LOG(DDS_LC_DISCOVERY, " writer_add_connection(wr %x:%x:%x:%x prd %x:%x:%x:%x) - prd is being deleted\n",
DDS_LOG(DDS_LC_DISCOVERY, " writer_add_connection(wr "PGUIDFMT" prd "PGUIDFMT") - prd is being deleted\n",
PGUID (wr->e.guid), PGUID (prd->e.guid));
pretend_everything_acked = 1;
}
@ -1566,14 +1566,14 @@ static void writer_add_connection (struct writer *wr, struct proxy_reader *prd)
m->seq = wr->seq;
if (ddsrt_avl_lookup_ipath (&wr_readers_treedef, &wr->readers, &prd->e.guid, &path))
{
DDS_LOG(DDS_LC_DISCOVERY, " writer_add_connection(wr %x:%x:%x:%x prd %x:%x:%x:%x) - already connected\n", PGUID (wr->e.guid), PGUID (prd->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, " writer_add_connection(wr "PGUIDFMT" prd "PGUIDFMT") - already connected\n", PGUID (wr->e.guid), PGUID (prd->e.guid));
ddsrt_mutex_unlock (&wr->e.lock);
nn_lat_estim_fini (&m->hb_to_ack_latency);
ddsrt_free (m);
}
else
{
DDS_LOG(DDS_LC_DISCOVERY, " writer_add_connection(wr %x:%x:%x:%x prd %x:%x:%x:%x) - ack seq %"PRId64"\n", PGUID (wr->e.guid), PGUID (prd->e.guid), m->seq);
DDS_LOG(DDS_LC_DISCOVERY, " writer_add_connection(wr "PGUIDFMT" prd "PGUIDFMT") - ack seq %"PRId64"\n", PGUID (wr->e.guid), PGUID (prd->e.guid), m->seq);
ddsrt_avl_insert_ipath (&wr_readers_treedef, &wr->readers, m, &path);
rebuild_writer_addrset (wr);
wr->num_reliable_readers += m->is_reliable;
@ -1623,13 +1623,13 @@ static void writer_add_local_connection (struct writer *wr, struct reader *rd)
ddsrt_mutex_lock (&wr->e.lock);
if (ddsrt_avl_lookup_ipath (&wr_local_readers_treedef, &wr->local_readers, &rd->e.guid, &path))
{
DDS_LOG(DDS_LC_DISCOVERY, " writer_add_local_connection(wr %x:%x:%x:%x rd %x:%x:%x:%x) - already connected\n", PGUID (wr->e.guid), PGUID (rd->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, " writer_add_local_connection(wr "PGUIDFMT" rd "PGUIDFMT") - already connected\n", PGUID (wr->e.guid), PGUID (rd->e.guid));
ddsrt_mutex_unlock (&wr->e.lock);
ddsrt_free (m);
return;
}
DDS_LOG(DDS_LC_DISCOVERY, " writer_add_local_connection(wr %x:%x:%x:%x rd %x:%x:%x:%x)", PGUID (wr->e.guid), PGUID (rd->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, " writer_add_local_connection(wr "PGUIDFMT" rd "PGUIDFMT")", PGUID (wr->e.guid), PGUID (rd->e.guid));
m->rd_guid = rd->e.guid;
ddsrt_avl_insert_ipath (&wr_local_readers_treedef, &wr->local_readers, m, &path);
local_reader_ary_insert (&wr->rdary, rd);
@ -1684,19 +1684,19 @@ static void reader_add_connection (struct reader *rd, struct proxy_writer *pwr,
writer will always see monotonically increasing sequence numbers
from one particular reader. This is then used for the
pwr_rd_match initialization */
DDS_LOG(DDS_LC_DISCOVERY, " reader %x:%x:%x:%x init_acknack_count = %d\n", PGUID (rd->e.guid), rd->init_acknack_count);
DDS_LOG(DDS_LC_DISCOVERY, " reader "PGUIDFMT" init_acknack_count = %"PRId32"\n", PGUID (rd->e.guid), rd->init_acknack_count);
*init_count = rd->init_acknack_count;
if (ddsrt_avl_lookup_ipath (&rd_writers_treedef, &rd->writers, &pwr->e.guid, &path))
{
DDS_LOG(DDS_LC_DISCOVERY, " reader_add_connection(pwr %x:%x:%x:%x rd %x:%x:%x:%x) - already connected\n",
DDS_LOG(DDS_LC_DISCOVERY, " reader_add_connection(pwr "PGUIDFMT" rd "PGUIDFMT") - already connected\n",
PGUID (pwr->e.guid), PGUID (rd->e.guid));
ddsrt_mutex_unlock (&rd->e.lock);
ddsrt_free (m);
}
else
{
DDS_LOG(DDS_LC_DISCOVERY, " reader_add_connection(pwr %x:%x:%x:%x rd %x:%x:%x:%x)\n",
DDS_LOG(DDS_LC_DISCOVERY, " reader_add_connection(pwr "PGUIDFMT" rd "PGUIDFMT")\n",
PGUID (pwr->e.guid), PGUID (rd->e.guid));
ddsrt_avl_insert_ipath (&rd_writers_treedef, &rd->writers, m, &path);
ddsrt_mutex_unlock (&rd->e.lock);
@ -1744,13 +1744,13 @@ static void reader_add_local_connection (struct reader *rd, struct writer *wr)
if (ddsrt_avl_lookup_ipath (&rd_local_writers_treedef, &rd->local_writers, &wr->e.guid, &path))
{
DDS_LOG(DDS_LC_DISCOVERY, " reader_add_local_connection(wr %x:%x:%x:%x rd %x:%x:%x:%x) - already connected\n", PGUID (wr->e.guid), PGUID (rd->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, " reader_add_local_connection(wr "PGUIDFMT" rd "PGUIDFMT") - already connected\n", PGUID (wr->e.guid), PGUID (rd->e.guid));
ddsrt_mutex_unlock (&rd->e.lock);
ddsrt_free (m);
}
else
{
DDS_LOG(DDS_LC_DISCOVERY, " reader_add_local_connection(wr %x:%x:%x:%x rd %x:%x:%x:%x)\n", PGUID (wr->e.guid), PGUID (rd->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, " reader_add_local_connection(wr "PGUIDFMT" rd "PGUIDFMT")\n", PGUID (wr->e.guid), PGUID (rd->e.guid));
ddsrt_avl_insert_ipath (&rd_local_writers_treedef, &rd->local_writers, m, &path);
ddsrt_mutex_unlock (&rd->e.lock);
@ -1787,7 +1787,7 @@ static void proxy_writer_add_connection (struct proxy_writer *pwr, struct reader
pwr->ddsi2direct_cbarg = rd->ddsi2direct_cbarg;
}
DDS_LOG(DDS_LC_DISCOVERY, " proxy_writer_add_connection(pwr %x:%x:%x:%x rd %x:%x:%x:%x)",
DDS_LOG(DDS_LC_DISCOVERY, " proxy_writer_add_connection(pwr "PGUIDFMT" rd "PGUIDFMT")",
PGUID (pwr->e.guid), PGUID (rd->e.guid));
m->rd_guid = rd->e.guid;
m->tcreate = now_mt ();
@ -1880,7 +1880,7 @@ static void proxy_writer_add_connection (struct proxy_writer *pwr, struct reader
already_matched:
assert (is_builtin_entityid (pwr->e.guid.entityid, pwr->c.vendor) ? (pwr->c.topic == NULL) : (pwr->c.topic != NULL));
DDS_LOG(DDS_LC_DISCOVERY, " proxy_writer_add_connection(pwr %x:%x:%x:%x rd %x:%x:%x:%x) - already connected\n",
DDS_LOG(DDS_LC_DISCOVERY, " proxy_writer_add_connection(pwr "PGUIDFMT" rd "PGUIDFMT") - already connected\n",
PGUID (pwr->e.guid), PGUID (rd->e.guid));
ddsrt_mutex_unlock (&pwr->e.lock);
ddsrt_free (m);
@ -1898,14 +1898,14 @@ static void proxy_reader_add_connection (struct proxy_reader *prd, struct writer
prd->c.topic = ddsi_sertopic_ref (wr->topic);
if (ddsrt_avl_lookup_ipath (&prd_writers_treedef, &prd->writers, &wr->e.guid, &path))
{
DDS_LOG(DDS_LC_DISCOVERY, " proxy_reader_add_connection(wr %x:%x:%x:%x prd %x:%x:%x:%x) - already connected\n",
DDS_LOG(DDS_LC_DISCOVERY, " proxy_reader_add_connection(wr "PGUIDFMT" prd "PGUIDFMT") - already connected\n",
PGUID (wr->e.guid), PGUID (prd->e.guid));
ddsrt_mutex_unlock (&prd->e.lock);
ddsrt_free (m);
}
else
{
DDS_LOG(DDS_LC_DISCOVERY, " proxy_reader_add_connection(wr %x:%x:%x:%x prd %x:%x:%x:%x)\n",
DDS_LOG(DDS_LC_DISCOVERY, " proxy_reader_add_connection(wr "PGUIDFMT" prd "PGUIDFMT")\n",
PGUID (wr->e.guid), PGUID (prd->e.guid));
ddsrt_avl_insert_ipath (&prd_writers_treedef, &prd->writers, m, &path);
ddsrt_mutex_unlock (&prd->e.lock);
@ -2259,7 +2259,7 @@ static void generic_do_match (struct entity_common *e, nn_mtime_t tnow)
enum entity_kind mkind = generic_do_match_mkind(e->kind);
if (!is_builtin_entityid (e->guid.entityid, NN_VENDORID_ECLIPSE))
{
DDS_LOG(DDS_LC_DISCOVERY, "match_%s_with_%ss(%s %x:%x:%x:%x) scanning all %ss\n",
DDS_LOG(DDS_LC_DISCOVERY, "match_%s_with_%ss(%s "PGUIDFMT") scanning all %ss\n",
generic_do_match_kindstr_us (e->kind), generic_do_match_kindstr_us (mkind),
generic_do_match_kindabbrev (e->kind), PGUID (e->guid),
generic_do_match_kindstr(mkind));
@ -2280,7 +2280,7 @@ static void generic_do_match (struct entity_common *e, nn_mtime_t tnow)
/* Built-ins have fixed QoS */
nn_entityid_t tgt_ent = builtin_entityid_match (e->guid.entityid);
enum entity_kind pkind = generic_do_match_isproxy (e) ? EK_PARTICIPANT : EK_PROXY_PARTICIPANT;
DDS_LOG(DDS_LC_DISCOVERY, "match_%s_with_%ss(%s %x:%x:%x:%x) scanning %sparticipants tgt=%x\n",
DDS_LOG(DDS_LC_DISCOVERY, "match_%s_with_%ss(%s "PGUIDFMT") scanning %sparticipants tgt=%"PRIx32"\n",
generic_do_match_kindstr_us (e->kind), generic_do_match_kindstr_us (mkind),
generic_do_match_kindabbrev (e->kind), PGUID (e->guid),
generic_do_match_isproxy (e) ? "" : "proxy ",
@ -2311,7 +2311,7 @@ static void generic_do_local_match (struct entity_common *e, nn_mtime_t tnow)
/* never a need for local matches on discovery endpoints */
return;
mkind = generic_do_local_match_mkind(e->kind);
DDS_LOG(DDS_LC_DISCOVERY, "match_%s_with_%ss(%s %x:%x:%x:%x) scanning all %ss\n",
DDS_LOG(DDS_LC_DISCOVERY, "match_%s_with_%ss(%s "PGUIDFMT") scanning all %ss\n",
generic_do_match_kindstr_us (e->kind), generic_do_match_kindstr_us (mkind),
generic_do_match_kindabbrev (e->kind), PGUID (e->guid),
generic_do_match_kindstr(mkind));
@ -2378,7 +2378,7 @@ static void new_reader_writer_common (const struct nn_guid *guid, const struct d
if (xqos->partition.n > 1)
partition_suffix = "+";
}
DDS_LOG(DDS_LC_DISCOVERY, "new_%s(guid %x:%x:%x:%x, %s%s.%s/%s)\n",
DDS_LOG(DDS_LC_DISCOVERY, "new_%s(guid "PGUIDFMT", %s%s.%s/%s)\n",
is_writer_entityid (guid->entityid) ? "writer" : "reader",
PGUID (*guid),
partition, partition_suffix,
@ -2607,7 +2607,7 @@ unsigned remove_acked_messages (struct writer *wr, struct whc_state *whcst, stru
writer_clear_retransmitting (wr);
if (wr->state == WRST_LINGERING && whcst->unacked_bytes == 0)
{
DDS_LOG(DDS_LC_DISCOVERY, "remove_acked_messages: deleting lingering writer %x:%x:%x:%x\n", PGUID (wr->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, "remove_acked_messages: deleting lingering writer "PGUIDFMT"\n", PGUID (wr->e.guid));
delete_writer_nolinger_locked (wr);
}
return n;
@ -2646,7 +2646,7 @@ static void new_writer_guid_common_init (struct writer *wr, const struct ddsi_se
assert (wr->xqos->aliased == 0);
set_topic_type_name (wr->xqos, topic);
DDS_LOG(DDS_LC_DISCOVERY, "WRITER %x:%x:%x:%x QOS={", PGUID (wr->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, "WRITER "PGUIDFMT" QOS={", PGUID (wr->e.guid));
nn_log_xqos (DDS_LC_DISCOVERY, wr->xqos);
DDS_LOG(DDS_LC_DISCOVERY, "}\n");
@ -2738,7 +2738,7 @@ static void new_writer_guid_common_init (struct writer *wr, const struct ddsi_se
wr->supports_ssm = 1;
wr->ssm_as = new_addrset ();
add_to_addrset (wr->ssm_as, &loc);
DDS_LOG(DDS_LC_DISCOVERY, "writer %x:%x:%x:%x: ssm=%d", PGUID (wr->e.guid), wr->supports_ssm);
DDS_LOG(DDS_LC_DISCOVERY, "writer "PGUIDFMT": ssm=%d", PGUID (wr->e.guid), wr->supports_ssm);
nn_log_addrset (DDS_LC_DISCOVERY, "", wr->ssm_as);
DDS_LOG(DDS_LC_DISCOVERY, "\n");
}
@ -2751,7 +2751,7 @@ static void new_writer_guid_common_init (struct writer *wr, const struct ddsi_se
if (!is_builtin_entityid (wr->e.guid.entityid, ownvendorid))
{
struct config_channel_listelem *channel = find_channel (wr->xqos->transport_priority);
DDS_LOG(DDS_LC_DISCOVERY, "writer %x:%x:%x:%x: transport priority %d => channel '%s' priority %d\n",
DDS_LOG(DDS_LC_DISCOVERY, "writer "PGUIDFMT": transport priority %d => channel '%s' priority %d\n",
PGUID (wr->e.guid), wr->xqos->transport_priority.value, channel->name, channel->priority);
wr->evq = channel->evq ? channel->evq : gv.xevents;
}
@ -2779,7 +2779,7 @@ static void new_writer_guid_common_init (struct writer *wr, const struct ddsi_se
if (wr->xqos->liveliness.kind != NN_AUTOMATIC_LIVELINESS_QOS ||
nn_from_ddsi_duration (wr->xqos->liveliness.lease_duration) != T_NEVER)
{
DDS_LOG(DDS_LC_DISCOVERY, "writer %x:%x:%x:%x: incorrectly treating it as of automatic liveliness kind with lease duration = inf (%d, %"PRId64")\n", PGUID (wr->e.guid), (int) wr->xqos->liveliness.kind, nn_from_ddsi_duration (wr->xqos->liveliness.lease_duration));
DDS_LOG(DDS_LC_DISCOVERY, "writer "PGUIDFMT": incorrectly treating it as of automatic liveliness kind with lease duration = inf (%d, %"PRId64")\n", PGUID (wr->e.guid), (int) wr->xqos->liveliness.kind, nn_from_ddsi_duration (wr->xqos->liveliness.lease_duration));
}
wr->lease_duration = T_NEVER; /* FIXME */
@ -2862,7 +2862,7 @@ dds_retcode_t new_writer (struct writer **wr_out, struct nn_guid *wrguid, const
if ((pp = ephash_lookup_participant_guid (ppguid)) == NULL)
{
DDS_LOG(DDS_LC_DISCOVERY, "new_writer - participant %x:%x:%x:%x not found\n", PGUID (*ppguid));
DDS_LOG(DDS_LC_DISCOVERY, "new_writer - participant "PGUIDFMT" not found\n", PGUID (*ppguid));
return DDS_RETCODE_NOT_FOUND;
}
/* participant can't be freed while we're mucking around cos we are
@ -2900,7 +2900,7 @@ struct local_orphan_writer *new_local_orphan_writer (nn_entityid_t entityid, str
static void gc_delete_writer (struct gcreq *gcreq)
{
struct writer *wr = gcreq->arg;
DDS_LOG(DDS_LC_DISCOVERY, "gc_delete_writer(%p, %x:%x:%x:%x)\n", (void *) gcreq, PGUID (wr->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, "gc_delete_writer(%p, "PGUIDFMT")\n", (void *) gcreq, PGUID (wr->e.guid));
gcreq_free (gcreq);
/* We now allow GC while blocked on a full WHC, but we still don't allow deleting a writer while blocked on it. The writer's state must be DELETING by the time we get here, and that means the transmit path is no longer blocked. It doesn't imply that the write thread is no longer in throttle_writer(), just that if it is, it will soon return from there. Therefore, block until it isn't throttling anymore. We can safely lock the writer, as we're on the separate GC thread. */
@ -2959,7 +2959,7 @@ static void gc_delete_writer (struct gcreq *gcreq)
static void gc_delete_writer_throttlewait (struct gcreq *gcreq)
{
struct writer *wr = gcreq->arg;
DDS_LOG(DDS_LC_DISCOVERY, "gc_delete_writer_throttlewait(%p, %x:%x:%x:%x)\n", (void *) gcreq, PGUID (wr->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, "gc_delete_writer_throttlewait(%p, "PGUIDFMT")\n", (void *) gcreq, PGUID (wr->e.guid));
/* We now allow GC while blocked on a full WHC, but we still don't allow deleting a writer while blocked on it. The writer's state must be DELETING by the time we get here, and that means the transmit path is no longer blocked. It doesn't imply that the write thread is no longer in throttle_writer(), just that if it is, it will soon return from there. Therefore, block until it isn't throttling anymore. We can safely lock the writer, as we're on the separate GC thread. */
assert (wr->state == WRST_DELETING);
ddsrt_mutex_lock (&wr->e.lock);
@ -2972,7 +2972,7 @@ static void gc_delete_writer_throttlewait (struct gcreq *gcreq)
static void writer_set_state (struct writer *wr, enum writer_state newstate)
{
ASSERT_MUTEX_HELD (&wr->e.lock);
DDS_LOG(DDS_LC_DISCOVERY, "writer_set_state(%x:%x:%x:%x) state transition %d -> %d\n", PGUID (wr->e.guid), wr->state, newstate);
DDS_LOG(DDS_LC_DISCOVERY, "writer_set_state("PGUIDFMT") state transition %d -> %d\n", PGUID (wr->e.guid), wr->state, newstate);
assert (newstate > wr->state);
if (wr->state == WRST_OPERATIONAL)
{
@ -2989,7 +2989,7 @@ static void writer_set_state (struct writer *wr, enum writer_state newstate)
int delete_writer_nolinger_locked (struct writer *wr)
{
DDS_LOG(DDS_LC_DISCOVERY, "delete_writer_nolinger(guid %x:%x:%x:%x) ...\n", PGUID (wr->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, "delete_writer_nolinger(guid "PGUIDFMT") ...\n", PGUID (wr->e.guid));
ASSERT_MUTEX_HELD (&wr->e.lock);
ddsi_plugin.builtintopic_write (&wr->e, now(), false);
local_reader_ary_setinvalid (&wr->rdary);
@ -3011,10 +3011,10 @@ int delete_writer_nolinger (const struct nn_guid *guid)
assert (is_writer_entityid (guid->entityid));
if ((wr = ephash_lookup_writer_guid (guid)) == NULL)
{
DDS_LOG(DDS_LC_DISCOVERY, "delete_writer_nolinger(guid %x:%x:%x:%x) - unknown guid\n", PGUID (*guid));
DDS_LOG(DDS_LC_DISCOVERY, "delete_writer_nolinger(guid "PGUIDFMT") - unknown guid\n", PGUID (*guid));
return Q_ERR_UNKNOWN_ENTITY;
}
DDS_LOG(DDS_LC_DISCOVERY, "delete_writer_nolinger(guid %x:%x:%x:%x) ...\n", PGUID (*guid));
DDS_LOG(DDS_LC_DISCOVERY, "delete_writer_nolinger(guid "PGUIDFMT") ...\n", PGUID (*guid));
ddsrt_mutex_lock (&wr->e.lock);
delete_writer_nolinger_locked (wr);
ddsrt_mutex_unlock (&wr->e.lock);
@ -3034,10 +3034,10 @@ int delete_writer (const struct nn_guid *guid)
struct whc_state whcst;
if ((wr = ephash_lookup_writer_guid (guid)) == NULL)
{
DDS_LOG(DDS_LC_DISCOVERY, "delete_writer(guid %x:%x:%x:%x) - unknown guid\n", PGUID (*guid));
DDS_LOG(DDS_LC_DISCOVERY, "delete_writer(guid "PGUIDFMT") - unknown guid\n", PGUID (*guid));
return Q_ERR_UNKNOWN_ENTITY;
}
DDS_LOG(DDS_LC_DISCOVERY, "delete_writer(guid %x:%x:%x:%x) ...\n", PGUID (*guid));
DDS_LOG(DDS_LC_DISCOVERY, "delete_writer(guid "PGUIDFMT") ...\n", PGUID (*guid));
ddsrt_mutex_lock (&wr->e.lock);
/* If no unack'ed data, don't waste time or resources (expected to
@ -3047,7 +3047,7 @@ int delete_writer (const struct nn_guid *guid)
whc_get_state(wr->whc, &whcst);
if (whcst.unacked_bytes == 0)
{
DDS_LOG(DDS_LC_DISCOVERY, "delete_writer(guid %x:%x:%x:%x) - no unack'ed samples\n", PGUID (*guid));
DDS_LOG(DDS_LC_DISCOVERY, "delete_writer(guid "PGUIDFMT") - no unack'ed samples\n", PGUID (*guid));
delete_writer_nolinger_locked (wr);
ddsrt_mutex_unlock (&wr->e.lock);
}
@ -3059,7 +3059,7 @@ int delete_writer (const struct nn_guid *guid)
ddsrt_mutex_unlock (&wr->e.lock);
tsched = add_duration_to_mtime (now_mt (), config.writer_linger_duration);
mtime_to_sec_usec (&tsec, &tusec, tsched);
DDS_LOG(DDS_LC_DISCOVERY, "delete_writer(guid %x:%x:%x:%x) - unack'ed samples, will delete when ack'd or at t = %"PRId32".%06"PRId32"\n",
DDS_LOG(DDS_LC_DISCOVERY, "delete_writer(guid "PGUIDFMT") - unack'ed samples, will delete when ack'd or at t = %"PRId32".%06"PRId32"\n",
PGUID (*guid), tsec, tusec);
qxev_delete_writer (tsched, &wr->e.guid);
}
@ -3078,7 +3078,7 @@ void writer_exit_startup_mode (struct writer *wr)
cnt += remove_acked_messages (wr, &whcst, &deferred_free_list);
cnt += whc_downgrade_to_volatile (wr->whc, &whcst);
writer_clear_retransmitting (wr);
DDS_LOG(DDS_LC_DISCOVERY, " %x:%x:%x:%x: dropped %u samples\n", PGUID(wr->e.guid), cnt);
DDS_LOG(DDS_LC_DISCOVERY, " "PGUIDFMT": dropped %u samples\n", PGUID(wr->e.guid), cnt);
}
ddsrt_mutex_unlock (&wr->e.lock);
whc_free_deferred_free_list (wr->whc, deferred_free_list);
@ -3237,7 +3237,7 @@ static dds_retcode_t new_reader_guid
if (dds_get_log_mask() & DDS_LC_DISCOVERY)
{
DDS_LOG(DDS_LC_DISCOVERY, "READER %x:%x:%x:%x QOS={", PGUID (rd->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, "READER "PGUIDFMT" QOS={", PGUID (rd->e.guid));
nn_log_xqos (DDS_LC_DISCOVERY, rd->xqos);
DDS_LOG(DDS_LC_DISCOVERY, "}\n");
}
@ -3268,7 +3268,7 @@ static dds_retcode_t new_reader_guid
if (rd->xqos->liveliness.kind != NN_AUTOMATIC_LIVELINESS_QOS ||
nn_from_ddsi_duration (rd->xqos->liveliness.lease_duration) != T_NEVER)
{
DDS_LOG(DDS_LC_DISCOVERY, "reader %x:%x:%x:%x: incorrectly treating it as of automatic liveliness kind with lease duration = inf (%d, %"PRId64")\n", PGUID (rd->e.guid), (int) rd->xqos->liveliness.kind, nn_from_ddsi_duration (rd->xqos->liveliness.lease_duration));
DDS_LOG(DDS_LC_DISCOVERY, "reader "PGUIDFMT": incorrectly treating it as of automatic liveliness kind with lease duration = inf (%d, %"PRId64")\n", PGUID (rd->e.guid), (int) rd->xqos->liveliness.kind, nn_from_ddsi_duration (rd->xqos->liveliness.lease_duration));
}
#ifdef DDSI_INCLUDE_NETWORK_PARTITIONS
@ -3302,7 +3302,7 @@ static dds_retcode_t new_reader_guid
addrset_forall (rd->as, join_mcast_helper, gv.data_conn_mc);
if (dds_get_log_mask() & DDS_LC_DISCOVERY)
{
DDS_LOG(DDS_LC_DISCOVERY, "READER %x:%x:%x:%x locators={", PGUID (rd->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, "READER "PGUIDFMT" locators={", PGUID (rd->e.guid));
nn_log_addrset(DDS_LC_DISCOVERY, "", rd->as);
DDS_LOG(DDS_LC_DISCOVERY, "}\n");
}
@ -3320,7 +3320,7 @@ static dds_retcode_t new_reader_guid
}
#ifdef DDSI_INCLUDE_SSM
if (rd->favours_ssm)
DDS_LOG(DDS_LC_DISCOVERY, "READER %x:%x:%x:%x ssm=%d\n", PGUID (rd->e.guid), rd->favours_ssm);
DDS_LOG(DDS_LC_DISCOVERY, "READER "PGUIDFMT" ssm=%d\n", PGUID (rd->e.guid), rd->favours_ssm);
#endif
#endif
@ -3355,7 +3355,7 @@ dds_retcode_t new_reader
if ((pp = ephash_lookup_participant_guid (ppguid)) == NULL)
{
DDS_LOG(DDS_LC_DISCOVERY, "new_reader - participant %x:%x:%x:%x not found\n", PGUID (*ppguid));
DDS_LOG(DDS_LC_DISCOVERY, "new_reader - participant "PGUIDFMT" not found\n", PGUID (*ppguid));
return DDS_RETCODE_NOT_FOUND;
}
rdguid->prefix = pp->e.guid.prefix;
@ -3368,7 +3368,7 @@ static void gc_delete_reader (struct gcreq *gcreq)
{
/* see gc_delete_writer for comments */
struct reader *rd = gcreq->arg;
DDS_LOG(DDS_LC_DISCOVERY, "gc_delete_reader(%p, %x:%x:%x:%x)\n", (void *) gcreq, PGUID (rd->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, "gc_delete_reader(%p, "PGUIDFMT")\n", (void *) gcreq, PGUID (rd->e.guid));
gcreq_free (gcreq);
while (!ddsrt_avl_is_empty (&rd->writers))
@ -3417,10 +3417,10 @@ int delete_reader (const struct nn_guid *guid)
assert (!is_writer_entityid (guid->entityid));
if ((rd = ephash_lookup_reader_guid (guid)) == NULL)
{
DDS_LOG(DDS_LC_DISCOVERY, "delete_reader_guid(guid %x:%x:%x:%x) - unknown guid\n", PGUID (*guid));
DDS_LOG(DDS_LC_DISCOVERY, "delete_reader_guid(guid "PGUIDFMT") - unknown guid\n", PGUID (*guid));
return Q_ERR_UNKNOWN_ENTITY;
}
DDS_LOG(DDS_LC_DISCOVERY, "delete_reader_guid(guid %x:%x:%x:%x) ...\n", PGUID (*guid));
DDS_LOG(DDS_LC_DISCOVERY, "delete_reader_guid(guid "PGUIDFMT") ...\n", PGUID (*guid));
ddsi_plugin.builtintopic_write (&rd->e, now(), false);
ephash_remove_reader_guid (rd);
gcreq_reader (rd);
@ -3754,7 +3754,7 @@ static void unref_proxy_participant (struct proxy_participant *proxypp, struct p
{
assert (proxypp->endpoints == NULL);
ddsrt_mutex_unlock (&proxypp->e.lock);
DDS_LOG(DDS_LC_DISCOVERY, "unref_proxy_participant(%x:%x:%x:%x): refc=0, freeing\n", PGUID (proxypp->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, "unref_proxy_participant("PGUIDFMT"): refc=0, freeing\n", PGUID (proxypp->e.guid));
unref_addrset (proxypp->as_default);
@ -3771,7 +3771,7 @@ static void unref_proxy_participant (struct proxy_participant *proxypp, struct p
{
assert (refc == 1);
ddsrt_mutex_unlock (&proxypp->e.lock);
DDS_LOG(DDS_LC_DISCOVERY, "unref_proxy_participant(%x:%x:%x:%x): refc=%u, no endpoints, implicitly created, deleting\n", PGUID (proxypp->e.guid), (unsigned) refc);
DDS_LOG(DDS_LC_DISCOVERY, "unref_proxy_participant("PGUIDFMT"): refc=%u, no endpoints, implicitly created, deleting\n", PGUID (proxypp->e.guid), (unsigned) refc);
delete_proxy_participant_by_guid(&proxypp->e.guid, tnow, 1);
/* Deletion is still (and has to be) asynchronous. A parallel endpoint creation may or may not
succeed, and if it succeeds it will be deleted along with the proxy participant. So "your
@ -3780,14 +3780,14 @@ static void unref_proxy_participant (struct proxy_participant *proxypp, struct p
else
{
ddsrt_mutex_unlock (&proxypp->e.lock);
DDS_LOG(DDS_LC_DISCOVERY, "unref_proxy_participant(%x:%x:%x:%x): refc=%u\n", PGUID (proxypp->e.guid), (unsigned) refc);
DDS_LOG(DDS_LC_DISCOVERY, "unref_proxy_participant("PGUIDFMT"): refc=%u\n", PGUID (proxypp->e.guid), (unsigned) refc);
}
}
static void gc_delete_proxy_participant (struct gcreq *gcreq)
{
struct proxy_participant *proxypp = gcreq->arg;
DDS_LOG(DDS_LC_DISCOVERY, "gc_delete_proxy_participant(%p, %x:%x:%x:%x)\n", (void *) gcreq, PGUID (proxypp->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, "gc_delete_proxy_participant(%p, "PGUIDFMT")\n", (void *) gcreq, PGUID (proxypp->e.guid));
gcreq_free (gcreq);
unref_proxy_participant (proxypp, NULL);
}
@ -3820,7 +3820,7 @@ static void delete_or_detach_dependent_pp (struct proxy_participant *p, struct p
{
nn_etime_t texp = add_duration_to_etime (now_et(), config.ds_grace_period);
/* Clear dependency (but don't touch entity id, which must be 0x1c1) and set the lease ticking */
DDS_LOG(DDS_LC_DISCOVERY, "%x:%x:%x:%x detach-from-DS %x:%x:%x:%x\n", PGUID(p->e.guid), PGUID(proxypp->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, PGUIDFMT" detach-from-DS "PGUIDFMT"\n", PGUID(p->e.guid), PGUID(proxypp->e.guid));
memset (&p->privileged_pp_guid.prefix, 0, sizeof (p->privileged_pp_guid.prefix));
lease_set_expiry (ddsrt_atomic_ldvoidp (&p->lease), texp);
ddsrt_mutex_unlock (&p->e.lock);
@ -3833,7 +3833,7 @@ static void delete_ppt (struct proxy_participant * proxypp, nn_wctime_t timestam
int ret;
/* if any proxy participants depend on this participant, delete them */
DDS_LOG(DDS_LC_DISCOVERY, "delete_ppt(%x:%x:%x:%x) - deleting dependent proxy participants\n", PGUID (proxypp->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, "delete_ppt("PGUIDFMT") - deleting dependent proxy participants\n", PGUID (proxypp->e.guid));
{
struct ephash_enum_proxy_participant est;
struct proxy_participant *p;
@ -3850,11 +3850,11 @@ static void delete_ppt (struct proxy_participant * proxypp, nn_wctime_t timestam
if (isimplicit)
proxypp->lease_expired = 1;
DDS_LOG(DDS_LC_DISCOVERY, "delete_ppt(%x:%x:%x:%x) - deleting groups\n", PGUID (proxypp->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, "delete_ppt("PGUIDFMT") - deleting groups\n", PGUID (proxypp->e.guid));
while (!ddsrt_avl_is_empty (&proxypp->groups))
delete_proxy_group_locked (ddsrt_avl_root (&proxypp_groups_treedef, &proxypp->groups), timestamp, isimplicit);
DDS_LOG(DDS_LC_DISCOVERY, "delete_ppt(%x:%x:%x:%x) - deleting endpoints\n", PGUID (proxypp->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, "delete_ppt("PGUIDFMT") - deleting endpoints\n", PGUID (proxypp->e.guid));
c = proxypp->endpoints;
while (c)
{
@ -3915,7 +3915,7 @@ int delete_proxy_participant_by_guid (const struct nn_guid * guid, nn_wctime_t t
{
struct proxy_participant * ppt;
DDS_LOG(DDS_LC_DISCOVERY, "delete_proxy_participant_by_guid(%x:%x:%x:%x) ", PGUID (*guid));
DDS_LOG(DDS_LC_DISCOVERY, "delete_proxy_participant_by_guid("PGUIDFMT") ", PGUID (*guid));
ddsrt_mutex_lock (&gv.lock);
ppt = ephash_lookup_proxy_participant_guid (guid);
if (ppt == NULL)
@ -3959,7 +3959,7 @@ int new_proxy_group (const struct nn_guid *guid, const char *name, const struct
ppguid.entityid.u = NN_ENTITYID_PARTICIPANT;
if ((proxypp = ephash_lookup_proxy_participant_guid (&ppguid)) == NULL)
{
DDS_LOG(DDS_LC_DISCOVERY, "new_proxy_group(%x:%x:%x:%x) - unknown participant\n", PGUID (*guid));
DDS_LOG(DDS_LC_DISCOVERY, "new_proxy_group("PGUIDFMT") - unknown participant\n", PGUID (*guid));
return 0;
}
else
@ -3976,7 +3976,7 @@ int new_proxy_group (const struct nn_guid *guid, const char *name, const struct
is_sub = 1;
break;
default:
DDS_WARNING("new_proxy_group: unrecognised entityid: %x\n", guid->entityid.u);
DDS_WARNING("new_proxy_group: unrecognised entityid: %"PRIx32"\n", guid->entityid.u);
return Q_ERR_INVALID_DATA;
}
ddsrt_mutex_lock (&proxypp->e.lock);
@ -3991,7 +3991,7 @@ int new_proxy_group (const struct nn_guid *guid, const char *name, const struct
else
{
/* Always have a guid, may not have a gid */
DDS_LOG(DDS_LC_DISCOVERY, "new_proxy_group(%x:%x:%x:%x): new\n", PGUID (*guid));
DDS_LOG(DDS_LC_DISCOVERY, "new_proxy_group("PGUIDFMT"): new\n", PGUID (*guid));
pgroup = ddsrt_malloc (sizeof (*pgroup));
pgroup->guid = *guid;
pgroup->proxypp = proxypp;
@ -4002,7 +4002,7 @@ int new_proxy_group (const struct nn_guid *guid, const char *name, const struct
if (name)
{
assert (xqos != NULL);
DDS_LOG(DDS_LC_DISCOVERY, "new_proxy_group(%x:%x:%x:%x): setting name (%s) and qos\n", PGUID (*guid), name);
DDS_LOG(DDS_LC_DISCOVERY, "new_proxy_group("PGUIDFMT"): setting name (%s) and qos\n", PGUID (*guid), name);
pgroup->name = ddsrt_strdup (name);
pgroup->xqos = nn_xqos_dup (xqos);
nn_xqos_mergein_missing (pgroup->xqos, is_sub ? &gv.default_xqos_sub : &gv.default_xqos_pub);
@ -4020,7 +4020,7 @@ static void delete_proxy_group_locked (struct proxy_group *pgroup, nn_wctime_t t
(void)timestamp;
(void)isimplicit;
assert ((pgroup->xqos != NULL) == (pgroup->name != NULL));
DDS_LOG(DDS_LC_DISCOVERY, "delete_proxy_group_locked %x:%x:%x:%x\n", PGUID (pgroup->guid));
DDS_LOG(DDS_LC_DISCOVERY, "delete_proxy_group_locked "PGUIDFMT"\n", PGUID (pgroup->guid));
ddsrt_avl_delete (&proxypp_groups_treedef, &proxypp->groups, pgroup);
/* Publish corresponding built-in topic only if it is not a place
holder: in that case we haven't announced its presence and
@ -4105,7 +4105,7 @@ int new_proxy_writer (const struct nn_guid *ppguid, const struct nn_guid *guid,
if ((proxypp = ephash_lookup_proxy_participant_guid (ppguid)) == NULL)
{
DDS_WARNING("new_proxy_writer(%x:%x:%x:%x): proxy participant unknown\n", PGUID (*guid));
DDS_WARNING("new_proxy_writer("PGUIDFMT"): proxy participant unknown\n", PGUID (*guid));
return Q_ERR_UNKNOWN_ENTITY;
}
@ -4277,7 +4277,7 @@ void update_proxy_reader (struct proxy_reader * prd, struct addrset * as)
static void gc_delete_proxy_writer (struct gcreq *gcreq)
{
struct proxy_writer *pwr = gcreq->arg;
DDS_LOG(DDS_LC_DISCOVERY, "gc_delete_proxy_writer(%p, %x:%x:%x:%x)\n", (void *) gcreq, PGUID (pwr->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, "gc_delete_proxy_writer(%p, "PGUIDFMT")\n", (void *) gcreq, PGUID (pwr->e.guid));
gcreq_free (gcreq);
while (!ddsrt_avl_is_empty (&pwr->readers))
@ -4299,7 +4299,7 @@ int delete_proxy_writer (const struct nn_guid *guid, nn_wctime_t timestamp, int
{
struct proxy_writer *pwr;
(void)isimplicit;
DDS_LOG(DDS_LC_DISCOVERY, "delete_proxy_writer (%x:%x:%x:%x) ", PGUID (*guid));
DDS_LOG(DDS_LC_DISCOVERY, "delete_proxy_writer ("PGUIDFMT") ", PGUID (*guid));
ddsrt_mutex_lock (&gv.lock);
if ((pwr = ephash_lookup_proxy_writer_guid (guid)) == NULL)
{
@ -4337,7 +4337,7 @@ int new_proxy_reader (const struct nn_guid *ppguid, const struct nn_guid *guid,
if ((proxypp = ephash_lookup_proxy_participant_guid (ppguid)) == NULL)
{
DDS_WARNING("new_proxy_reader(%x:%x:%x:%x): proxy participant unknown\n", PGUID (*guid));
DDS_WARNING("new_proxy_reader("PGUIDFMT"): proxy participant unknown\n", PGUID (*guid));
return Q_ERR_UNKNOWN_ENTITY;
}
@ -4416,7 +4416,7 @@ static void proxy_reader_set_delete_and_ack_all_messages (struct proxy_reader *p
static void gc_delete_proxy_reader (struct gcreq *gcreq)
{
struct proxy_reader *prd = gcreq->arg;
DDS_LOG(DDS_LC_DISCOVERY, "gc_delete_proxy_reader(%p, %x:%x:%x:%x)\n", (void *) gcreq, PGUID (prd->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, "gc_delete_proxy_reader(%p, "PGUIDFMT")\n", (void *) gcreq, PGUID (prd->e.guid));
gcreq_free (gcreq);
while (!ddsrt_avl_is_empty (&prd->writers))
@ -4435,7 +4435,7 @@ int delete_proxy_reader (const struct nn_guid *guid, nn_wctime_t timestamp, int
{
struct proxy_reader *prd;
(void)isimplicit;
DDS_LOG(DDS_LC_DISCOVERY, "delete_proxy_reader (%x:%x:%x:%x) ", PGUID (*guid));
DDS_LOG(DDS_LC_DISCOVERY, "delete_proxy_reader ("PGUIDFMT") ", PGUID (*guid));
ddsrt_mutex_lock (&gv.lock);
if ((prd = ephash_lookup_proxy_reader_guid (guid)) == NULL)
{
@ -4496,7 +4496,7 @@ static void gc_delete_proxy_writer_dqueue_bubble_cb (struct gcreq *gcreq)
{
/* delete proxy_writer, phase 3 */
struct proxy_writer *pwr = gcreq->arg;
DDS_LOG(DDS_LC_DISCOVERY, "gc_delete_proxy_writer_dqueue_bubble(%p, %x:%x:%x:%x)\n", (void *) gcreq, PGUID (pwr->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, "gc_delete_proxy_writer_dqueue_bubble(%p, "PGUIDFMT")\n", (void *) gcreq, PGUID (pwr->e.guid));
gcreq_requeue (gcreq, gc_delete_proxy_writer);
}
@ -4505,7 +4505,7 @@ static void gc_delete_proxy_writer_dqueue (struct gcreq *gcreq)
/* delete proxy_writer, phase 2 */
struct proxy_writer *pwr = gcreq->arg;
struct nn_dqueue *dqueue = pwr->dqueue;
DDS_LOG(DDS_LC_DISCOVERY, "gc_delete_proxy_writer_dqueue(%p, %x:%x:%x:%x)\n", (void *) gcreq, PGUID (pwr->e.guid));
DDS_LOG(DDS_LC_DISCOVERY, "gc_delete_proxy_writer_dqueue(%p, "PGUIDFMT")\n", (void *) gcreq, PGUID (pwr->e.guid));
nn_dqueue_enqueue_callback (dqueue, (void (*) (void *)) gc_delete_proxy_writer_dqueue_bubble_cb, gcreq);
}

16
src/core/ddsi/src/q_init.c
View file

@ -647,7 +647,7 @@ int joinleave_spdp_defmcip (int dojoin)
unref_addrset (as);
if (arg.errcount)
{
DDS_ERROR("rtps_init: failed to join multicast groups for domain %d participant %d\n", config.domainId.value, config.participantIndex);
DDS_ERROR("rtps_init: failed to join multicast groups for domain %"PRId32" participant %d\n", config.domainId.value, config.participantIndex);
return -1;
}
return 0;
@ -679,7 +679,7 @@ int create_multicast_sockets(void)
gv.disc_conn_mc = disc;
gv.data_conn_mc = data;
DDS_TRACE("Multicast Ports: discovery %d data %d \n",
DDS_TRACE("Multicast Ports: discovery %"PRIu32" data %"PRIu32" \n",
ddsi_conn_port (gv.disc_conn_mc), ddsi_conn_port (gv.data_conn_mc));
return 1;
@ -1060,7 +1060,7 @@ int rtps_init (void)
{
if (make_uc_sockets (&port_disc_uc, &port_data_uc, config.participantIndex) < 0)
{
DDS_ERROR("rtps_init: failed to create unicast sockets for domain %d participant %d\n", config.domainId.value, config.participantIndex);
DDS_ERROR("rtps_init: failed to create unicast sockets for domain %"PRId32" participant %d\n", config.domainId.value, config.participantIndex);
goto err_unicast_sockets;
}
}
@ -1078,13 +1078,13 @@ int rtps_init (void)
continue;
else /* Oops! */
{
DDS_ERROR("rtps_init: failed to create unicast sockets for domain %d participant %d\n", config.domainId.value, ppid);
DDS_ERROR("rtps_init: failed to create unicast sockets for domain %"PRId32" participant %d\n", config.domainId.value, ppid);
goto err_unicast_sockets;
}
}
if (ppid > config.maxAutoParticipantIndex)
{
DDS_ERROR("rtps_init: failed to find a free participant index for domain %d\n", config.domainId.value);
DDS_ERROR("rtps_init: failed to find a free participant index for domain %"PRId32"\n", config.domainId.value);
goto err_unicast_sockets;
}
config.participantIndex = ppid;
@ -1093,9 +1093,9 @@ int rtps_init (void)
{
assert(0);
}
DDS_LOG(DDS_LC_CONFIG, "rtps_init: uc ports: disc %u data %u\n", port_disc_uc, port_data_uc);
DDS_LOG(DDS_LC_CONFIG, "rtps_init: uc ports: disc %"PRIu32" data %"PRIu32"\n", port_disc_uc, port_data_uc);
}
DDS_LOG(DDS_LC_CONFIG, "rtps_init: domainid %d participantid %d\n", config.domainId.value, config.participantIndex);
DDS_LOG(DDS_LC_CONFIG, "rtps_init: domainid %"PRId32" participantid %d\n", config.domainId.value, config.participantIndex);
if (config.pcap_file && *config.pcap_file)
{
@ -1115,7 +1115,7 @@ int rtps_init (void)
if (gv.m_factory->m_connless)
{
if (!(config.many_sockets_mode == MSM_NO_UNICAST && config.allowMulticast))
DDS_TRACE("Unicast Ports: discovery %d data %d\n", ddsi_conn_port (gv.disc_conn_uc), ddsi_conn_port (gv.data_conn_uc));
DDS_TRACE("Unicast Ports: discovery %"PRIu32" data %"PRIu32"\n", ddsi_conn_port (gv.disc_conn_uc), ddsi_conn_port (gv.data_conn_uc));
if (config.allowMulticast)
{

16
src/core/ddsi/src/q_lease.c
View file

@ -108,7 +108,7 @@ struct lease *lease_new (nn_etime_t texpire, int64_t tdur, struct entity_common
struct lease *l;
if ((l = ddsrt_malloc (sizeof (*l))) == NULL)
return NULL;
DDS_TRACE("lease_new(tdur %"PRId64" guid %x:%x:%x:%x) @ %p\n", tdur, PGUID (e->guid), (void *) l);
DDS_TRACE("lease_new(tdur %"PRId64" guid "PGUIDFMT") @ %p\n", tdur, PGUID (e->guid), (void *) l);
l->tdur = tdur;
l->tend = texpire;
l->tsched.v = TSCHED_NOT_ON_HEAP;
@ -118,7 +118,7 @@ struct lease *lease_new (nn_etime_t texpire, int64_t tdur, struct entity_common
void lease_register (struct lease *l)
{
DDS_TRACE("lease_register(l %p guid %x:%x:%x:%x)\n", (void *) l, PGUID (l->entity->guid));
DDS_TRACE("lease_register(l %p guid "PGUIDFMT")\n", (void *) l, PGUID (l->entity->guid));
ddsrt_mutex_lock (&gv.leaseheap_lock);
lock_lease (l);
assert (l->tsched.v == TSCHED_NOT_ON_HEAP);
@ -136,7 +136,7 @@ void lease_register (struct lease *l)
void lease_free (struct lease *l)
{
DDS_TRACE("lease_free(l %p guid %x:%x:%x:%x)\n", (void *) l, PGUID (l->entity->guid));
DDS_TRACE("lease_free(l %p guid "PGUIDFMT")\n", (void *) l, PGUID (l->entity->guid));
ddsrt_mutex_lock (&gv.leaseheap_lock);
if (l->tsched.v != TSCHED_NOT_ON_HEAP)
ddsrt_fibheap_delete (&lease_fhdef, &gv.leaseheap, l);
@ -167,9 +167,9 @@ void lease_renew (struct lease *l, nn_etime_t tnowE)
int32_t tsec, tusec;
DDS_TRACE(" L(");
if (l->entity->guid.entityid.u == NN_ENTITYID_PARTICIPANT)
DDS_TRACE(":%x", l->entity->guid.entityid.u);
DDS_TRACE(":%"PRIx32, l->entity->guid.entityid.u);
else
DDS_TRACE("%x:%x:%x:%x", PGUID (l->entity->guid));
DDS_TRACE(""PGUIDFMT"", PGUID (l->entity->guid));
etime_to_sec_usec (&tsec, &tusec, tend_new);
DDS_TRACE(" %"PRId32".%06"PRId32")", tsec, tusec);
}
@ -233,7 +233,7 @@ int64_t check_and_handle_lease_expiration (nn_etime_t tnowE)
continue;
}
DDS_LOG(DDS_LC_DISCOVERY, "lease expired: l %p guid %x:%x:%x:%x tend %"PRId64" < now %"PRId64"\n", (void *) l, PGUID (g), l->tend.v, tnowE.v);
DDS_LOG(DDS_LC_DISCOVERY, "lease expired: l %p guid "PGUIDFMT" tend %"PRId64" < now %"PRId64"\n", (void *) l, PGUID (g), l->tend.v, tnowE.v);
/* If the proxy participant is relying on another participant for
writing its discovery data (on the privileged participant,
@ -266,7 +266,7 @@ int64_t check_and_handle_lease_expiration (nn_etime_t tnowE)
if ((proxypp = ephash_lookup_proxy_participant_guid (&g)) != NULL &&
ephash_lookup_proxy_participant_guid (&proxypp->privileged_pp_guid) != NULL)
{
DDS_LOG(DDS_LC_DISCOVERY, "but postponing because privileged pp %x:%x:%x:%x is still live\n",
DDS_LOG(DDS_LC_DISCOVERY, "but postponing because privileged pp "PGUIDFMT" is still live\n",
PGUID (proxypp->privileged_pp_guid));
l->tsched = l->tend = add_duration_to_etime (tnowE, 200 * T_MILLISECOND);
unlock_lease (l);
@ -350,7 +350,7 @@ void handle_PMD (UNUSED_ARG (const struct receiver_state *rst), nn_wctime_t time
nn_guid_prefix_t p = nn_ntoh_guid_prefix (pmd->participantGuidPrefix);
unsigned kind = ntohl (pmd->kind);
unsigned length = bswap ? bswap4u (pmd->length) : pmd->length;
DDS_TRACE(" pp %x:%x:%x kind %u data %u", p.u[0], p.u[1], p.u[2], kind, length);
DDS_TRACE(" pp %"PRIx32":%"PRIx32":%"PRIx32" kind %u data %u", p.u[0], p.u[1], p.u[2], kind, length);
if (len - sizeof (struct CDRHeader) - offsetof (ParticipantMessageData_t, value) < length)
debug_print_rawdata (" SHORT2", pmd->value, len - sizeof (struct CDRHeader) - offsetof (ParticipantMessageData_t, value));
else

6
src/core/ddsi/src/q_nwif.c
View file

@ -123,13 +123,13 @@ static int set_rcvbuf (ddsrt_socket_t socket)
{
/* NN_ERROR does more than just DDS_ERROR(), hence the duplication */
if (config.socket_min_rcvbuf_size.isdefault)
DDS_LOG(DDS_LC_CONFIG, "failed to increase socket receive buffer size to %u bytes, continuing with %u bytes\n", socket_min_rcvbuf_size, ReceiveBufferSize);
DDS_LOG(DDS_LC_CONFIG, "failed to increase socket receive buffer size to %"PRIu32" bytes, continuing with %"PRIu32" bytes\n", socket_min_rcvbuf_size, ReceiveBufferSize);
else
DDS_ERROR("failed to increase socket receive buffer size to %u bytes, continuing with %u bytes\n", socket_min_rcvbuf_size, ReceiveBufferSize);
DDS_ERROR("failed to increase socket receive buffer size to %"PRIu32" bytes, continuing with %"PRIu32" bytes\n", socket_min_rcvbuf_size, ReceiveBufferSize);
}
else
{
DDS_LOG(DDS_LC_CONFIG, "socket receive buffer size set to %u bytes\n", ReceiveBufferSize);
DDS_LOG(DDS_LC_CONFIG, "socket receive buffer size set to %"PRIu32" bytes\n", ReceiveBufferSize);
}
}
return 0;

44
src/core/ddsi/src/q_plist.c
View file

@ -257,7 +257,7 @@ static int alias_stringseq (nn_stringseq_t *strseq, const struct dd *dd)
seq += sizeof (uint32_t);
if (strseq->n >= UINT_MAX / sizeof(*strs))
{
DDS_TRACE("plist/alias_stringseq: length %u out of range\n", strseq->n);
DDS_TRACE("plist/alias_stringseq: length %"PRIu32" out of range\n", strseq->n);
return Q_ERR_INVALID;
}
else if (strseq->n == 0)
@ -1185,7 +1185,7 @@ static int valid_participant_guid (const nn_guid_t *g, UNUSED_ARG (const struct
return 0;
else
{
DDS_TRACE("plist/valid_participant_guid: prefix is 0 but entityid is not (%u)\n", g->entityid.u);
DDS_TRACE("plist/valid_participant_guid: prefix is 0 but entityid is not (%"PRIu32")\n", g->entityid.u);
return Q_ERR_INVALID;
}
}
@ -1195,7 +1195,7 @@ static int valid_participant_guid (const nn_guid_t *g, UNUSED_ARG (const struct
}
else
{
DDS_TRACE("plist/valid_participant_guid: entityid not a participant entityid (%u)\n", g->entityid.u);
DDS_TRACE("plist/valid_participant_guid: entityid not a participant entityid (%"PRIu32")\n", g->entityid.u);
return Q_ERR_INVALID;
}
}
@ -1209,7 +1209,7 @@ static int valid_group_guid (const nn_guid_t *g, UNUSED_ARG (const struct dd *dd
return 0;
else
{
DDS_TRACE("plist/valid_group_guid: prefix is 0 but entityid is not (%u)\n", g->entityid.u);
DDS_TRACE("plist/valid_group_guid: prefix is 0 but entityid is not (%"PRIu32")\n", g->entityid.u);
return Q_ERR_INVALID;
}
}
@ -1234,7 +1234,7 @@ static int valid_endpoint_guid (const nn_guid_t *g, const struct dd *dd)
return 0;
else
{
DDS_TRACE("plist/valid_endpoint_guid: prefix is 0 but entityid is not (%x)\n", g->entityid.u);
DDS_TRACE("plist/valid_endpoint_guid: prefix is 0 but entityid is not (%"PRIx32")\n", g->entityid.u);
return Q_ERR_INVALID;
}
}
@ -1253,7 +1253,7 @@ static int valid_endpoint_guid (const nn_guid_t *g, const struct dd *dd)
return 0;
else
{
DDS_TRACE("plist/valid_endpoint_guid[src=USER,proto=%u.%u]: invalid kind (%x)\n",
DDS_TRACE("plist/valid_endpoint_guid[src=USER,proto=%u.%u]: invalid kind (%"PRIx32")\n",
dd->protocol_version.major, dd->protocol_version.minor,
g->entityid.u & NN_ENTITYID_KIND_MASK);
return Q_ERR_INVALID;
@ -1278,7 +1278,7 @@ static int valid_endpoint_guid (const nn_guid_t *g, const struct dd *dd)
return 0;
else
{
DDS_TRACE("plist/valid_endpoint_guid[src=BUILTIN,proto=%u.%u]: invalid entityid (%x)\n",
DDS_TRACE("plist/valid_endpoint_guid[src=BUILTIN,proto=%u.%u]: invalid entityid (%"PRIx32")\n",
dd->protocol_version.major, dd->protocol_version.minor, g->entityid.u);
return Q_ERR_INVALID;
}
@ -1302,14 +1302,14 @@ static int valid_endpoint_guid (const nn_guid_t *g, const struct dd *dd)
return 0;
else
{
DDS_TRACE("plist/valid_endpoint_guid[src=VENDOR,proto=%u.%u]: unexpected entityid (%x)\n",
DDS_TRACE("plist/valid_endpoint_guid[src=VENDOR,proto=%u.%u]: unexpected entityid (%"PRIx32")\n",
dd->protocol_version.major, dd->protocol_version.minor, g->entityid.u);
return 0;
}
}
}
default:
DDS_TRACE("plist/valid_endpoint_guid: invalid source (%x)\n", g->entityid.u);
DDS_TRACE("plist/valid_endpoint_guid: invalid source (%"PRIx32")\n", g->entityid.u);
return Q_ERR_INVALID;
}
}
@ -1329,7 +1329,7 @@ static int do_guid (nn_guid_t *dst, uint64_t *present, uint64_t fl, int (*valid)
that has long since changed (even if I don't know exactly when) */
if (fl == PP_PARTICIPANT_GUID && vendor_is_twinoaks (dd->vendorid) && dst->entityid.u == 0 && ! NN_STRICT_P)
{
DDS_LOG(DDS_LC_DISCOVERY, "plist(vendor %u.%u): rewriting invalid participant guid %x:%x:%x:%x\n",
DDS_LOG(DDS_LC_DISCOVERY, "plist(vendor %u.%u): rewriting invalid participant guid "PGUIDFMT,
dd->vendorid.id[0], dd->vendorid.id[1], PGUID (*dst));
dst->entityid.u = NN_ENTITYID_PARTICIPANT;
}
@ -2122,9 +2122,9 @@ static int init_one_parameter
dest->aliased |= PP_PRISMTECH_EOTINFO;
if (dds_get_log_mask() & DDS_LC_PLIST)
{
DDS_LOG(DDS_LC_PLIST, "eotinfo: txn %u {", q->transactionId);
DDS_LOG(DDS_LC_PLIST, "eotinfo: txn %"PRIu32" {", q->transactionId);
for (i = 0; i < q->n; i++)
DDS_LOG(DDS_LC_PLIST, " %x:%u", q->tids[i].writer_entityid.u, q->tids[i].transactionId);
DDS_LOG(DDS_LC_PLIST, " %"PRIx32":%"PRIu32, q->tids[i].writer_entityid.u, q->tids[i].transactionId);
DDS_LOG(DDS_LC_PLIST, " }\n");
}
return 0;
@ -3421,12 +3421,12 @@ void nn_log_xqos (uint32_t cat, const nn_xqos_t *xqos)
DDS_LOG(cat, "}");
});
DO (GROUP_DATA, {
LOGB1 ("group_data=%u<", xqos->group_data.length);
LOGB1 ("group_data=%"PRIu32"<", xqos->group_data.length);
log_octetseq (cat, xqos->group_data.length, xqos->group_data.value);
DDS_LOG(cat, ">");
});
DO (TOPIC_DATA, {
LOGB1 ("topic_data=%u<", xqos->topic_data.length);
LOGB1 ("topic_data=%"PRIu32"<", xqos->topic_data.length);
log_octetseq (cat, xqos->topic_data.length, xqos->topic_data.value);
DDS_LOG(cat, ">");
});
@ -3434,25 +3434,25 @@ void nn_log_xqos (uint32_t cat, const nn_xqos_t *xqos)
DO (DURABILITY_SERVICE, {
LOGB0 ("durability_service=");
DDS_LOG(cat, FMT_DUR, PRINTARG_DUR (xqos->durability_service.service_cleanup_delay));
DDS_LOG(cat, ":{%d:%d}", xqos->durability_service.history.kind, xqos->durability_service.history.depth);
DDS_LOG(cat, ":{%d:%d:%d}", xqos->durability_service.resource_limits.max_samples, xqos->durability_service.resource_limits.max_instances, xqos->durability_service.resource_limits.max_samples_per_instance);
DDS_LOG(cat, ":{%u:%"PRId32"}", xqos->durability_service.history.kind, xqos->durability_service.history.depth);
DDS_LOG(cat, ":{%"PRId32":%"PRId32":%"PRId32"}", xqos->durability_service.resource_limits.max_samples, xqos->durability_service.resource_limits.max_instances, xqos->durability_service.resource_limits.max_samples_per_instance);
});
DO (DEADLINE, { LOGB1 ("deadline="FMT_DUR, PRINTARG_DUR (xqos->deadline.deadline)); });
DO (LATENCY_BUDGET, { LOGB1 ("latency_budget="FMT_DUR, PRINTARG_DUR (xqos->latency_budget.duration)); });
DO (LIVELINESS, { LOGB2 ("liveliness=%d:"FMT_DUR, xqos->liveliness.kind, PRINTARG_DUR (xqos->liveliness.lease_duration)); });
DO (RELIABILITY, { LOGB2 ("reliability=%d:"FMT_DUR, xqos->reliability.kind, PRINTARG_DUR (xqos->reliability.max_blocking_time)); });
DO (DESTINATION_ORDER, { LOGB1 ("destination_order=%d", xqos->destination_order.kind); });
DO (HISTORY, { LOGB2 ("history=%d:%d", xqos->history.kind, xqos->history.depth); });
DO (RESOURCE_LIMITS, { LOGB3 ("resource_limits=%d:%d:%d", xqos->resource_limits.max_samples, xqos->resource_limits.max_instances, xqos->resource_limits.max_samples_per_instance); });
DO (TRANSPORT_PRIORITY, { LOGB1 ("transport_priority=%d", xqos->transport_priority.value); });
DO (HISTORY, { LOGB2 ("history=%d:%"PRId32, xqos->history.kind, xqos->history.depth); });
DO (RESOURCE_LIMITS, { LOGB3 ("resource_limits=%"PRId32":%"PRId32":%"PRId32, xqos->resource_limits.max_samples, xqos->resource_limits.max_instances, xqos->resource_limits.max_samples_per_instance); });
DO (TRANSPORT_PRIORITY, { LOGB1 ("transport_priority=%"PRId32, xqos->transport_priority.value); });
DO (LIFESPAN, { LOGB1 ("lifespan="FMT_DUR, PRINTARG_DUR (xqos->lifespan.duration)); });
DO (USER_DATA, {
LOGB1 ("user_data=%u<", xqos->user_data.length);
LOGB1 ("user_data=%"PRIu32"<", xqos->user_data.length);
log_octetseq (cat, xqos->user_data.length, xqos->user_data.value);
DDS_LOG(cat, ">");
});
DO (OWNERSHIP, { LOGB1 ("ownership=%d", xqos->ownership.kind); });
DO (OWNERSHIP_STRENGTH, { LOGB1 ("ownership_strength=%d", xqos->ownership_strength.value); });
DO (OWNERSHIP_STRENGTH, { LOGB1 ("ownership_strength=%"PRId32, xqos->ownership_strength.value); });
DO (TIME_BASED_FILTER, { LOGB1 ("time_based_filter="FMT_DUR, PRINTARG_DUR (xqos->time_based_filter.minimum_separation)); });
DO (PRISMTECH_READER_DATA_LIFECYCLE, { LOGB5 ("reader_data_lifecycle="FMT_DUR":"FMT_DUR":%u:%u:%d", PRINTARG_DUR (xqos->reader_data_lifecycle.autopurge_nowriter_samples_delay), PRINTARG_DUR (xqos->reader_data_lifecycle.autopurge_disposed_samples_delay), xqos->reader_data_lifecycle.autopurge_dispose_all, xqos->reader_data_lifecycle.enable_invalid_samples, (int) xqos->reader_data_lifecycle.invalid_sample_visibility); });
DO (PRISMTECH_WRITER_DATA_LIFECYCLE, {
@ -3473,7 +3473,7 @@ void nn_log_xqos (uint32_t cat, const nn_xqos_t *xqos)
DO (PRISMTECH_ENTITY_FACTORY, { LOGB1 ("entity_factory=%u", xqos->entity_factory.autoenable_created_entities); });
DO (PRISMTECH_SYNCHRONOUS_ENDPOINT, { LOGB1 ("synchronous_endpoint=%u", xqos->synchronous_endpoint.value); });
DO (RTI_TYPECODE, {
LOGB1 ("rti_typecode=%u<", xqos->rti_typecode.length);
LOGB1 ("rti_typecode=%"PRIu32"<", xqos->rti_typecode.length);
log_octetseq (cat, xqos->rti_typecode.length, xqos->rti_typecode.value);
DDS_LOG(cat, ">");
});

32
src/core/ddsi/src/q_radmin.c
View file

@ -484,7 +484,7 @@ static void *nn_rbuf_alloc (struct nn_rbufpool *rbufpool)
/* Note: only one thread calls nn_rmsg_new on a pool */
uint32_t asize = max_rmsg_size_w_hdr (rbufpool->max_rmsg_size);
struct nn_rbuf *rb;
DDS_LOG(DDS_LC_RADMIN, "rmsg_rbuf_alloc(%p, %u)\n", (void *) rbufpool, asize);
DDS_LOG(DDS_LC_RADMIN, "rmsg_rbuf_alloc(%p, %"PRIu32")\n", (void *) rbufpool, asize);
ASSERT_RBUFPOOL_OWNER (rbufpool);
rb = rbufpool->current;
assert (rb != NULL);
@ -501,7 +501,7 @@ static void *nn_rbuf_alloc (struct nn_rbufpool *rbufpool)
assert ((uint32_t) (rb->u.raw + rb->size - rb->freeptr) >= asize);
}
DDS_LOG(DDS_LC_RADMIN, "rmsg_rbuf_alloc(%p, %u) = %p\n", (void *) rbufpool, asize, (void *) rb->freeptr);
DDS_LOG(DDS_LC_RADMIN, "rmsg_rbuf_alloc(%p, %"PRIu32") = %p\n", (void *) rbufpool, asize, (void *) rb->freeptr);
#if USE_VALGRIND
VALGRIND_MEMPOOL_ALLOC (rbufpool, rb->freeptr, asize);
#endif
@ -540,7 +540,7 @@ struct nn_rmsg *nn_rmsg_new (struct nn_rbufpool *rbufpool)
void nn_rmsg_setsize (struct nn_rmsg *rmsg, uint32_t size)
{
uint32_t size8 = align8uint32 (size);
DDS_LOG(DDS_LC_RADMIN, "rmsg_setsize(%p, %u => %u)\n", (void *) rmsg, size, size8);
DDS_LOG(DDS_LC_RADMIN, "rmsg_setsize(%p, %"PRIu32" => %"PRIu32")\n", (void *) rmsg, size, size8);
ASSERT_RBUFPOOL_OWNER (rmsg->chunk.rbuf->rbufpool);
ASSERT_RMSG_UNCOMMITTED (rmsg);
assert (ddsrt_atomic_ld32 (&rmsg->refcount) == RMSG_REFCOUNT_UNCOMMITTED_BIAS);
@ -601,7 +601,7 @@ void nn_rmsg_commit (struct nn_rmsg *rmsg)
happens to be such that any asynchronous activities have
completed before we got to commit. */
struct nn_rmsg_chunk *chunk = rmsg->lastchunk;
DDS_LOG(DDS_LC_RADMIN, "rmsg_commit(%p) refcount 0x%x last-chunk-size %u\n",
DDS_LOG(DDS_LC_RADMIN, "rmsg_commit(%p) refcount 0x%"PRIx32" last-chunk-size %"PRIu32"\n",
(void *) rmsg, rmsg->refcount.v, chunk->size);
ASSERT_RBUFPOOL_OWNER (chunk->rbuf->rbufpool);
ASSERT_RMSG_UNCOMMITTED (rmsg);
@ -665,7 +665,7 @@ void *nn_rmsg_alloc (struct nn_rmsg *rmsg, uint32_t size)
struct nn_rbuf *rbuf = chunk->rbuf;
uint32_t size8 = align8uint32 (size);
void *ptr;
DDS_LOG(DDS_LC_RADMIN, "rmsg_alloc(%p, %u => %u)\n", (void *) rmsg, size, size8);
DDS_LOG(DDS_LC_RADMIN, "rmsg_alloc(%p, %"PRIu32" => %"PRIu32")\n", (void *) rmsg, size, size8);
ASSERT_RBUFPOOL_OWNER (rbuf->rbufpool);
ASSERT_RMSG_UNCOMMITTED (rmsg);
assert ((chunk->size % 8) == 0);
@ -675,12 +675,12 @@ void *nn_rmsg_alloc (struct nn_rmsg *rmsg, uint32_t size)
{
struct nn_rbufpool *rbufpool = rbuf->rbufpool;
struct nn_rmsg_chunk *newchunk;
DDS_LOG(DDS_LC_RADMIN, "rmsg_alloc(%p, %u) limit hit - new chunk\n", (void *) rmsg, size);
DDS_LOG(DDS_LC_RADMIN, "rmsg_alloc(%p, %"PRIu32") limit hit - new chunk\n", (void *) rmsg, size);
commit_rmsg_chunk (chunk);
newchunk = nn_rbuf_alloc (rbufpool);
if (newchunk == NULL)
{
DDS_WARNING ("nn_rmsg_alloc: can't allocate more memory (%u bytes) ... giving up\n", size);
DDS_WARNING ("nn_rmsg_alloc: can't allocate more memory (%"PRIu32" bytes) ... giving up\n", size);
return NULL;
}
init_rmsg_chunk (newchunk, rbufpool->current);
@ -690,7 +690,7 @@ void *nn_rmsg_alloc (struct nn_rmsg *rmsg, uint32_t size)
ptr = chunk->u.payload + chunk->size;
chunk->size += size8;
DDS_LOG(DDS_LC_RADMIN, "rmsg_alloc(%p, %u) = %p\n", (void *) rmsg, size, ptr);
DDS_LOG(DDS_LC_RADMIN, "rmsg_alloc(%p, %"PRIu32") = %p\n", (void *) rmsg, size, ptr);
#if USE_VALGRIND
if (chunk == &rmsg->chunk) {
VALGRIND_MEMPOOL_CHANGE (rbuf->rbufpool, rmsg, rmsg, offsetof (struct nn_rmsg, chunk.u.payload) + chunk->size);
@ -717,7 +717,7 @@ struct nn_rdata *nn_rdata_new (struct nn_rmsg *rmsg, uint32_t start, uint32_t en
#ifndef NDEBUG
ddsrt_atomic_st32 (&d->refcount_bias_added, 0);
#endif
DDS_LOG(DDS_LC_RADMIN, "rdata_new(%p, bytes [%u,%u), submsg @ %u, payload @ %u) = %p\n", (void *) rmsg, start, endp1, NN_RDATA_SUBMSG_OFF (d), NN_RDATA_PAYLOAD_OFF (d), (void *) d);
DDS_LOG(DDS_LC_RADMIN, "rdata_new(%p, bytes [%"PRIu32",%"PRIu32"), submsg @ %u, payload @ %u) = %p\n", (void *) rmsg, start, endp1, NN_RDATA_SUBMSG_OFF (d), NN_RDATA_PAYLOAD_OFF (d), (void *) d);
return d;
}
@ -931,7 +931,7 @@ static int defrag_try_merge_with_succ (struct nn_rsample_defrag *sample, struct
{
struct nn_defrag_iv *succ;
DDS_LOG(DDS_LC_RADMIN, " defrag_try_merge_with_succ(%p [%u..%u)):\n",
DDS_LOG(DDS_LC_RADMIN, " defrag_try_merge_with_succ(%p [%"PRIu32"..%"PRIu32")):\n",
(void *) node, node->min, node->maxp1);
if (node == sample->lastfrag)
{
@ -942,7 +942,7 @@ static int defrag_try_merge_with_succ (struct nn_rsample_defrag *sample, struct
succ = ddsrt_avl_find_succ (&rsample_defrag_fragtree_treedef, &sample->fragtree, node);
assert (succ != NULL);
DDS_LOG(DDS_LC_RADMIN, " succ is %p [%u..%u)\n", (void *) succ, succ->min, succ->maxp1);
DDS_LOG(DDS_LC_RADMIN, " succ is %p [%"PRIu32"..%"PRIu32")\n", (void *) succ, succ->min, succ->maxp1);
if (succ->min > node->maxp1)
{
DDS_LOG(DDS_LC_RADMIN, " gap between node and succ\n");
@ -1147,7 +1147,7 @@ static struct nn_rsample *defrag_add_fragment (struct nn_rsample *sample, struct
/* relatively expensive test: lastfrag, tree must be consistent */
assert (dfsample->lastfrag == ddsrt_avl_find_max (&rsample_defrag_fragtree_treedef, &dfsample->fragtree));
DDS_LOG(DDS_LC_RADMIN, " lastfrag %p [%u..%u)\n",
DDS_LOG(DDS_LC_RADMIN, " lastfrag %p [%"PRIu32"..%"PRIu32")\n",
(void *) dfsample->lastfrag,
dfsample->lastfrag->min, dfsample->lastfrag->maxp1);
@ -1164,7 +1164,7 @@ static struct nn_rsample *defrag_add_fragment (struct nn_rsample *sample, struct
/* Slow path: find preceding fragment by tree search */
predeq = ddsrt_avl_lookup_pred_eq (&rsample_defrag_fragtree_treedef, &dfsample->fragtree, &min);
assert (predeq);
DDS_LOG(DDS_LC_RADMIN, " slow path: predeq = lookup %u => %p [%u..%u)\n",
DDS_LOG(DDS_LC_RADMIN, " slow path: predeq = lookup %"PRIu32" => %p [%"PRIu32"..%"PRIu32")\n",
min, (void *) predeq, predeq->min, predeq->maxp1);
}
@ -1213,7 +1213,7 @@ static struct nn_rsample *defrag_add_fragment (struct nn_rsample *sample, struct
fragment in the chain adds value); but doesn't overlap with
predeq so the tree structure doesn't change even though the key
does change */
DDS_LOG(DDS_LC_RADMIN, " extending succ %p [%u..%u) at head\n",
DDS_LOG(DDS_LC_RADMIN, " extending succ %p [%"PRIu32"..%"PRIu32") at head\n",
(void *) succ, succ->min, succ->maxp1);
nn_rdata_addbias (rdata);
rdata->nextfrag = succ->first;
@ -1336,7 +1336,7 @@ struct nn_rsample *nn_defrag_rsample (struct nn_defrag *defrag, struct nn_rdata
consistent. Max_sample must be consistent with tree */
assert (defrag->max_sample == ddsrt_avl_find_max (&defrag_sampletree_treedef, &defrag->sampletree));
max_seq = defrag->max_sample ? defrag->max_sample->u.defrag.seq : 0;
DDS_LOG(DDS_LC_RADMIN, "defrag_rsample(%p, %p [%u..%u) msg %p, %p seq %"PRId64" size %u) max_seq %p %"PRId64":\n",
DDS_LOG(DDS_LC_RADMIN, "defrag_rsample(%p, %p [%"PRIu32"..%"PRIu32") msg %p, %p seq %"PRId64" size %"PRIu32") max_seq %p %"PRId64":\n",
(void *) defrag, (void *) rdata, rdata->min, rdata->maxp1, (void *) rdata->rmsg,
(void *) sampleinfo, sampleinfo->seq, sampleinfo->size,
(void *) defrag->max_sample, max_seq);
@ -2230,7 +2230,7 @@ nn_reorder_result_t nn_reorder_gap (struct nn_rsample_chain *sc, struct nn_reord
}
else if (coalesced->u.reorder.min <= reorder->next_seq)
{
DDS_LOG(DDS_LC_RADMIN, " coalesced = [%"PRId64",%"PRId64") @ %p containing %d samples\n",
DDS_LOG(DDS_LC_RADMIN, " coalesced = [%"PRId64",%"PRId64") @ %p containing %"PRId32" samples\n",
coalesced->u.reorder.min, coalesced->u.reorder.maxp1,
(void *) coalesced, coalesced->u.reorder.n_samples);
ddsrt_avl_delete (&reorder_sampleivtree_treedef, &reorder->sampleivtree, coalesced);

120
src/core/ddsi/src/q_receive.c
View file

@ -93,7 +93,7 @@ static void maybe_set_reader_in_sync (struct proxy_writer *pwr, struct pwr_rd_ma
case PRMSS_OUT_OF_SYNC:
if (nn_reorder_next_seq (wn->u.not_in_sync.reorder) - 1 >= wn->u.not_in_sync.end_of_out_of_sync_seq)
{
DDS_TRACE(" msr_in_sync(%x:%x:%x:%x out-of-sync to tlcatchup)", PGUID (wn->rd_guid));
DDS_TRACE(" msr_in_sync("PGUIDFMT" out-of-sync to tlcatchup)", PGUID (wn->rd_guid));
wn->in_sync = PRMSS_TLCATCHUP;
maybe_set_reader_in_sync (pwr, wn, last_deliv_seq);
}
@ -627,14 +627,14 @@ static void force_heartbeat_to_peer (struct writer *wr, const struct whc_state *
}
add_Gap (m, wr, prd, seq, seq+1, 1, &bits);
add_Heartbeat (m, wr, whcst, hbansreq, prd->e.guid.entityid, 1);
DDS_TRACE("force_heartbeat_to_peer: %x:%x:%x:%x -> %x:%x:%x:%x - whc empty, queueing gap #%"PRId64" + heartbeat for transmit\n",
DDS_TRACE("force_heartbeat_to_peer: "PGUIDFMT" -> "PGUIDFMT" - whc empty, queueing gap #%"PRId64" + heartbeat for transmit\n",
PGUID (wr->e.guid), PGUID (prd->e.guid), seq);
}
else
{
/* Send a Heartbeat just to this peer */
add_Heartbeat (m, wr, whcst, hbansreq, prd->e.guid.entityid, 0);
DDS_TRACE("force_heartbeat_to_peer: %x:%x:%x:%x -> %x:%x:%x:%x - queue for transmit\n",
DDS_TRACE("force_heartbeat_to_peer: "PGUIDFMT" -> "PGUIDFMT" - queue for transmit\n",
PGUID (wr->e.guid), PGUID (prd->e.guid));
}
qxev_msg (wr->evq, m);
@ -729,7 +729,7 @@ static int handle_AckNack (struct receiver_state *rst, nn_etime_t tnow, const Ac
src.entityid = msg->readerId;
dst.prefix = rst->dst_guid_prefix;
dst.entityid = msg->writerId;
DDS_TRACE("ACKNACK(%s#%d:%"PRId64"/%u:", msg->smhdr.flags & ACKNACK_FLAG_FINAL ? "F" : "",
DDS_TRACE("ACKNACK(%s#%"PRId32":%"PRId64"/%"PRIu32":", msg->smhdr.flags & ACKNACK_FLAG_FINAL ? "F" : "",
*countp, fromSN (msg->readerSNState.bitmap_base), msg->readerSNState.numbits);
for (i = 0; i < msg->readerSNState.numbits; i++)
DDS_TRACE("%c", nn_bitset_isset (msg->readerSNState.numbits, msg->readerSNState.bits, i) ? '1' : '0');
@ -737,13 +737,13 @@ static int handle_AckNack (struct receiver_state *rst, nn_etime_t tnow, const Ac
if (!rst->forme)
{
DDS_TRACE(" %x:%x:%x:%x -> %x:%x:%x:%x not-for-me)", PGUID (src), PGUID (dst));
DDS_TRACE(" "PGUIDFMT" -> "PGUIDFMT" not-for-me)", PGUID (src), PGUID (dst));
return 1;
}
if ((wr = ephash_lookup_writer_guid (&dst)) == NULL)
{
DDS_TRACE(" %x:%x:%x:%x -> %x:%x:%x:%x?)", PGUID (src), PGUID (dst));
DDS_TRACE(" "PGUIDFMT" -> "PGUIDFMT"?)", PGUID (src), PGUID (dst));
return 1;
}
/* Always look up the proxy reader -- even though we don't need for
@ -752,7 +752,7 @@ static int handle_AckNack (struct receiver_state *rst, nn_etime_t tnow, const Ac
only retrieve it when needed. */
if ((prd = ephash_lookup_proxy_reader_guid (&src)) == NULL)
{
DDS_TRACE(" %x:%x:%x:%x? -> %x:%x:%x:%x)", PGUID (src), PGUID (dst));
DDS_TRACE(" "PGUIDFMT"? -> "PGUIDFMT")", PGUID (src), PGUID (dst));
return 1;
}
@ -762,14 +762,14 @@ static int handle_AckNack (struct receiver_state *rst, nn_etime_t tnow, const Ac
if (!wr->reliable) /* note: reliability can't be changed */
{
DDS_TRACE(" %x:%x:%x:%x -> %x:%x:%x:%x not a reliable writer!)", PGUID (src), PGUID (dst));
DDS_TRACE(" "PGUIDFMT" -> "PGUIDFMT" not a reliable writer!)", PGUID (src), PGUID (dst));
return 1;
}
ddsrt_mutex_lock (&wr->e.lock);
if ((rn = ddsrt_avl_lookup (&wr_readers_treedef, &wr->readers, &src)) == NULL)
{
DDS_TRACE(" %x:%x:%x:%x -> %x:%x:%x:%x not a connection)", PGUID (src), PGUID (dst));
DDS_TRACE(" "PGUIDFMT" -> "PGUIDFMT" not a connection)", PGUID (src), PGUID (dst));
goto out;
}
@ -789,10 +789,10 @@ static int handle_AckNack (struct receiver_state *rst, nn_etime_t tnow, const Ac
if (!accept_ack_or_hb_w_timeout (*countp, &rn->next_acknack, tnow, &rn->t_acknack_accepted, is_preemptive_ack))
{
DDS_TRACE(" [%x:%x:%x:%x -> %x:%x:%x:%x])", PGUID (src), PGUID (dst));
DDS_TRACE(" ["PGUIDFMT" -> "PGUIDFMT"])", PGUID (src), PGUID (dst));
goto out;
}
DDS_TRACE(" %x:%x:%x:%x -> %x:%x:%x:%x", PGUID (src), PGUID (dst));
DDS_TRACE(" "PGUIDFMT" -> "PGUIDFMT"", PGUID (src), PGUID (dst));
/* Update latency estimates if we have a timestamp -- won't actually
work so well if the timestamp can be a left over from some other
@ -851,7 +851,7 @@ static int handle_AckNack (struct receiver_state *rst, nn_etime_t tnow, const Ac
rn->seq = wr->seq;
}
ddsrt_avl_augment_update (&wr_readers_treedef, rn);
DDS_LOG(DDS_LC_THROTTLE, "writer %x:%x:%x:%x considering reader %x:%x:%x:%x responsive again\n", PGUID (wr->e.guid), PGUID (rn->prd_guid));
DDS_LOG(DDS_LC_THROTTLE, "writer "PGUIDFMT" considering reader "PGUIDFMT" responsive again\n", PGUID (wr->e.guid), PGUID (rn->prd_guid));
}
/* Second, the NACK bits (literally, that is). To do so, attempt to
@ -1143,7 +1143,7 @@ static void handle_Heartbeat_helper (struct pwr_rd_match * const wn, struct hand
/* Not supposed to respond to repeats and old heartbeats. */
if (!accept_ack_or_hb_w_timeout (msg->count, &wn->next_heartbeat, arg->tnow, &wn->t_heartbeat_accepted, 0))
{
DDS_TRACE(" (%x:%x:%x:%x)", PGUID (wn->rd_guid));
DDS_TRACE(" ("PGUIDFMT")", PGUID (wn->rd_guid));
return;
}
@ -1154,7 +1154,7 @@ static void handle_Heartbeat_helper (struct pwr_rd_match * const wn, struct hand
refseq = nn_reorder_next_seq (pwr->reorder) - 1;
else
refseq = nn_reorder_next_seq (wn->u.not_in_sync.reorder) - 1;
DDS_TRACE(" %x:%x:%x:%x@%"PRId64"%s", PGUID (wn->rd_guid), refseq, (wn->in_sync == PRMSS_SYNC) ? "(sync)" : (wn->in_sync == PRMSS_TLCATCHUP) ? "(tlcatchup)" : "");
DDS_TRACE(" "PGUIDFMT"@%"PRId64"%s", PGUID (wn->rd_guid), refseq, (wn->in_sync == PRMSS_SYNC) ? "(sync)" : (wn->in_sync == PRMSS_TLCATCHUP) ? "(tlcatchup)" : "");
/* Reschedule AckNack transmit if deemed appropriate; unreliable
readers have acknack_xevent == NULL and can't do this.
@ -1214,17 +1214,17 @@ static int handle_Heartbeat (struct receiver_state *rst, nn_etime_t tnow, struct
dst.prefix = rst->dst_guid_prefix;
dst.entityid = msg->readerId;
DDS_TRACE("HEARTBEAT(%s#%d:%"PRId64"..%"PRId64" ", msg->smhdr.flags & HEARTBEAT_FLAG_FINAL ? "F" : "", msg->count, firstseq, lastseq);
DDS_TRACE("HEARTBEAT(%s#%"PRId32":%"PRId64"..%"PRId64" ", msg->smhdr.flags & HEARTBEAT_FLAG_FINAL ? "F" : "", msg->count, firstseq, lastseq);
if (!rst->forme)
{
DDS_TRACE("%x:%x:%x:%x -> %x:%x:%x:%x not-for-me)", PGUID (src), PGUID (dst));
DDS_TRACE(""PGUIDFMT" -> "PGUIDFMT" not-for-me)", PGUID (src), PGUID (dst));
return 1;
}
if ((pwr = ephash_lookup_proxy_writer_guid (&src)) == NULL)
{
DDS_TRACE("%x:%x:%x:%x? -> %x:%x:%x:%x)", PGUID (src), PGUID (dst));
DDS_TRACE(""PGUIDFMT"? -> "PGUIDFMT")", PGUID (src), PGUID (dst));
return 1;
}
@ -1232,7 +1232,7 @@ static int handle_Heartbeat (struct receiver_state *rst, nn_etime_t tnow, struct
if (pwr->assert_pp_lease)
lease_renew (ddsrt_atomic_ldvoidp (&pwr->c.proxypp->lease), tnow);
DDS_TRACE("%x:%x:%x:%x -> %x:%x:%x:%x:", PGUID (src), PGUID (dst));
DDS_TRACE(""PGUIDFMT" -> "PGUIDFMT":", PGUID (src), PGUID (dst));
ddsrt_mutex_lock (&pwr->e.lock);
@ -1311,7 +1311,7 @@ static int handle_Heartbeat (struct receiver_state *rst, nn_etime_t tnow, struct
if (wn->u.not_in_sync.end_of_tl_seq == MAX_SEQ_NUMBER)
{
wn->u.not_in_sync.end_of_out_of_sync_seq = wn->u.not_in_sync.end_of_tl_seq = fromSN (msg->lastSN);
DDS_TRACE(" end-of-tl-seq(rd %x:%x:%x:%x #%"PRId64")", PGUID(wn->rd_guid), wn->u.not_in_sync.end_of_tl_seq);
DDS_TRACE(" end-of-tl-seq(rd "PGUIDFMT" #%"PRId64")", PGUID(wn->rd_guid), wn->u.not_in_sync.end_of_tl_seq);
}
maybe_set_reader_in_sync (pwr, wn, last_deliv_seq);
}
@ -1343,16 +1343,16 @@ static int handle_HeartbeatFrag (struct receiver_state *rst, UNUSED_ARG(nn_etime
dst.prefix = rst->dst_guid_prefix;
dst.entityid = msg->readerId;
DDS_TRACE("HEARTBEATFRAG(#%d:%"PRId64"/[1,%u]", msg->count, seq, fragnum+1);
DDS_TRACE("HEARTBEATFRAG(#%"PRId32":%"PRId64"/[1,%u]", msg->count, seq, fragnum+1);
if (!rst->forme)
{
DDS_TRACE(" %x:%x:%x:%x -> %x:%x:%x:%x not-for-me)", PGUID (src), PGUID (dst));
DDS_TRACE(" "PGUIDFMT" -> "PGUIDFMT" not-for-me)", PGUID (src), PGUID (dst));
return 1;
}
if ((pwr = ephash_lookup_proxy_writer_guid (&src)) == NULL)
{
DDS_TRACE(" %x:%x:%x:%x? -> %x:%x:%x:%x)", PGUID (src), PGUID (dst));
DDS_TRACE(" "PGUIDFMT"? -> "PGUIDFMT")", PGUID (src), PGUID (dst));
return 1;
}
@ -1360,7 +1360,7 @@ static int handle_HeartbeatFrag (struct receiver_state *rst, UNUSED_ARG(nn_etime
if (pwr->assert_pp_lease)
lease_renew (ddsrt_atomic_ldvoidp (&pwr->c.proxypp->lease), tnow);
DDS_TRACE(" %x:%x:%x:%x -> %x:%x:%x:%x", PGUID (src), PGUID (dst));
DDS_TRACE(" "PGUIDFMT" -> "PGUIDFMT"", PGUID (src), PGUID (dst));
ddsrt_mutex_lock (&pwr->e.lock);
if (seq > pwr->last_seq)
@ -1459,19 +1459,19 @@ static int handle_NackFrag (struct receiver_state *rst, nn_etime_t tnow, const N
dst.prefix = rst->dst_guid_prefix;
dst.entityid = msg->writerId;
DDS_TRACE("NACKFRAG(#%d:%"PRId64"/%u/%u:", *countp, seq, msg->fragmentNumberState.bitmap_base, msg->fragmentNumberState.numbits);
DDS_TRACE("NACKFRAG(#%"PRId32":%"PRId64"/%u/%"PRIu32":", *countp, seq, msg->fragmentNumberState.bitmap_base, msg->fragmentNumberState.numbits);
for (i = 0; i < msg->fragmentNumberState.numbits; i++)
DDS_TRACE("%c", nn_bitset_isset (msg->fragmentNumberState.numbits, msg->fragmentNumberState.bits, i) ? '1' : '0');
if (!rst->forme)
{
DDS_TRACE(" %x:%x:%x:%x -> %x:%x:%x:%x not-for-me)", PGUID (src), PGUID (dst));
DDS_TRACE(" "PGUIDFMT" -> "PGUIDFMT" not-for-me)", PGUID (src), PGUID (dst));
return 1;
}
if ((wr = ephash_lookup_writer_guid (&dst)) == NULL)
{
DDS_TRACE(" %x:%x:%x:%x -> %x:%x:%x:%x?)", PGUID (src), PGUID (dst));
DDS_TRACE(" "PGUIDFMT" -> "PGUIDFMT"?)", PGUID (src), PGUID (dst));
return 1;
}
/* Always look up the proxy reader -- even though we don't need for
@ -1480,7 +1480,7 @@ static int handle_NackFrag (struct receiver_state *rst, nn_etime_t tnow, const N
only retrieve it when needed. */
if ((prd = ephash_lookup_proxy_reader_guid (&src)) == NULL)
{
DDS_TRACE(" %x:%x:%x:%x? -> %x:%x:%x:%x)", PGUID (src), PGUID (dst));
DDS_TRACE(" "PGUIDFMT"? -> "PGUIDFMT")", PGUID (src), PGUID (dst));
return 1;
}
@ -1490,25 +1490,25 @@ static int handle_NackFrag (struct receiver_state *rst, nn_etime_t tnow, const N
if (!wr->reliable) /* note: reliability can't be changed */
{
DDS_TRACE(" %x:%x:%x:%x -> %x:%x:%x:%x not a reliable writer)", PGUID (src), PGUID (dst));
DDS_TRACE(" "PGUIDFMT" -> "PGUIDFMT" not a reliable writer)", PGUID (src), PGUID (dst));
return 1;
}
ddsrt_mutex_lock (&wr->e.lock);
if ((rn = ddsrt_avl_lookup (&wr_readers_treedef, &wr->readers, &src)) == NULL)
{
DDS_TRACE(" %x:%x:%x:%x -> %x:%x:%x:%x not a connection", PGUID (src), PGUID (dst));
DDS_TRACE(" "PGUIDFMT" -> "PGUIDFMT" not a connection", PGUID (src), PGUID (dst));
goto out;
}
/* Ignore old NackFrags (see also handle_AckNack) */
if (*countp < rn->next_nackfrag)
{
DDS_TRACE(" [%x:%x:%x:%x -> %x:%x:%x:%x]", PGUID (src), PGUID (dst));
DDS_TRACE(" ["PGUIDFMT" -> "PGUIDFMT"]", PGUID (src), PGUID (dst));
goto out;
}
rn->next_nackfrag = *countp + 1;
DDS_TRACE(" %x:%x:%x:%x -> %x:%x:%x:%x", PGUID (src), PGUID (dst));
DDS_TRACE(" "PGUIDFMT" -> "PGUIDFMT"", PGUID (src), PGUID (dst));
/* Resend the requested fragments if we still have the sample, send
a Gap if we don't have them anymore. */
@ -1569,7 +1569,7 @@ static int handle_NackFrag (struct receiver_state *rst, nn_etime_t tnow, const N
static int handle_InfoDST (struct receiver_state *rst, const InfoDST_t *msg, const nn_guid_prefix_t *dst_prefix)
{
rst->dst_guid_prefix = nn_ntoh_guid_prefix (msg->guid_prefix);
DDS_TRACE("INFODST(%x:%x:%x)", PGUIDPREFIX (rst->dst_guid_prefix));
DDS_TRACE("INFODST(%"PRIx32":%"PRIx32":%"PRIx32")", PGUIDPREFIX (rst->dst_guid_prefix));
if (rst->dst_guid_prefix.u[0] == 0 && rst->dst_guid_prefix.u[1] == 0 && rst->dst_guid_prefix.u[2] == 0)
{
if (dst_prefix)
@ -1591,7 +1591,7 @@ static int handle_InfoSRC (struct receiver_state *rst, const InfoSRC_t *msg)
rst->src_guid_prefix = nn_ntoh_guid_prefix (msg->guid_prefix);
rst->protocol_version = msg->version;
rst->vendor = msg->vendorid;
DDS_TRACE("INFOSRC(%x:%x:%x vendor %u.%u)",
DDS_TRACE("INFOSRC(%"PRIx32":%"PRIx32":%"PRIx32" vendor %u.%u)",
PGUIDPREFIX (rst->src_guid_prefix), rst->vendor.id[0], rst->vendor.id[1]);
return 1;
}
@ -1710,7 +1710,7 @@ static int handle_Gap (struct receiver_state *rst, nn_etime_t tnow, struct nn_rm
dst.entityid = msg->readerId;
gapstart = fromSN (msg->gapStart);
listbase = fromSN (msg->gapList.bitmap_base);
DDS_TRACE("GAP(%"PRId64"..%"PRId64"/%u ", gapstart, listbase, msg->gapList.numbits);
DDS_TRACE("GAP(%"PRId64"..%"PRId64"/%"PRIu32" ", gapstart, listbase, msg->gapList.numbits);
/* There is no _good_ reason for a writer to start the bitmap with a
1 bit, but check for it just in case, to reduce the number of
@ -1722,13 +1722,13 @@ static int handle_Gap (struct receiver_state *rst, nn_etime_t tnow, struct nn_rm
if (!rst->forme)
{
DDS_TRACE("%x:%x:%x:%x -> %x:%x:%x:%x not-for-me)", PGUID (src), PGUID (dst));
DDS_TRACE(""PGUIDFMT" -> "PGUIDFMT" not-for-me)", PGUID (src), PGUID (dst));
return 1;
}
if ((pwr = ephash_lookup_proxy_writer_guid (&src)) == NULL)
{
DDS_TRACE("%x:%x:%x:%x? -> %x:%x:%x:%x)", PGUID (src), PGUID (dst));
DDS_TRACE(""PGUIDFMT"? -> "PGUIDFMT")", PGUID (src), PGUID (dst));
return 1;
}
@ -1739,11 +1739,11 @@ static int handle_Gap (struct receiver_state *rst, nn_etime_t tnow, struct nn_rm
ddsrt_mutex_lock (&pwr->e.lock);
if ((wn = ddsrt_avl_lookup (&pwr_readers_treedef, &pwr->readers, &dst)) == NULL)
{
DDS_TRACE("%x:%x:%x:%x -> %x:%x:%x:%x not a connection)", PGUID (src), PGUID (dst));
DDS_TRACE(PGUIDFMT" -> "PGUIDFMT" not a connection)", PGUID (src), PGUID (dst));
ddsrt_mutex_unlock (&pwr->e.lock);
return 1;
}
DDS_TRACE("%x:%x:%x:%x -> %x:%x:%x:%x", PGUID (src), PGUID (dst));
DDS_TRACE(PGUIDFMT" -> "PGUIDFMT, PGUID (src), PGUID (dst));
if (!pwr->have_seen_heartbeat && pwr->n_reliable_readers > 0)
{
@ -1831,8 +1831,8 @@ static struct ddsi_serdata *extract_sample_from_data
{
const struct proxy_writer *pwr = sampleinfo->pwr;
nn_guid_t guid = pwr ? pwr->e.guid : null_guid; /* can't be null _yet_, but that might change some day */
DDS_TRACE("data(application, vendor %u.%u): %x:%x:%x:%x #%"PRId64
": write without proper payload (data_smhdr_flags 0x%x size %u)\n",
DDS_TRACE("data(application, vendor %u.%u): "PGUIDFMT" #%"PRId64
": write without proper payload (data_smhdr_flags 0x%x size %"PRIu32")\n",
sampleinfo->rst->vendor.id[0], sampleinfo->rst->vendor.id[1],
PGUID (guid), sampleinfo->seq,
data_smhdr_flags, sampleinfo->size);
@ -1882,7 +1882,7 @@ static struct ddsi_serdata *extract_sample_from_data
nn_guid_t guid = pwr ? pwr->e.guid : null_guid; /* can't be null _yet_, but that might change some day */
DDS_WARNING
(
"data(application, vendor %u.%u): %x:%x:%x:%x #%"PRId64": deserialization %s/%s failed (%s)\n",
"data(application, vendor %u.%u): "PGUIDFMT" #%"PRId64": deserialization %s/%s failed (%s)\n",
sampleinfo->rst->vendor.id[0], sampleinfo->rst->vendor.id[1],
PGUID (guid), sampleinfo->seq,
topic->name, topic->type_name,
@ -1988,7 +1988,7 @@ static int deliver_user_data (const struct nn_rsample_info *sampleinfo, const st
if ((plist_ret = nn_plist_init_frommsg (&qos, NULL, PP_STATUSINFO | PP_KEYHASH | PP_COHERENT_SET | PP_PRISMTECH_EOTINFO, 0, &src)) < 0)
{
if (plist_ret != Q_ERR_INCOMPATIBLE)
DDS_WARNING ("data(application, vendor %u.%u): %x:%x:%x:%x #%"PRId64": invalid inline qos\n",
DDS_WARNING ("data(application, vendor %u.%u): "PGUIDFMT" #%"PRId64": invalid inline qos\n",
src.vendorid.id[0], src.vendorid.id[1], PGUID (pwr->e.guid), sampleinfo->seq);
return 0;
}
@ -2047,7 +2047,7 @@ retry:
unsigned i;
for (i = 0; rdary[i]; i++)
{
DDS_TRACE("reader %x:%x:%x:%x\n", PGUID (rdary[i]->e.guid));
DDS_TRACE("reader "PGUIDFMT"\n", PGUID (rdary[i]->e.guid));
if (! (ddsi_plugin.rhc_plugin.rhc_store_fn) (rdary[i]->rhc, &pwr_info, payload, tk))
{
if (pwr_locked) ddsrt_mutex_unlock (&pwr->e.lock);
@ -2078,7 +2078,7 @@ retry:
struct reader *rd;
if ((rd = ephash_lookup_reader_guid (&m->rd_guid)) != NULL)
{
DDS_TRACE("reader-via-guid %x:%x:%x:%x\n", PGUID (rd->e.guid));
DDS_TRACE("reader-via-guid "PGUIDFMT"\n", PGUID (rd->e.guid));
(void) (ddsi_plugin.rhc_plugin.rhc_store_fn) (rd->rhc, &pwr_info, payload, tk);
}
}
@ -2090,7 +2090,7 @@ retry:
else
{
struct reader *rd = ephash_lookup_reader_guid (rdguid);;
DDS_TRACE(" %"PRId64"=>%x:%x:%x:%x%s\n", sampleinfo->seq, PGUID (*rdguid), rd ? "" : "?");
DDS_TRACE(" %"PRId64"=>"PGUIDFMT"%s\n", sampleinfo->seq, PGUID (*rdguid), rd ? "" : "?");
while (rd && ! (ddsi_plugin.rhc_plugin.rhc_store_fn) (rd->rhc, &pwr_info, payload, tk) && ephash_lookup_proxy_writer_guid (&pwr->e.guid))
{
if (pwr_locked) ddsrt_mutex_unlock (&pwr->e.lock);
@ -2166,7 +2166,7 @@ static void handle_regular (struct receiver_state *rst, nn_etime_t tnow, struct
nn_guid_t src;
src.prefix = rst->src_guid_prefix;
src.entityid = msg->writerId;
DDS_TRACE(" %x:%x:%x:%x? -> %x:%x:%x:%x", PGUID (src), PGUID (dst));
DDS_TRACE(" "PGUIDFMT"? -> "PGUIDFMT, PGUID (src), PGUID (dst));
return;
}
@ -2195,14 +2195,14 @@ static void handle_regular (struct receiver_state *rst, nn_etime_t tnow, struct
if (!pwr->have_seen_heartbeat && pwr->n_reliable_readers > 0)
{
ddsrt_mutex_unlock (&pwr->e.lock);
DDS_TRACE(" %x:%x:%x:%x -> %x:%x:%x:%x: no heartbeat seen yet", PGUID (pwr->e.guid), PGUID (dst));
DDS_TRACE(" "PGUIDFMT" -> "PGUIDFMT": no heartbeat seen yet", PGUID (pwr->e.guid), PGUID (dst));
return;
}
if (ddsrt_avl_is_empty (&pwr->readers) || pwr->local_matching_inprogress)
{
ddsrt_mutex_unlock (&pwr->e.lock);
DDS_TRACE(" %x:%x:%x:%x -> %x:%x:%x:%x: no readers", PGUID (pwr->e.guid), PGUID (dst));
DDS_TRACE(" "PGUIDFMT" -> "PGUIDFMT": no readers", PGUID (pwr->e.guid), PGUID (dst));
return;
}
@ -2359,7 +2359,7 @@ static void drop_oversize (struct receiver_state *rst, struct nn_rmsg *rmsg, con
cause periodic warnings. */
if (msg->writerId.u == NN_ENTITYID_SPDP_BUILTIN_PARTICIPANT_WRITER)
{
DDS_WARNING ("dropping oversize (%u > %u) SPDP sample %"PRId64" from remote writer %x:%x:%x:%x\n",
DDS_WARNING ("dropping oversize (%"PRIu32" > %"PRIu32") SPDP sample %"PRId64" from remote writer "PGUIDFMT"\n",
sampleinfo->size, config.max_sample_size, sampleinfo->seq,
PGUIDPREFIX (rst->src_guid_prefix), msg->writerId.u);
}
@ -2389,7 +2389,7 @@ static void drop_oversize (struct receiver_state *rst, struct nn_rmsg *rmsg, con
{
const char *tname = pwr->c.topic ? pwr->c.topic->name : "(null)";
const char *ttname = pwr->c.topic ? pwr->c.topic->type_name : "(null)";
DDS_WARNING ("dropping oversize (%u > %u) sample %"PRId64" from remote writer %x:%x:%x:%x %s/%s\n",
DDS_WARNING ("dropping oversize (%"PRIu32" > %"PRIu32") sample %"PRId64" from remote writer "PGUIDFMT" %s/%s\n",
sampleinfo->size, config.max_sample_size, sampleinfo->seq,
PGUIDPREFIX (rst->src_guid_prefix), msg->writerId.u,
tname, ttname);
@ -2399,7 +2399,7 @@ static void drop_oversize (struct receiver_state *rst, struct nn_rmsg *rmsg, con
static int handle_Data (struct receiver_state *rst, nn_etime_t tnow, struct nn_rmsg *rmsg, const Data_t *msg, size_t size, struct nn_rsample_info *sampleinfo, unsigned char *datap, struct nn_dqueue **deferred_wakeup)
{
DDS_TRACE("DATA(%x:%x:%x:%x -> %x:%x:%x:%x #%"PRId64"",
DDS_TRACE("DATA("PGUIDFMT" -> "PGUIDFMT" #%"PRId64,
PGUIDPREFIX (rst->src_guid_prefix), msg->x.writerId.u,
PGUIDPREFIX (rst->dst_guid_prefix), msg->x.readerId.u,
fromSN (msg->x.writerSN));
@ -2443,7 +2443,7 @@ static int handle_Data (struct receiver_state *rst, nn_etime_t tnow, struct nn_r
static int handle_DataFrag (struct receiver_state *rst, nn_etime_t tnow, struct nn_rmsg *rmsg, const DataFrag_t *msg, size_t size, struct nn_rsample_info *sampleinfo, unsigned char *datap, struct nn_dqueue **deferred_wakeup)
{
DDS_TRACE("DATAFRAG(%x:%x:%x:%x -> %x:%x:%x:%x #%"PRId64"/[%u..%u]",
DDS_TRACE("DATAFRAG("PGUIDFMT" -> "PGUIDFMT" #%"PRId64"/[%u..%u]",
PGUIDPREFIX (rst->src_guid_prefix), msg->x.writerId.u,
PGUIDPREFIX (rst->dst_guid_prefix), msg->x.readerId.u,
fromSN (msg->x.writerSN),
@ -2463,7 +2463,7 @@ static int handle_DataFrag (struct receiver_state *rst, nn_etime_t tnow, struct
uint32_t begin, endp1;
if (msg->x.writerId.u == NN_ENTITYID_SPDP_BUILTIN_PARTICIPANT_WRITER)
{
DDS_WARNING ("DATAFRAG(%x:%x:%x:%x #%"PRId64" -> %x:%x:%x:%x) - fragmented builtin data not yet supported\n",
DDS_WARNING ("DATAFRAG("PGUIDFMT" #%"PRId64" -> "PGUIDFMT") - fragmented builtin data not yet supported\n",
PGUIDPREFIX (rst->src_guid_prefix), msg->x.writerId.u, fromSN (msg->x.writerSN),
PGUIDPREFIX (rst->dst_guid_prefix), msg->x.readerId.u);
return 1;
@ -2496,7 +2496,7 @@ static int handle_DataFrag (struct receiver_state *rst, nn_etime_t tnow, struct
here */
endp1 = msg->sampleSize;
}
DDS_TRACE("/[%u..%u) of %u", begin, endp1, msg->sampleSize);
DDS_TRACE("/[%"PRIu32"..%"PRIu32") of %"PRIu32, begin, endp1, msg->sampleSize);
rdata = nn_rdata_new (rmsg, begin, endp1, submsg_offset, payload_offset);
@ -2910,7 +2910,7 @@ static int handle_submsg_sequence
#endif /* DDSI_INCLUDE_ENCRYPTION */
break;
default:
DDS_TRACE("(unknown id %u?)\n", sm->pt_infocontainer.id);
DDS_TRACE("(unknown id %"PRIu32"?)\n", sm->pt_infocontainer.id);
}
}
break;
@ -2919,7 +2919,7 @@ static int handle_submsg_sequence
#if 0
state = "parse:msg_len";
#endif
DDS_TRACE("MSG_LEN(%u)", ((MsgLen_t*) sm)->length);
DDS_TRACE("MSG_LEN(%"PRIu32")", ((MsgLen_t*) sm)->length);
break;
}
case SMID_PT_ENTITY_ID:
@ -3086,7 +3086,7 @@ static bool do_packet
else if (hdr->version.major != RTPS_MAJOR || (hdr->version.major == RTPS_MAJOR && hdr->version.minor < RTPS_MINOR_MINIMUM))
{
if ((hdr->version.major == RTPS_MAJOR && hdr->version.minor < RTPS_MINOR_MINIMUM))
DDS_TRACE("HDR(%x:%x:%x vendor %d.%d) len %lu\n, version mismatch: %d.%d\n",
DDS_TRACE("HDR(%"PRIx32":%"PRIx32":%"PRIx32" vendor %d.%d) len %lu\n, version mismatch: %d.%d\n",
PGUIDPREFIX (hdr->guid_prefix), hdr->vendorid.id[0], hdr->vendorid.id[1], (unsigned long) sz, hdr->version.major, hdr->version.minor);
if (NN_PEDANTIC_P)
malformed_packet_received_nosubmsg (buff, sz, "header", hdr->vendorid);
@ -3099,7 +3099,7 @@ static bool do_packet
{
char addrstr[DDSI_LOCSTRLEN];
ddsi_locator_to_string(addrstr, sizeof(addrstr), &srcloc);
DDS_TRACE("HDR(%x:%x:%x vendor %d.%d) len %lu from %s\n",
DDS_TRACE("HDR(%"PRIx32":%"PRIx32":%"PRIx32" vendor %d.%d) len %lu from %s\n",
PGUIDPREFIX (hdr->guid_prefix), hdr->vendorid.id[0], hdr->vendorid.id[1], (unsigned long) sz, addrstr);
}
@ -3173,7 +3173,7 @@ static void rebuild_local_participant_set (struct thread_state1 * const ts1, str
struct ephash_enum_participant est;
struct participant *pp;
unsigned nps_alloc;
DDS_TRACE("pp set gen changed: local %u global %"PRIu32"\n", lps->gen, ddsrt_atomic_ld32(&gv.participant_set_generation));
DDS_TRACE("pp set gen changed: local %"PRIu32" global %"PRIu32"\n", lps->gen, ddsrt_atomic_ld32(&gv.participant_set_generation));
thread_state_awake (ts1);
restart:
lps->gen = ddsrt_atomic_ld32 (&gv.participant_set_generation);
@ -3201,7 +3201,7 @@ static void rebuild_local_participant_set (struct thread_state1 * const ts1, str
{
lps->ps[lps->nps].m_conn = pp->m_conn;
lps->ps[lps->nps].guid_prefix = pp->e.guid.prefix;
DDS_TRACE(" pp %x:%x:%x:%x handle %"PRIdSOCK"\n", PGUID (pp->e.guid), ddsi_conn_handle (pp->m_conn));
DDS_TRACE(" pp "PGUIDFMT" handle %"PRIdSOCK"\n", PGUID (pp->e.guid), ddsi_conn_handle (pp->m_conn));
lps->nps++;
}
}

2
src/core/ddsi/src/q_sockwaitset.c
View file

@ -873,7 +873,7 @@ os_sockWaitsetCtx os_sockWaitsetWait (os_sockWaitset ws)
dds_retcode_t rc = ddsrt_select (fdmax, rdset, NULL, NULL, DDS_INFINITY, &n);
if (rc != DDS_RETCODE_OK && rc != DDS_RETCODE_INTERRUPTED && rc != DDS_RETCODE_TRY_AGAIN)
{
DDS_WARNING("os_sockWaitsetWait: select failed, retcode = %d", rc);
DDS_WARNING("os_sockWaitsetWait: select failed, retcode = %"PRId32, rc);
break;
}
}

2
src/core/ddsi/src/q_thread.c
View file

@ -275,7 +275,7 @@ dds_retcode_t create_thread (struct thread_state1 **ts1, const char *name, uint3
if (!tprops->stack_size.isdefault)
tattr.stackSize = tprops->stack_size.value;
}
DDS_TRACE("create_thread: %s: class %d priority %d stack %u\n", name, (int) tattr.schedClass, tattr.schedPriority, tattr.stackSize);
DDS_TRACE("create_thread: %s: class %d priority %"PRId32" stack %"PRIu32"\n", name, (int) tattr.schedClass, tattr.schedPriority, tattr.stackSize);
if (ddsrt_thread_create (&tid, name, &tattr, &create_thread_wrapper, ctxt) != DDS_RETCODE_OK)
{

20
src/core/ddsi/src/q_transmit.c
View file

@ -185,11 +185,11 @@ struct nn_xmsg *writer_hbcontrol_create_heartbeat (struct writer *wr, const stru
}
}
DDS_TRACE("writer_hbcontrol: wr %x:%x:%x:%x ", PGUID (wr->e.guid));
DDS_TRACE("writer_hbcontrol: wr "PGUIDFMT" ", PGUID (wr->e.guid));
if (prd_guid == NULL)
DDS_TRACE("multicasting ");
else
DDS_TRACE("unicasting to prd %x:%x:%x:%x ", PGUID (*prd_guid));
DDS_TRACE("unicasting to prd "PGUIDFMT" ", PGUID (*prd_guid));
DDS_TRACE("(rel-prd %d seq-eq-max %d seq %"PRId64" maxseq %"PRId64")\n",
wr->num_reliable_readers,
ddsrt_avl_is_empty (&wr->readers) ? -1 : root_rdmatch (wr)->num_reliable_readers_where_seq_equals_max,
@ -209,7 +209,7 @@ struct nn_xmsg *writer_hbcontrol_create_heartbeat (struct writer *wr, const stru
struct proxy_reader *prd;
if ((prd = ephash_lookup_proxy_reader_guid (prd_guid)) == NULL)
{
DDS_TRACE("writer_hbcontrol: wr %x:%x:%x:%x unknown prd %x:%x:%x:%x\n", PGUID (wr->e.guid), PGUID (*prd_guid));
DDS_TRACE("writer_hbcontrol: wr "PGUIDFMT" unknown prd "PGUIDFMT"\n", PGUID (wr->e.guid), PGUID (*prd_guid));
nn_xmsg_free (msg);
return NULL;
}
@ -308,7 +308,7 @@ struct nn_xmsg *writer_hbcontrol_piggyback (struct writer *wr, const struct whc_
if (msg)
{
DDS_TRACE("heartbeat(wr %x:%x:%x:%x%s) piggybacked, resched in %g s (min-ack %"PRId64"%s, avail-seq %"PRId64", xmit %"PRId64")\n",
DDS_TRACE("heartbeat(wr "PGUIDFMT"%s) piggybacked, resched in %g s (min-ack %"PRId64"%s, avail-seq %"PRId64", xmit %"PRId64")\n",
PGUID (wr->e.guid),
*hbansreq ? "" : " final",
(hbc->tsched.v == T_NEVER) ? POS_INFINITY_DOUBLE : (double) (hbc->tsched.v - tnow.v) / 1e9,
@ -635,7 +635,7 @@ int create_fragment_message (struct writer *wr, seqno_t seq, const struct nn_pli
nn_xmsg_serdata (*pmsg, serdata, fragstart, fraglen);
nn_xmsg_submsg_setnext (*pmsg, sm_marker);
#if 0
DDS_TRACE("queue data%s %x:%x:%x:%x #%lld/%u[%u..%u)\n",
DDS_TRACE("queue data%s "PGUIDFMT" #%lld/%u[%u..%u)\n",
fragging ? "frag" : "", PGUID (wr->e.guid),
seq, fragnum+1, fragstart, fragstart + fraglen);
#endif
@ -871,10 +871,10 @@ static int insert_sample_in_whc (struct writer *wr, seqno_t seq, struct nn_plist
const char *ttname = wr->topic ? wr->topic->type_name : "(null)";
ppbuf[0] = '\0';
tmp = sizeof (ppbuf) - 1;
DDS_TRACE("write_sample %x:%x:%x:%x #%"PRId64"", PGUID (wr->e.guid), seq);
DDS_TRACE("write_sample "PGUIDFMT" #%"PRId64, PGUID (wr->e.guid), seq);
if (plist != 0 && (plist->present & PP_COHERENT_SET))
DDS_TRACE(" C#%"PRId64"", fromSN (plist->coherent_set_seqno));
DDS_TRACE(": ST%u %s/%s:%s%s\n", serdata->statusinfo, tname, ttname, ppbuf, tmp < (int) sizeof (ppbuf) ? "" : " (trunc)");
DDS_TRACE(": ST%"PRIu32" %s/%s:%s%s\n", serdata->statusinfo, tname, ttname, ppbuf, tmp < (int) sizeof (ppbuf) ? "" : " (trunc)");
}
assert (wr->reliable || have_reliable_subs (wr) == 0);
@ -960,7 +960,7 @@ static dds_retcode_t throttle_writer (struct thread_state1 * const ts1, struct n
assert (!is_builtin_entityid(wr->e.guid.entityid, NN_VENDORID_ECLIPSE));
}
DDS_LOG(DDS_LC_THROTTLE, "writer %x:%x:%x:%x waiting for whc to shrink below low-water mark (whc %"PRIuSIZE" low=%u high=%u)\n", PGUID (wr->e.guid), whcst.unacked_bytes, wr->whc_low, wr->whc_high);
DDS_LOG(DDS_LC_THROTTLE, "writer "PGUIDFMT" waiting for whc to shrink below low-water mark (whc %"PRIuSIZE" low=%"PRIu32" high=%"PRIu32")\n", PGUID (wr->e.guid), whcst.unacked_bytes, wr->whc_low, wr->whc_high);
wr->throttling++;
wr->throttle_count++;
@ -1007,7 +1007,7 @@ static dds_retcode_t throttle_writer (struct thread_state1 * const ts1, struct n
ddsrt_cond_broadcast (&wr->throttle_cond);
}
DDS_LOG(DDS_LC_THROTTLE, "writer %x:%x:%x:%x done waiting for whc to shrink below low-water mark (whc %"PRIuSIZE" low=%u high=%u)\n", PGUID (wr->e.guid), whcst.unacked_bytes, wr->whc_low, wr->whc_high);
DDS_LOG(DDS_LC_THROTTLE, "writer "PGUIDFMT" done waiting for whc to shrink below low-water mark (whc %"PRIuSIZE" low=%"PRIu32" high=%"PRIu32")\n", PGUID (wr->e.guid), whcst.unacked_bytes, wr->whc_low, wr->whc_high);
return result;
}
@ -1046,7 +1046,7 @@ static int write_sample_eot (struct thread_state1 * const ts1, struct nn_xpack *
const char *ttname = wr->topic ? wr->topic->type_name : "(null)";
ppbuf[0] = '\0';
tmp = sizeof (ppbuf) - 1;
DDS_WARNING ("dropping oversize (%u > %u) sample from local writer %x:%x:%x:%x %s/%s:%s%s\n",
DDS_WARNING ("dropping oversize (%"PRIu32" > %"PRIu32") sample from local writer "PGUIDFMT" %s/%s:%s%s\n",
ddsi_serdata_size (serdata), config.max_sample_size,
PGUID (wr->e.guid), tname, ttname, ppbuf,
tmp < (int) sizeof (ppbuf) ? "" : " (trunc)");

38
src/core/ddsi/src/q_xevent.c
View file

@ -196,7 +196,7 @@ static void trace_msg (const char *func, const struct nn_xmsg *m)
seqno_t wrseq;
nn_fragment_number_t wrfragid;
nn_xmsg_guid_seq_fragid (m, &wrguid, &wrseq, &wrfragid);
DDS_TRACE(" %s(%x:%x:%x:%x/%"PRId64"/%u)", func, PGUID (wrguid), wrseq, wrfragid);
DDS_TRACE(" %s("PGUIDFMT"/%"PRId64"/%u)", func, PGUID (wrguid), wrseq, wrfragid);
}
}
#else
@ -604,7 +604,7 @@ static void handle_xevk_heartbeat (struct nn_xpack *xp, struct xevent *ev, nn_mt
if ((wr = ephash_lookup_writer_guid (&ev->u.heartbeat.wr_guid)) == NULL)
{
DDS_TRACE("heartbeat(wr %x:%x:%x:%x) writer gone\n",
DDS_TRACE("heartbeat(wr "PGUIDFMT") writer gone\n",
PGUID (ev->u.heartbeat.wr_guid));
return;
}
@ -631,7 +631,7 @@ static void handle_xevk_heartbeat (struct nn_xpack *xp, struct xevent *ev, nn_mt
t_next.v = tnow.v + writer_hbcontrol_intv (wr, &whcst, tnow);
}
DDS_TRACE("heartbeat(wr %x:%x:%x:%x%s) %s, resched in %g s (min-ack %"PRId64"%s, avail-seq %"PRId64", xmit %"PRId64")\n",
DDS_TRACE("heartbeat(wr "PGUIDFMT"%s) %s, resched in %g s (min-ack %"PRId64"%s, avail-seq %"PRId64", xmit %"PRId64")\n",
PGUID (wr->e.guid),
hbansreq ? "" : " final",
msg ? "sent" : "suppressed",
@ -826,7 +826,7 @@ static void add_AckNack (struct nn_xmsg *msg, struct proxy_writer *pwr, struct p
nn_xmsg_shrink (msg, sm_marker, ACKNACK_SIZE (an->readerSNState.numbits));
nn_xmsg_submsg_setnext (msg, sm_marker);
DDS_TRACE("acknack %x:%x:%x:%x -> %x:%x:%x:%x: #%d:%"PRId64"/%u:",
DDS_TRACE("acknack "PGUIDFMT" -> "PGUIDFMT": #%"PRId32":%"PRId64"/%"PRIu32":",
PGUID (rwn->rd_guid), PGUID (pwr->e.guid), rwn->count,
base, an->readerSNState.numbits);
for (ui = 0; ui != an->readerSNState.numbits; ui++)
@ -857,7 +857,7 @@ static void add_AckNack (struct nn_xmsg *msg, struct proxy_writer *pwr, struct p
*countp = ++pwr->nackfragcount;
nn_xmsg_submsg_setnext (msg, sm_marker);
DDS_TRACE(" + nackfrag #%d:%"PRId64"/%u/%u:", *countp, fromSN (nf->writerSN), nf->fragmentNumberState.bitmap_base, nf->fragmentNumberState.numbits);
DDS_TRACE(" + nackfrag #%"PRId32":%"PRId64"/%u/%"PRIu32":", *countp, fromSN (nf->writerSN), nf->fragmentNumberState.bitmap_base, nf->fragmentNumberState.numbits);
for (ui = 0; ui != nf->fragmentNumberState.numbits; ui++)
DDS_TRACE("%c", nn_bitset_isset (nf->fragmentNumberState.numbits, nf->fragmentNumberState.bits, ui) ? '1' : '0');
}
@ -922,12 +922,12 @@ static void handle_xevk_acknack (UNUSED_ARG (struct nn_xpack *xp), struct xevent
eventually. */
resched_xevent_if_earlier (ev, add_duration_to_mtime (tnow, config.auto_resched_nack_delay));
}
DDS_TRACE("send acknack(rd %x:%x:%x:%x -> pwr %x:%x:%x:%x)\n",
DDS_TRACE("send acknack(rd "PGUIDFMT" -> pwr "PGUIDFMT")\n",
PGUID (ev->u.acknack.rd_guid), PGUID (ev->u.acknack.pwr_guid));
}
else
{
DDS_TRACE("skip acknack(rd %x:%x:%x:%x -> pwr %x:%x:%x:%x): no address\n",
DDS_TRACE("skip acknack(rd "PGUIDFMT" -> pwr "PGUIDFMT"): no address\n",
PGUID (ev->u.acknack.rd_guid), PGUID (ev->u.acknack.pwr_guid));
msg = NULL;
}
@ -1009,7 +1009,7 @@ static void handle_xevk_spdp (UNUSED_ARG (struct nn_xpack *xp), struct xevent *e
if ((pp = ephash_lookup_participant_guid (&ev->u.spdp.pp_guid)) == NULL)
{
DDS_TRACE("handle_xevk_spdp %x:%x:%x:%x - unknown guid\n",
DDS_TRACE("handle_xevk_spdp "PGUIDFMT" - unknown guid\n",
PGUID (ev->u.spdp.pp_guid));
if (ev->u.spdp.directed)
delete_xevent (ev);
@ -1018,7 +1018,7 @@ static void handle_xevk_spdp (UNUSED_ARG (struct nn_xpack *xp), struct xevent *e
if ((spdp_wr = get_builtin_writer (pp, NN_ENTITYID_SPDP_BUILTIN_PARTICIPANT_WRITER)) == NULL)
{
DDS_TRACE("handle_xevk_spdp %x:%x:%x:%x - spdp writer of participant not found\n",
DDS_TRACE("handle_xevk_spdp "PGUIDFMT" - spdp writer of participant not found\n",
PGUID (ev->u.spdp.pp_guid));
if (ev->u.spdp.directed)
delete_xevent (ev);
@ -1040,7 +1040,7 @@ static void handle_xevk_spdp (UNUSED_ARG (struct nn_xpack *xp), struct xevent *e
prd = ephash_lookup_proxy_reader_guid (&guid);
do_write = (prd != NULL);
if (!do_write)
DDS_TRACE("xmit spdp: no proxy reader %x:%x:%x:%x\n", PGUID (guid));
DDS_TRACE("xmit spdp: no proxy reader "PGUIDFMT"\n", PGUID (guid));
}
if (do_write && !resend_spdp_sample_by_guid_key (spdp_wr, &ev->u.spdp.pp_guid, prd))
@ -1065,7 +1065,7 @@ static void handle_xevk_spdp (UNUSED_ARG (struct nn_xpack *xp), struct xevent *e
}
else
{
DDS_TRACE("xmit spdp: suppressing early spdp response from %x:%x:%x:%x to %x:%x:%x:%x\n",
DDS_TRACE("xmit spdp: suppressing early spdp response from "PGUIDFMT" to %"PRIx32":%"PRIx32":%"PRIx32":%x\n",
PGUID (pp->e.guid), PGUIDPREFIX (ev->u.spdp.dest_proxypp_guid_prefix), NN_ENTITYID_PARTICIPANT);
}
#endif
@ -1080,7 +1080,7 @@ static void handle_xevk_spdp (UNUSED_ARG (struct nn_xpack *xp), struct xevent *e
else
{
nn_mtime_t tnext = add_duration_to_mtime (tnow, T_SECOND);
DDS_TRACE("xmit spdp %x:%x:%x:%x to %x:%x:%x:%x (resched %gs)\n",
DDS_TRACE("xmit spdp "PGUIDFMT" to %"PRIx32":%"PRIx32":%"PRIx32":%x (resched %gs)\n",
PGUID (pp->e.guid),
PGUIDPREFIX (ev->u.spdp.dest_proxypp_guid_prefix), NN_ENTITYID_SPDP_BUILTIN_PARTICIPANT_READER,
(double)(tnext.v - tnow.v) / 1e9);
@ -1107,7 +1107,7 @@ static void handle_xevk_spdp (UNUSED_ARG (struct nn_xpack *xp), struct xevent *e
intv = config.spdp_interval;
tnext = add_duration_to_mtime (tnow, intv);
DDS_TRACE("xmit spdp %x:%x:%x:%x to %x:%x:%x:%x (resched %gs)\n",
DDS_TRACE("xmit spdp "PGUIDFMT" to %"PRIx32":%"PRIx32":%"PRIx32":%x (resched %gs)\n",
PGUID (pp->e.guid),
PGUIDPREFIX (ev->u.spdp.dest_proxypp_guid_prefix), NN_ENTITYID_SPDP_BUILTIN_PARTICIPANT_READER,
(double)(tnext.v - tnow.v) / 1e9);
@ -1128,7 +1128,7 @@ static void write_pmd_message (struct thread_state1 * const ts1, struct nn_xpack
if ((wr = get_builtin_writer (pp, NN_ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_WRITER)) == NULL)
{
DDS_TRACE("write_pmd_message(%x:%x:%x:%x) - builtin pmd writer not found\n", PGUID (pp->e.guid));
DDS_TRACE("write_pmd_message("PGUIDFMT") - builtin pmd writer not found\n", PGUID (pp->e.guid));
return;
}
@ -1178,7 +1178,7 @@ static void handle_xevk_pmd_update (struct thread_state1 * const ts1, struct nn_
if (intv == T_NEVER)
{
tnext.v = T_NEVER;
DDS_TRACE("resched pmd(%x:%x:%x:%x): never\n", PGUID (pp->e.guid));
DDS_TRACE("resched pmd("PGUIDFMT"): never\n", PGUID (pp->e.guid));
}
else
{
@ -1188,7 +1188,7 @@ static void handle_xevk_pmd_update (struct thread_state1 * const ts1, struct nn_
tnext.v = tnow.v + intv - 2 * T_SECOND;
else
tnext.v = tnow.v + 4 * intv / 5;
DDS_TRACE("resched pmd(%x:%x:%x:%x): %gs\n", PGUID (pp->e.guid), (double)(tnext.v - tnow.v) / 1e9);
DDS_TRACE("resched pmd("PGUIDFMT"): %gs\n", PGUID (pp->e.guid), (double)(tnext.v - tnow.v) / 1e9);
}
resched_xevent_if_earlier (ev, tnext);
@ -1213,7 +1213,7 @@ static void handle_xevk_end_startup_mode (UNUSED_ARG (struct nn_xpack *xp), stru
static void handle_xevk_delete_writer (UNUSED_ARG (struct nn_xpack *xp), struct xevent *ev, UNUSED_ARG (nn_mtime_t tnow))
{
/* don't worry if the writer is already gone by the time we get here. */
DDS_TRACE("handle_xevk_delete_writer: %x:%x:%x:%x\n", PGUID (ev->u.delete_writer.guid));
DDS_TRACE("handle_xevk_delete_writer: "PGUIDFMT"\n", PGUID (ev->u.delete_writer.guid));
delete_writer_nolinger (&ev->u.delete_writer.guid);
delete_xevent (ev);
}
@ -1439,7 +1439,7 @@ void qxev_prd_entityid (struct proxy_reader * prd, nn_guid_prefix_t * id)
msg = nn_xmsg_new (gv.xmsgpool, id, sizeof (EntityId_t), NN_XMSG_KIND_CONTROL);
if (nn_xmsg_setdstPRD (msg, prd) == 0)
{
DDS_TRACE(" qxev_prd_entityid (%x:%x:%x)\n", PGUIDPREFIX (*id));
DDS_TRACE(" qxev_prd_entityid (%"PRIx32":%"PRIx32":%"PRIx32")\n", PGUIDPREFIX (*id));
nn_xmsg_add_entityid (msg);
ddsrt_mutex_lock (&gv.xevents->lock);
ev = qxev_common_nt (gv.xevents, XEVK_ENTITYID);
@ -1466,7 +1466,7 @@ void qxev_pwr_entityid (struct proxy_writer * pwr, nn_guid_prefix_t * id)
msg = nn_xmsg_new (gv.xmsgpool, id, sizeof (EntityId_t), NN_XMSG_KIND_CONTROL);
if (nn_xmsg_setdstPWR (msg, pwr) == 0)
{
DDS_TRACE(" qxev_pwr_entityid (%x:%x:%x)\n", PGUIDPREFIX (*id));
DDS_TRACE(" qxev_pwr_entityid (%"PRIx32":%"PRIx32":%"PRIx32")\n", PGUIDPREFIX (*id));
nn_xmsg_add_entityid (msg);
ddsrt_mutex_lock (&pwr->evq->lock);
ev = qxev_common_nt (pwr->evq, XEVK_ENTITYID);

16
src/core/ddsi/src/q_xmsg.c
View file

@ -590,7 +590,7 @@ int nn_xmsg_setdstPRD (struct nn_xmsg *m, const struct proxy_reader *prd)
}
else
{
DDS_WARNING("nn_xmsg_setdstPRD: no address for %x:%x:%x:%x", PGUID (prd->e.guid));
DDS_WARNING("nn_xmsg_setdstPRD: no address for "PGUIDFMT"", PGUID (prd->e.guid));
return Q_ERR_NO_ADDRESS;
}
}
@ -603,7 +603,7 @@ int nn_xmsg_setdstPWR (struct nn_xmsg *m, const struct proxy_writer *pwr)
nn_xmsg_setdst1 (m, &pwr->e.guid.prefix, &loc);
return 0;
}
DDS_WARNING("nn_xmsg_setdstPRD: no address for %x:%x:%x:%x", PGUID (pwr->e.guid));
DDS_WARNING("nn_xmsg_setdstPRD: no address for "PGUIDFMT, PGUID (pwr->e.guid));
return Q_ERR_NO_ADDRESS;
}
@ -659,7 +659,7 @@ int nn_xmsg_merge_rexmit_destinations_wrlock_held (struct nn_xmsg *m, const stru
assert (m->kindspecific.data.readerId_off != 0);
assert (madd->kindspecific.data.readerId_off != 0);
DDS_TRACE(" (%x:%x:%x:%x#%"PRId64"/%u:",
DDS_TRACE(" ("PGUIDFMT"#%"PRId64"/%u:",
PGUID (m->kindspecific.data.wrguid), m->kindspecific.data.wrseq, m->kindspecific.data.wrfragid + 1);
switch (m->dstmode)
@ -1359,7 +1359,7 @@ static void nn_xpack_send_real (struct nn_xpack * xp)
if (dds_get_log_mask() & DDS_LC_TRACE)
{
int i;
DDS_TRACE("nn_xpack_send %u:", xp->msg_len.length);
DDS_TRACE("nn_xpack_send %"PRIu32":", xp->msg_len.length);
for (i = 0; i < (int) xp->niov; i++)
{
DDS_TRACE(" %p:%lu", (void *) xp->iov[i].iov_base, (unsigned long) xp->iov[i].iov_len);
@ -1412,7 +1412,7 @@ static void nn_xpack_send_real (struct nn_xpack * xp)
DDS_TRACE(" ]\n");
if (calls)
{
DDS_LOG(DDS_LC_TRAFFIC, "traffic-xmit (%lu) %u\n", (unsigned long) calls, xp->msg_len.length);
DDS_LOG(DDS_LC_TRAFFIC, "traffic-xmit (%lu) %"PRIu32"\n", (unsigned long) calls, xp->msg_len.length);
}
nn_xmsg_chain_release (&xp->included_msgs);
nn_xpack_reinit (xp);
@ -1641,7 +1641,7 @@ int nn_xpack_addmsg (struct nn_xpack *xp, struct nn_xmsg *m, const uint32_t flag
But do make sure we can't run out of iovecs. */
assert (niov + NN_XMSG_MAX_SUBMESSAGE_IOVECS <= NN_XMSG_MAX_MESSAGE_IOVECS);
DDS_TRACE("xpack_addmsg %p %p %u(", (void *) xp, (void *) m, flags);
DDS_TRACE("xpack_addmsg %p %p %"PRIu32"(", (void *) xp, (void *) m, flags);
switch (m->kind)
{
case NN_XMSG_KIND_CONTROL:
@ -1649,7 +1649,7 @@ int nn_xpack_addmsg (struct nn_xpack *xp, struct nn_xmsg *m, const uint32_t flag
break;
case NN_XMSG_KIND_DATA:
case NN_XMSG_KIND_DATA_REXMIT:
DDS_TRACE("%s(%x:%x:%x:%x:#%"PRId64"/%u)",
DDS_TRACE("%s("PGUIDFMT":#%"PRId64"/%u)",
(m->kind == NN_XMSG_KIND_DATA) ? "data" : "rexmit",
PGUID (m->kindspecific.data.wrguid),
m->kindspecific.data.wrseq,
@ -1784,7 +1784,7 @@ int nn_xpack_addmsg (struct nn_xpack *xp, struct nn_xmsg *m, const uint32_t flag
if (xpo_niov > 0 && sz > config.max_msg_size)
{
DDS_TRACE(" => now niov %d sz %"PRIuSIZE" > max_msg_size %u, nn_xpack_send niov %d sz %u now\n", (int) niov, sz, config.max_msg_size, (int) xpo_niov, xpo_sz);
DDS_TRACE(" => now niov %d sz %"PRIuSIZE" > max_msg_size %"PRIu32", nn_xpack_send niov %d sz %"PRIu32" now\n", (int) niov, sz, config.max_msg_size, (int) xpo_niov, xpo_sz);
xp->msg_len.length = xpo_sz;
xp->niov = xpo_niov;
nn_xpack_send (xp, false);

4
src/tools/ddsperf/ddsperf.c
View file

@ -624,7 +624,7 @@ static int check_eseq (struct eseq_admin *ea, uint32_t seq, uint32_t keyval, uin
uint32_t *eseq;
if (keyval >= ea->nkeys)
{
printf ("received key %u >= nkeys %u\n", keyval, ea->nkeys);
printf ("received key %"PRIu32" >= nkeys %u\n", keyval, ea->nkeys);
exit (3);
}
ddsrt_mutex_lock (&ea->lock);
@ -1315,7 +1315,7 @@ static void print_stats (dds_time_t tstart, dds_time_t tnow, dds_time_t tprev)
prefix, x->pubhandle, (double) x->min / 1e3,
(double) x->sum / (double) x->cnt / 1e3, (double) x->max / 1e3, x->cnt);
else
printf ("%s %s:%d min %.3fus mean %.3fus max %.3fus cnt %"PRIu32"\n",
printf ("%s %s:%"PRIu32" min %.3fus mean %.3fus max %.3fus cnt %"PRIu32"\n",
prefix, pp->hostname, pp->pid, (double) x->min / 1e3,
(double) x->sum / (double) x->cnt / 1e3, (double) x->max / 1e3, x->cnt);
ddsrt_mutex_unlock (&disc_lock);