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

Move operating system abstractions from DDSI to abstraction layer

Browse source 
Signed-off-by: Jeroen Koekkoek <jeroen@koekkoek.nl>
This commit is contained in:
Jeroen Koekkoek 2019-01-07 15:35:40 +01:00
parent 9475024a5f
commit c86bda7aa4
60 changed files with 540 additions and 602 deletions
Download patch file Download diff file Expand all files Collapse all files

9
src/core/ddsi/include/ddsi/ddsi_serdata.h
View file

@ -14,7 +14,6 @@
#include "ddsi/q_time.h"
#include "ddsi/ddsi_sertopic.h"
#include "ddsi/sysdeps.h" /* for ddsi_iovec_t */
struct nn_rdata;
struct nn_keyhash;
@ -67,11 +66,11 @@ typedef void (*ddsi_serdata_to_ser_t) (const struct ddsi_serdata *d, size_t off,
calls to to_ser_ref() may be issued in parallel, the separate ref/unref bit is there to at least
have the option of lazily creating the serialised representation and freeing it when no one needs
it, while the sample itself remains valid */
typedef struct ddsi_serdata * (*ddsi_serdata_to_ser_ref_t) (const struct ddsi_serdata *d, size_t off, size_t sz, ddsi_iovec_t *ref);
typedef struct ddsi_serdata * (*ddsi_serdata_to_ser_ref_t) (const struct ddsi_serdata *d, size_t off, size_t sz, os_iovec_t *ref);
/* Release a lock on serialised data, ref must be a pointer previously obtained by calling
to_ser_ref(d, off, sz) for some offset off. */
typedef void (*ddsi_serdata_to_ser_unref_t) (struct ddsi_serdata *d, const ddsi_iovec_t *ref);
typedef void (*ddsi_serdata_to_ser_unref_t) (struct ddsi_serdata *d, const os_iovec_t *ref);
/* Turn serdata into an application sample (or just the key values if only key values are
available); return false on error (typically out-of-memory, but if from_ser doesn't do any
@ -146,11 +145,11 @@ inline void ddsi_serdata_to_ser (const struct ddsi_serdata *d, size_t off, size_
d->ops->to_ser (d, off, sz, buf);
}
inline struct ddsi_serdata *ddsi_serdata_to_ser_ref (const struct ddsi_serdata *d, size_t off, size_t sz, ddsi_iovec_t *ref) {
inline struct ddsi_serdata *ddsi_serdata_to_ser_ref (const struct ddsi_serdata *d, size_t off, size_t sz, os_iovec_t *ref) {
return d->ops->to_ser_ref (d, off, sz, ref);
}
inline void ddsi_serdata_to_ser_unref (struct ddsi_serdata *d, const ddsi_iovec_t *ref) {
inline void ddsi_serdata_to_ser_unref (struct ddsi_serdata *d, const os_iovec_t *ref) {
d->ops->to_ser_unref (d, ref);
}

1
src/core/ddsi/include/ddsi/ddsi_serdata_builtin.h
View file

@ -14,7 +14,6 @@
#include "os/os.h"
#include "util/ut_avl.h"
#include "sysdeps.h"
#include "ddsi/ddsi_serdata.h"
#include "ddsi/ddsi_sertopic.h"
#include "ddsi/q_xqos.h"

1
src/core/ddsi/include/ddsi/ddsi_serdata_default.h
View file

@ -16,7 +16,6 @@
#include "ddsi/q_plist.h" /* for nn_prismtech_writer_info */
#include "ddsi/q_freelist.h"
#include "util/ut_avl.h"
#include "sysdeps.h"
#include "ddsi/ddsi_serdata.h"
#include "ddsi/ddsi_sertopic.h"

8
src/core/ddsi/include/ddsi/ddsi_tran.h
View file

@ -37,10 +37,10 @@ typedef struct ddsi_tran_qos * ddsi_tran_qos_t;
/* Function pointer types */
typedef ssize_t (*ddsi_tran_read_fn_t) (ddsi_tran_conn_t, unsigned char *, size_t, nn_locator_t *);
typedef ssize_t (*ddsi_tran_write_fn_t) (ddsi_tran_conn_t, const nn_locator_t *, size_t, const ddsi_iovec_t *, uint32_t);
typedef ssize_t (*ddsi_tran_write_fn_t) (ddsi_tran_conn_t, const nn_locator_t *, size_t, const os_iovec_t *, uint32_t);
typedef int (*ddsi_tran_locator_fn_t) (ddsi_tran_base_t, nn_locator_t *);
typedef bool (*ddsi_tran_supports_fn_t) (int32_t);
typedef os_handle (*ddsi_tran_handle_fn_t) (ddsi_tran_base_t);
typedef os_socket (*ddsi_tran_handle_fn_t) (ddsi_tran_base_t);
typedef int (*ddsi_tran_listen_fn_t) (ddsi_tran_listener_t);
typedef void (*ddsi_tran_free_fn_t) (void);
typedef void (*ddsi_tran_peer_locator_fn_t) (ddsi_tran_conn_t, nn_locator_t *);
@ -188,7 +188,7 @@ int ddsi_tran_locator (ddsi_tran_base_t base, nn_locator_t * loc);
void ddsi_tran_free (ddsi_tran_base_t base);
void ddsi_tran_free_qos (ddsi_tran_qos_t qos);
ddsi_tran_qos_t ddsi_tran_create_qos (void);
os_handle ddsi_tran_handle (ddsi_tran_base_t base);
os_socket ddsi_tran_handle (ddsi_tran_base_t base);
#define ddsi_factory_create_listener(f,p,q) (((f)->m_create_listener_fn) ((p), (q)))
#define ddsi_factory_supports(f,k) (((f)->m_supports_fn) (k))
@ -208,7 +208,7 @@ void ddsi_factory_conn_init (ddsi_tran_factory_t factory, ddsi_tran_conn_t conn)
#define ddsi_conn_handle(c) (ddsi_tran_handle (&(c)->m_base))
#define ddsi_conn_locator(c,l) (ddsi_tran_locator (&(c)->m_base,(l)))
OSAPI_EXPORT ssize_t ddsi_conn_write (ddsi_tran_conn_t conn, const nn_locator_t *dst, size_t niov, const ddsi_iovec_t *iov, uint32_t flags);
OSAPI_EXPORT ssize_t ddsi_conn_write (ddsi_tran_conn_t conn, const nn_locator_t *dst, size_t niov, const os_iovec_t *iov, uint32_t flags);
ssize_t ddsi_conn_read (ddsi_tran_conn_t conn, unsigned char * buf, size_t len, nn_locator_t *srcloc);
bool ddsi_conn_peer_locator (ddsi_tran_conn_t conn, nn_locator_t * loc);
void ddsi_conn_disable_multiplexing (ddsi_tran_conn_t conn);

2
src/core/ddsi/include/ddsi/q_config.h
View file

@ -87,7 +87,7 @@ struct q_security_plugins
q_securityDecoderSet (*new_decoder) (void);
c_bool (*free_encoder) (q_securityEncoderSet);
c_bool (*free_decoder) (q_securityDecoderSet);
ssize_t (*send_encoded) (ddsi_tran_conn_t, const nn_locator_t *dst, size_t niov, ddsi_iovec_t *iov, q_securityEncoderSet *, uint32_t, uint32_t);
ssize_t (*send_encoded) (ddsi_tran_conn_t, const nn_locator_t *dst, size_t niov, os_iovec_t *iov, q_securityEncoderSet *, uint32_t, uint32_t);
char * (*cipher_type) (q_cipherType);
c_bool (*cipher_type_from_string) (const char *, q_cipherType *);
uint32_t (*header_size) (q_securityEncoderSet, uint32_t);

1
src/core/ddsi/include/ddsi/q_freelist.h
View file

@ -13,7 +13,6 @@
#define NN_FREELIST_H
#include "os/os.h"
#include "ddsi/sysdeps.h"
#define FREELIST_SIMPLE 1
#define FREELIST_ATOMIC_LIFO 2

29
src/core/ddsi/include/ddsi/q_log.h
View file

@ -22,19 +22,22 @@ extern "C" {
#endif
/* LOG_THREAD_CPUTIME must be considered private. */
#define LOG_THREAD_CPUTIME(guard) \
do { \
if (dds_get_log_mask() & DDS_LC_TIMING) { \
nn_mtime_t tnowlt = now_mt(); \
if (tnowlt.v >= (guard).v) { \
const char fmt[] = "thread_cputime %d.%09d\n"; \
int64_t ts = get_thread_cputime (); \
dds_log( \
DDS_LC_TIMING, __FILE__, __LINE__, OS_FUNCTION, \
fmt, (int)(ts / T_SECOND), (int)(ts % T_SECOND)); \
(guard).v = tnowlt.v + T_SECOND; \
} \
} \
#define LOG_THREAD_CPUTIME(guard) \
do { \
if (dds_get_log_mask() & DDS_LC_TIMING) { \
nn_mtime_t tnowlt = now_mt(); \
if (tnowlt.v >= (guard).v) { \
os_rusage_t usage; \
if (os_getrusage(OS_RUSAGE_THREAD, &usage) == 0) { \
DDS_LOG( \
DDS_LC_TIMING, \
"thread_cputime %d.%09d\n", \
(int)usage.stime.tv_sec, \
(int)usage.stime.tv_nsec); \
(guard).v = tnowlt.v + T_SECOND; \
} \
} \
} \
} while (0)
#if defined (__cplusplus)

1
src/core/ddsi/include/ddsi/q_sockwaitset.h
View file

@ -13,7 +13,6 @@
#define Q_SOCKWAITSET_H
#include "os/os_defs.h"
#include "ddsi/sysdeps.h"
#if defined (__cplusplus)
extern "C" {

1
src/core/ddsi/include/ddsi/q_thread_template.h
View file

@ -11,7 +11,6 @@
*/
/* -*- c -*- */
#include "ddsi/sysdeps.h"
#include "os/os_atomics.h"
#include "ddsi/q_static_assert.h"

188
src/core/ddsi/include/ddsi/sysdeps.h
View file

@ -14,113 +14,6 @@
#include "os/os.h"
#ifndef os_sockECONNRESET
#ifdef WSAECONNRESET
#define os_sockECONNRESET WSAECONNRESET
#else
#define os_sockECONNRESET ECONNRESET
#endif
#endif
#ifndef os_sockEPERM
#ifdef WSAEACCES
#define os_sockEPERM WSAEACCES
#else
#define os_sockEPERM EPERM
#endif
#endif
#if defined (__linux) || defined (__sun) || defined (__APPLE__) || defined (INTEGRITY) || defined (AIX) || defined (OS_RTEMS_DEFS_H) || defined (__VXWORKS__) || defined (__Lynx__) || defined (__linux__) || defined (OS_QNX_DEFS_H)
#define SYSDEPS_HAVE_MSGHDR 1
#define SYSDEPS_HAVE_RECVMSG 1
#define SYSDEPS_HAVE_SENDMSG 1
#endif
#if defined (__linux) || defined (__sun) || defined (__APPLE__) || defined (INTEGRITY) || defined (AIX) || defined (OS_RTEMS_DEFS_H) || defined (__VXWORKS__) || defined (__linux__) || defined (OS_QNX_DEFS_H)
#define SYSDEPS_HAVE_IOVEC 1
#endif
#if defined (__linux) || defined (__sun) || defined (__APPLE__) || defined (AIX) || defined (__Lynx__) || defined (OS_QNX_DEFS_H)
#define SYSDEPS_HAVE_RANDOM 1
#include <unistd.h>
#endif
#if defined (__linux) || defined (__sun) || defined (__APPLE__) || defined (AIX) || defined (OS_QNX_DEFS_H)
#define SYSDEPS_HAVE_GETRUSAGE 1
#include <sys/time.h> /* needed for Linux, exists on all four */
#include <sys/times.h> /* needed for AIX, exists on all four */
#include <sys/resource.h>
#endif
#if defined (__linux) && defined (CLOCK_THREAD_CPUTIME_ID)
#define SYSDEPS_HAVE_CLOCK_THREAD_CPUTIME 1
#endif
#if defined (INTEGRITY)
#include <sys/uio.h>
#include <limits.h>
#endif
#if defined (VXWORKS_RTP)
#include <net/uio.h>
#endif
#if defined (_WIN32)
typedef SOCKET os_handle;
#define Q_VALID_SOCKET(s) ((s) != INVALID_SOCKET)
#define Q_INVALID_SOCKET INVALID_SOCKET
#else /* All Unixes have socket() return -1 on error */
typedef int os_handle;
#define Q_VALID_SOCKET(s) ((s) != -1)
#define Q_INVALID_SOCKET -1
#endif
/* From MSDN: from Vista & 2k3 onwards, a macro named MemoryBarrier is
defined, XP needs inline assembly. Unfortunately, MemoryBarrier()
is a function on x86 ...
Definition below is taken from the MSDN page on MemoryBarrier() */
#ifndef MemoryBarrier
#if NTDDI_VERSION >= NTDDI_WS03 && defined _M_IX86
#define MemoryBarrier() do { \
LONG Barrier; \
__asm { \
xchg Barrier, eax \
} \
} while (0)
#endif /* x86 */
/* Don't try interworking with thumb - one thing at a time. Do a DMB
SY if supported, else no need for a memory barrier. (I think.) */
#if defined _M_ARM && ! defined _M_ARMT
#define MemoryBarrierARM __emit (0xf57ff05f) /* 0xf57ff05f or 0x5ff07ff5 */
#if _M_ARM > 7
/* if targetting ARMv7 the dmb instruction is available */
#define MemoryBarrier() MemoryBarrierARM
#else
/* else conditional on actual hardware platform */
extern void (*q_maybe_membar) (void);
#define MemoryBarrier() q_maybe_membar ()
#define NEED_ARM_MEMBAR_SUPPORT 1
#endif /* ARM version */
#endif /* ARM */
#endif /* !def MemoryBarrier */
#if defined (__sun) && !defined (_XPG4_2)
#define SYSDEPS_MSGHDR_ACCRIGHTS 1
#else
#define SYSDEPS_MSGHDR_ACCRIGHTS 0
#endif
#if SYSDEPS_MSGHDR_ACCRIGHTS
#define SYSDEPS_MSGHDR_FLAGS 0
#else
#define SYSDEPS_MSGHDR_FLAGS 1
#endif
#if defined (__cplusplus)
}
#endif
#if defined (__cplusplus)
extern "C" {
@ -130,89 +23,8 @@ extern "C" {
#define ASSERT_WRLOCK_HELD(x) ((void) 0)
#define ASSERT_MUTEX_HELD(x) ((void) 0)
#if SYSDEPS_HAVE_IOVEC
typedef struct iovec ddsi_iovec_t;
typedef size_t ddsi_iov_len_t;
#elif defined _WIN32 && !defined WINCE
typedef unsigned ddsi_iov_len_t;
typedef struct ddsi_iovec {
ddsi_iov_len_t iov_len;
void *iov_base;
} ddsi_iovec_t;
#define DDSI_IOVEC_MATCHES_WSABUF do { \
struct ddsi_iovec_matches_WSABUF { \
char sizeof_matches[sizeof(struct ddsi_iovec) == sizeof(WSABUF) ? 1 : -1]; \
char base_off_matches[offsetof(struct ddsi_iovec, iov_base) == offsetof(WSABUF, buf) ? 1 : -1]; \
char base_size_matches[sizeof(((struct ddsi_iovec *)8)->iov_base) == sizeof(((WSABUF *)8)->buf) ? 1 : -1]; \
char len_off_matches[offsetof(struct ddsi_iovec, iov_len) == offsetof(WSABUF, len) ? 1 : -1]; \
char len_size_matches[sizeof(((struct ddsi_iovec *)8)->iov_len) == sizeof(((WSABUF *)8)->len) ? 1 : -1]; \
}; } while (0)
#else
typedef size_t ddsi_iov_len_t;
typedef struct ddsi_iovec {
void *iov_base;
ddsi_iov_len_t iov_len;
} ddsi_iovec_t;
#endif
#if ! SYSDEPS_HAVE_MSGHDR
#if defined _WIN32
typedef DWORD ddsi_msg_iovlen_t;
#else
typedef int ddsi_msg_iovlen_t;
#endif
struct msghdr
{
void *msg_name;
socklen_t msg_namelen;
ddsi_iovec_t *msg_iov;
ddsi_msg_iovlen_t msg_iovlen;
void *msg_control;
size_t msg_controllen;
int msg_flags;
};
#elif defined __linux
typedef size_t ddsi_msg_iovlen_t;
#else /* POSIX says int (which macOS, FreeBSD, Solaris do) */
typedef int ddsi_msg_iovlen_t;
#endif
#ifndef MSG_TRUNC
#define MSG_TRUNC 1
#endif
#if ! SYSDEPS_HAVE_RECVMSG
/* Only implements iovec of length 1, no control */
ssize_t recvmsg (os_handle fd, struct msghdr *message, int flags);
#endif
#if ! SYSDEPS_HAVE_SENDMSG
ssize_t sendmsg (os_handle fd, const struct msghdr *message, int flags);
#endif
#if ! SYSDEPS_HAVE_RANDOM
long random (void);
#endif
int64_t get_thread_cputime (void);
int os_threadEqual (os_threadId a, os_threadId b);
void log_stacktrace (const char *name, os_threadId tid);
#if (_LP64 && __GCC_HAVE_SYNC_COMPARE_AND_SWAP_16) || (!_LP64 && __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)
#define HAVE_ATOMIC_LIFO 1
#if _LP64
typedef union { __int128 x; struct { uintptr_t a, b; } s; } os_atomic_uintptr2_t;
#else
typedef union { uint64_t x; struct { uintptr_t a, b; } s; } os_atomic_uintptr2_t;
#endif
typedef struct os_atomic_lifo {
os_atomic_uintptr2_t aba_head;
} os_atomic_lifo_t;
void os_atomic_lifo_init (os_atomic_lifo_t *head);
void os_atomic_lifo_push (os_atomic_lifo_t *head, void *elem, size_t linkoff);
void os_atomic_lifo_pushmany (os_atomic_lifo_t *head, void *first, void *last, size_t linkoff);
void *os_atomic_lifo_pop (os_atomic_lifo_t *head, size_t linkoff);
#endif
#if defined (__cplusplus)
}
#endif

8
src/core/ddsi/src/ddsi_raweth.c
View file

@ -118,7 +118,7 @@ static ssize_t ddsi_raweth_conn_read (ddsi_tran_conn_t conn, unsigned char * buf
return ret;
}
static ssize_t ddsi_raweth_conn_write (ddsi_tran_conn_t conn, const nn_locator_t *dst, size_t niov, const ddsi_iovec_t *iov, uint32_t flags)
static ssize_t ddsi_raweth_conn_write (ddsi_tran_conn_t conn, const nn_locator_t *dst, size_t niov, const os_iovec_t *iov, uint32_t flags)
{
ddsi_raweth_conn_t uc = (ddsi_raweth_conn_t) conn;
int err;
@ -138,7 +138,7 @@ static ssize_t ddsi_raweth_conn_write (ddsi_tran_conn_t conn, const nn_locator_t
msg.msg_name = &dstaddr;
msg.msg_namelen = sizeof(dstaddr);
msg.msg_flags = (int) flags;
msg.msg_iov = (ddsi_iovec_t *) iov;
msg.msg_iov = (os_iovec_t *) iov;
msg.msg_iovlen = niov;
#ifdef MSG_NOSIGNAL
sendflags |= MSG_NOSIGNAL;
@ -168,7 +168,7 @@ static ssize_t ddsi_raweth_conn_write (ddsi_tran_conn_t conn, const nn_locator_t
return ret;
}
static os_handle ddsi_raweth_conn_handle (ddsi_tran_base_t base)
static os_socket ddsi_raweth_conn_handle (ddsi_tran_base_t base)
{
return ((ddsi_raweth_conn_t) base)->m_sock;
}
@ -182,7 +182,7 @@ static int ddsi_raweth_conn_locator (ddsi_tran_base_t base, nn_locator_t *loc)
{
ddsi_raweth_conn_t uc = (ddsi_raweth_conn_t) base;
int ret = -1;
if (uc->m_sock != Q_INVALID_SOCKET)
if (uc->m_sock != OS_INVALID_SOCKET)
{
loc->kind = NN_LOCATOR_KIND_RAWETH;
loc->port = uc->m_base.m_base.m_port;

5
src/core/ddsi/src/ddsi_serdata.c
View file

@ -15,7 +15,6 @@
#include <string.h>
#include "os/os.h"
#include "ddsi/sysdeps.h"
#include "ddsi/q_md5.h"
#include "ddsi/q_bswap.h"
#include "ddsi/q_config.h"
@ -42,8 +41,8 @@ extern inline struct ddsi_serdata *ddsi_serdata_from_keyhash (const struct ddsi_
extern inline struct ddsi_serdata *ddsi_serdata_from_sample (const struct ddsi_sertopic *topic, enum ddsi_serdata_kind kind, const void *sample);
extern inline struct ddsi_serdata *ddsi_serdata_to_topicless (const struct ddsi_serdata *d);
extern inline void ddsi_serdata_to_ser (const struct ddsi_serdata *d, size_t off, size_t sz, void *buf);
extern inline struct ddsi_serdata *ddsi_serdata_to_ser_ref (const struct ddsi_serdata *d, size_t off, size_t sz, ddsi_iovec_t *ref);
extern inline void ddsi_serdata_to_ser_unref (struct ddsi_serdata *d, const ddsi_iovec_t *ref);
extern inline struct ddsi_serdata *ddsi_serdata_to_ser_ref (const struct ddsi_serdata *d, size_t off, size_t sz, os_iovec_t *ref);
extern inline void ddsi_serdata_to_ser_unref (struct ddsi_serdata *d, const os_iovec_t *ref);
extern inline bool ddsi_serdata_to_sample (const struct ddsi_serdata *d, void *sample, void **bufptr, void *buflim);
extern inline bool ddsi_serdata_topicless_to_sample (const struct ddsi_sertopic *topic, const struct ddsi_serdata *d, void *sample, void **bufptr, void *buflim);
extern inline bool ddsi_serdata_eqkey (const struct ddsi_serdata *a, const struct ddsi_serdata *b);

5
src/core/ddsi/src/ddsi_serdata_builtin.c
View file

@ -15,7 +15,6 @@
#include <string.h>
#include "os/os.h"
#include "ddsi/sysdeps.h"
#include "ddsi/q_md5.h"
#include "ddsi/q_bswap.h"
#include "ddsi/q_config.h"
@ -260,13 +259,13 @@ static void serdata_builtin_to_ser (const struct ddsi_serdata *serdata_common, s
(void)serdata_common; (void)off; (void)sz; (void)buf;
}
static struct ddsi_serdata *serdata_builtin_to_ser_ref (const struct ddsi_serdata *serdata_common, size_t off, size_t sz, ddsi_iovec_t *ref)
static struct ddsi_serdata *serdata_builtin_to_ser_ref (const struct ddsi_serdata *serdata_common, size_t off, size_t sz, os_iovec_t *ref)
{
(void)serdata_common; (void)off; (void)sz; (void)ref;
return NULL;
}
static void serdata_builtin_to_ser_unref (struct ddsi_serdata *serdata_common, const ddsi_iovec_t *ref)
static void serdata_builtin_to_ser_unref (struct ddsi_serdata *serdata_common, const os_iovec_t *ref)
{
(void)serdata_common; (void)ref;
}

7
src/core/ddsi/src/ddsi_serdata_default.c
View file

@ -15,7 +15,6 @@
#include <string.h>
#include "os/os.h"
#include "ddsi/sysdeps.h"
#include "ddsi/q_md5.h"
#include "ddsi/q_bswap.h"
#include "ddsi/q_config.h"
@ -479,17 +478,17 @@ static void serdata_default_to_ser (const struct ddsi_serdata *serdata_common, s
memcpy (buf, (char *)&d->hdr + off, sz);
}
static struct ddsi_serdata *serdata_default_to_ser_ref (const struct ddsi_serdata *serdata_common, size_t off, size_t sz, ddsi_iovec_t *ref)
static struct ddsi_serdata *serdata_default_to_ser_ref (const struct ddsi_serdata *serdata_common, size_t off, size_t sz, os_iovec_t *ref)
{
const struct ddsi_serdata_default *d = (const struct ddsi_serdata_default *)serdata_common;
assert (off < d->pos + sizeof(struct CDRHeader));
assert (sz <= alignup_size (d->pos + sizeof(struct CDRHeader), 4) - off);
ref->iov_base = (char *)&d->hdr + off;
ref->iov_len = (ddsi_iov_len_t)sz;
ref->iov_len = (os_iov_len_t)sz;
return ddsi_serdata_ref(serdata_common);
}
static void serdata_default_to_ser_unref (struct ddsi_serdata *serdata_common, const ddsi_iovec_t *ref)
static void serdata_default_to_ser_unref (struct ddsi_serdata *serdata_common, const os_iovec_t *ref)
{
(void)ref;
ddsi_serdata_unref(serdata_common);

1
src/core/ddsi/src/ddsi_sertopic.c
View file

@ -15,7 +15,6 @@
#include <string.h>
#include "os/os.h"
#include "ddsi/sysdeps.h"
#include "ddsi/q_md5.h"
#include "ddsi/q_bswap.h"
#include "ddsi/q_config.h"

1
src/core/ddsi/src/ddsi_sertopic_builtin.c
View file

@ -15,7 +15,6 @@
#include <string.h>
#include "os/os.h"
#include "ddsi/sysdeps.h"
#include "ddsi/q_md5.h"
#include "ddsi/q_bswap.h"
#include "ddsi/q_config.h"

1
src/core/ddsi/src/ddsi_sertopic_default.c
View file

@ -15,7 +15,6 @@
#include <string.h>
#include "os/os.h"
#include "ddsi/sysdeps.h"
#include "ddsi/q_md5.h"
#include "ddsi/q_bswap.h"
#include "ddsi/q_config.h"

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

@ -361,7 +361,7 @@ static SSL * ddsi_ssl_accept (BIO * bio, os_socket * sock)
if (err <= 0)
{
SSL_free (ssl);
*sock = Q_INVALID_SOCKET;
*sock = OS_INVALID_SOCKET;
ssl = NULL;
}
}

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

@ -159,12 +159,12 @@ static unsigned short get_socket_port (os_socket socket)
static void ddsi_tcp_conn_set_socket (ddsi_tcp_conn_t conn, os_socket sock)
{
conn->m_sock = sock;
conn->m_base.m_base.m_port = (sock == Q_INVALID_SOCKET) ? INVALID_PORT : get_socket_port (sock);
conn->m_base.m_base.m_port = (sock == OS_INVALID_SOCKET) ? INVALID_PORT : get_socket_port (sock);
}
static void ddsi_tcp_sock_free (os_socket sock, const char * msg)
{
if (sock != Q_INVALID_SOCKET)
if (sock != OS_INVALID_SOCKET)
{
if (msg)
{
@ -178,7 +178,7 @@ static void ddsi_tcp_sock_new (os_socket * sock, unsigned short port)
{
if (make_socket (sock, port, true, true) != 0)
{
*sock = Q_INVALID_SOCKET;
*sock = OS_INVALID_SOCKET;
}
}
@ -196,7 +196,7 @@ static void ddsi_tcp_conn_connect (ddsi_tcp_conn_t conn, const struct msghdr * m
os_socket sock;
ddsi_tcp_sock_new (&sock, 0);
if (sock != Q_INVALID_SOCKET)
if (sock != OS_INVALID_SOCKET)
{
/* Attempt to connect, expected that may fail */
@ -219,7 +219,7 @@ static void ddsi_tcp_conn_connect (ddsi_tcp_conn_t conn, const struct msghdr * m
conn->m_ssl = (ddsi_tcp_ssl_plugin.connect) (sock);
if (conn->m_ssl == NULL)
{
ddsi_tcp_conn_set_socket (conn, Q_INVALID_SOCKET);
ddsi_tcp_conn_set_socket (conn, OS_INVALID_SOCKET);
return;
}
}
@ -329,7 +329,7 @@ static ddsi_tcp_conn_t ddsi_tcp_cache_find (const struct msghdr * msg)
}
if (ret == NULL)
{
ret = ddsi_tcp_new_conn (Q_INVALID_SOCKET, false, (os_sockaddr *)&key.m_peer_addr);
ret = ddsi_tcp_new_conn (OS_INVALID_SOCKET, false, (os_sockaddr *)&key.m_peer_addr);
ddsi_tcp_cache_add (ret, &path);
}
os_mutexUnlock (&ddsi_tcp_cache_lock_g);
@ -521,7 +521,7 @@ static ssize_t ddsi_tcp_block_write
return (pos == sz) ? (ssize_t) pos : -1;
}
static size_t iovlen_sum (size_t niov, const ddsi_iovec_t *iov)
static size_t iovlen_sum (size_t niov, const os_iovec_t *iov)
{
size_t tot = 0;
while (niov--) {
@ -530,13 +530,13 @@ static size_t iovlen_sum (size_t niov, const ddsi_iovec_t *iov)
return tot;
}
static void set_msghdr_iov (struct msghdr *mhdr, ddsi_iovec_t *iov, size_t iovlen)
static void set_msghdr_iov (struct msghdr *mhdr, os_iovec_t *iov, size_t iovlen)
{
mhdr->msg_iov = iov;
mhdr->msg_iovlen = (ddsi_msg_iovlen_t)iovlen;
mhdr->msg_iovlen = (os_msg_iovlen_t)iovlen;
}
static ssize_t ddsi_tcp_conn_write (ddsi_tran_conn_t base, const nn_locator_t *dst, size_t niov, const ddsi_iovec_t *iov, uint32_t flags)
static ssize_t ddsi_tcp_conn_write (ddsi_tran_conn_t base, const nn_locator_t *dst, size_t niov, const os_iovec_t *iov, uint32_t flags)
{
#ifdef DDSI_INCLUDE_SSL
char msgbuf[4096]; /* stack buffer for merging smallish writes without requiring allocations */
@ -552,7 +552,7 @@ static ssize_t ddsi_tcp_conn_write (ddsi_tran_conn_t base, const nn_locator_t *d
assert(niov <= INT_MAX);
ddsi_ipaddr_from_loc(&dstaddr, dst);
memset(&msg, 0, sizeof(msg));
set_msghdr_iov (&msg, (ddsi_iovec_t *) iov, niov);
set_msghdr_iov (&msg, (os_iovec_t *) iov, niov);
msg.msg_name = &dstaddr;
msg.msg_namelen = (socklen_t) os_sockaddr_get_size((os_sockaddr *) &dstaddr);
#if SYSDEPS_MSGHDR_FLAGS
@ -571,10 +571,10 @@ static ssize_t ddsi_tcp_conn_write (ddsi_tran_conn_t base, const nn_locator_t *d
/* If not connected attempt to conect */
if ((conn->m_sock == Q_INVALID_SOCKET) && ! conn->m_base.m_server)
if ((conn->m_sock == OS_INVALID_SOCKET) && ! conn->m_base.m_server)
{
ddsi_tcp_conn_connect (conn, &msg);
if (conn->m_sock == Q_INVALID_SOCKET)
if (conn->m_sock == OS_INVALID_SOCKET)
{
os_mutexUnlock (&conn->m_mutex);
return -1;
@ -644,7 +644,7 @@ static ssize_t ddsi_tcp_conn_write (ddsi_tran_conn_t base, const nn_locator_t *d
piecewise = 0;
if (err != os_sockECONNRESET)
{
if (! conn->m_base.m_closed && (conn->m_sock != Q_INVALID_SOCKET))
if (! conn->m_base.m_closed && (conn->m_sock != OS_INVALID_SOCKET))
{
DDS_WARNING
(
@ -711,7 +711,7 @@ static ssize_t ddsi_tcp_conn_write (ddsi_tran_conn_t base, const nn_locator_t *d
return ((size_t) ret == len) ? ret : -1;
}
static os_handle ddsi_tcp_conn_handle (ddsi_tran_base_t base)
static os_socket ddsi_tcp_conn_handle (ddsi_tran_base_t base)
{
return ((ddsi_tcp_conn_t) base)->m_sock;
}
@ -756,7 +756,7 @@ static ddsi_tran_conn_t ddsi_tcp_accept (ddsi_tran_listener_t listener)
{
ddsi_tcp_listener_t tl = (ddsi_tcp_listener_t) listener;
ddsi_tcp_conn_t tcp = NULL;
os_socket sock = Q_INVALID_SOCKET;
os_socket sock = OS_INVALID_SOCKET;
os_sockaddr_storage addr;
socklen_t addrlen = sizeof (addr);
char buff[DDSI_LOCSTRLEN];
@ -783,11 +783,11 @@ static ddsi_tran_conn_t ddsi_tcp_accept (ddsi_tran_listener_t listener)
ddsi_tcp_sock_free (sock, NULL);
return NULL;
}
err = (sock == Q_INVALID_SOCKET) ? os_getErrno () : 0;
err = (sock == OS_INVALID_SOCKET) ? os_getErrno () : 0;
}
while ((err == os_sockEINTR) || (err == os_sockEAGAIN) || (err == os_sockEWOULDBLOCK));
if (sock == Q_INVALID_SOCKET)
if (sock == OS_INVALID_SOCKET)
{
getsockname (tl->m_sock, (struct sockaddr *) &addr, &addrlen);
sockaddr_to_string_with_port(buff, sizeof(buff), (os_sockaddr *)&addr);
@ -821,7 +821,7 @@ static ddsi_tran_conn_t ddsi_tcp_accept (ddsi_tran_listener_t listener)
return tcp ? &tcp->m_base : NULL;
}
static os_handle ddsi_tcp_listener_handle (ddsi_tran_base_t base)
static os_socket ddsi_tcp_listener_handle (ddsi_tran_base_t base)
{
return ((ddsi_tcp_listener_t) base)->m_sock;
}
@ -836,7 +836,7 @@ static void ddsi_tcp_conn_peer_locator (ddsi_tran_conn_t conn, nn_locator_t * lo
{
char buff[DDSI_LOCSTRLEN];
ddsi_tcp_conn_t tc = (ddsi_tcp_conn_t) conn;
assert (tc->m_sock != Q_INVALID_SOCKET);
assert (tc->m_sock != OS_INVALID_SOCKET);
ddsi_ipaddr_to_loc (loc, (os_sockaddr *)&tc->m_peer_addr, tc->m_peer_addr.ss_family == AF_INET ? NN_LOCATOR_KIND_TCPv4 : NN_LOCATOR_KIND_TCPv6);
ddsi_locator_to_string(buff, sizeof(buff), loc);
DDS_LOG(DDS_LC_TCP, "(%s EP:%s)", ddsi_name, buff);
@ -861,7 +861,7 @@ static ddsi_tcp_conn_t ddsi_tcp_new_conn (os_socket sock, bool server, os_sockad
memset (conn, 0, sizeof (*conn));
ddsi_tcp_base_init (&conn->m_base);
os_mutexInit (&conn->m_mutex);
conn->m_sock = Q_INVALID_SOCKET;
conn->m_sock = OS_INVALID_SOCKET;
(void)memcpy(&conn->m_peer_addr, peer, os_sockaddr_get_size(peer));
conn->m_peer_port = os_sockaddr_get_port (peer);
conn->m_base.m_server = server;
@ -883,7 +883,7 @@ static ddsi_tran_listener_t ddsi_tcp_create_listener (int port, ddsi_tran_qos_t
ddsi_tcp_sock_new (&sock, (unsigned short) port);
if (sock != Q_INVALID_SOCKET)
if (sock != OS_INVALID_SOCKET)
{
tl = (ddsi_tcp_listener_t) os_malloc (sizeof (*tl));
memset (tl, 0, sizeof (*tl));
@ -974,7 +974,7 @@ static void ddsi_tcp_unblock_listener (ddsi_tran_listener_t listener)
/* Connect to own listener socket to wake listener from blocking 'accept()' */
ddsi_tcp_sock_new (&sock, 0);
if (sock != Q_INVALID_SOCKET)
if (sock != OS_INVALID_SOCKET)
{
os_sockaddr_storage addr;
socklen_t addrlen = sizeof (addr);

1
src/core/ddsi/src/ddsi_tkmap.c
View file

@ -16,7 +16,6 @@
#include "ddsi/q_gc.h"
#include "ddsi/q_globals.h"
#include "ddsi/q_config.h"
#include "ddsi/sysdeps.h"
#include "ddsi/ddsi_iid.h"
#include "ddsi/ddsi_tkmap.h"
#include "util/ut_hopscotch.h"

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

@ -97,7 +97,7 @@ void ddsi_conn_free (ddsi_tran_conn_t conn)
{
conn->m_closed = true;
/* FIXME: rethink the socket waitset & the deleting of entries; the biggest issue is TCP handling that can open & close sockets at will and yet expects the waitset to wake up at the apprioriate times. (This pretty much works with the select-based version, but not the kqueue-based one.) TCP code can also have connections without a socket ... Calling sockWaitsetRemove here (where there shouldn't be any knowledge of it) at least ensures that it is removed in time and that there can't be aliasing of connections and sockets. */
if (ddsi_conn_handle (conn) != Q_INVALID_SOCKET)
if (ddsi_conn_handle (conn) != OS_INVALID_SOCKET)
{
unsigned i;
for (i = 0; i < gv.n_recv_threads; i++)
@ -149,7 +149,7 @@ ssize_t ddsi_conn_read (ddsi_tran_conn_t conn, unsigned char * buf, size_t len,
return (conn->m_closed) ? -1 : (conn->m_read_fn) (conn, buf, len, srcloc);
}
ssize_t ddsi_conn_write (ddsi_tran_conn_t conn, const nn_locator_t *dst, size_t niov, const ddsi_iovec_t *iov, uint32_t flags)
ssize_t ddsi_conn_write (ddsi_tran_conn_t conn, const nn_locator_t *dst, size_t niov, const os_iovec_t *iov, uint32_t flags)
{
ssize_t ret = -1;
if (! conn->m_closed)
@ -202,7 +202,7 @@ int ddsi_conn_leave_mc (ddsi_tran_conn_t conn, const nn_locator_t *srcloc, const
return conn->m_factory->m_leave_mc_fn (conn, srcloc, mcloc, interf);
}
os_handle ddsi_tran_handle (ddsi_tran_base_t base)
os_socket ddsi_tran_handle (ddsi_tran_base_t base)
{
return (base->m_handle_fn) (base);
}

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

@ -54,23 +54,18 @@ static ssize_t ddsi_udp_conn_read (ddsi_tran_conn_t conn, unsigned char * buf, s
ssize_t ret;
struct msghdr msghdr;
os_sockaddr_storage src;
ddsi_iovec_t msg_iov;
os_iovec_t msg_iov;
socklen_t srclen = (socklen_t) sizeof (src);
msg_iov.iov_base = (void*) buf;
msg_iov.iov_len = (ddsi_iov_len_t)len; /* windows uses unsigned, POISX size_t */
msg_iov.iov_len = (os_iov_len_t)len; /* Windows uses unsigned, POSIX (except Linux) int */
msghdr.msg_name = &src;
msghdr.msg_namelen = srclen;
msghdr.msg_iov = &msg_iov;
msghdr.msg_iovlen = 1;
#if !defined(__sun) || defined(_XPG4_2)
msghdr.msg_control = NULL;
msghdr.msg_controllen = 0;
#else
msghdr.msg_accrights = NULL;
msghdr.msg_accrightslen = 0;
#endif
do {
ret = recvmsg(((ddsi_udp_conn_t) conn)->m_sock, &msghdr, 0);
@ -103,13 +98,13 @@ static ssize_t ddsi_udp_conn_read (ddsi_tran_conn_t conn, unsigned char * buf, s
return ret;
}
static void set_msghdr_iov (struct msghdr *mhdr, ddsi_iovec_t *iov, size_t iovlen)
static void set_msghdr_iov (struct msghdr *mhdr, os_iovec_t *iov, size_t iovlen)
{
mhdr->msg_iov = iov;
mhdr->msg_iovlen = (ddsi_msg_iovlen_t)iovlen;
mhdr->msg_iovlen = (os_msg_iovlen_t)iovlen;
}
static ssize_t ddsi_udp_conn_write (ddsi_tran_conn_t conn, const nn_locator_t *dst, size_t niov, const ddsi_iovec_t *iov, uint32_t flags)
static ssize_t ddsi_udp_conn_write (ddsi_tran_conn_t conn, const nn_locator_t *dst, size_t niov, const os_iovec_t *iov, uint32_t flags)
{
int err;
ssize_t ret;
@ -119,18 +114,15 @@ static ssize_t ddsi_udp_conn_write (ddsi_tran_conn_t conn, const nn_locator_t *d
os_sockaddr_storage dstaddr;
assert(niov <= INT_MAX);
ddsi_ipaddr_from_loc(&dstaddr, dst);
set_msghdr_iov (&msg, (ddsi_iovec_t *) iov, niov);
set_msghdr_iov (&msg, (os_iovec_t *) iov, niov);
msg.msg_name = &dstaddr;
msg.msg_namelen = (socklen_t) os_sockaddr_get_size((os_sockaddr *) &dstaddr);
#if !defined(__sun) || defined(_XPG4_2)
msg.msg_control = NULL;
msg.msg_controllen = 0;
#else
msg.msg_accrights = NULL;
msg.msg_accrightslen = 0;
#endif
#if SYSDEPS_MSGHDR_FLAGS
msg.msg_flags = (int) flags;
#else
OS_UNUSED_ARG(flags);
#endif
#ifdef MSG_NOSIGNAL
sendflags |= MSG_NOSIGNAL;
@ -187,7 +179,7 @@ static void ddsi_udp_disable_multiplexing (ddsi_tran_conn_t base)
#endif
}
static os_handle ddsi_udp_conn_handle (ddsi_tran_base_t base)
static os_socket ddsi_udp_conn_handle (ddsi_tran_base_t base)
{
return ((ddsi_udp_conn_t) base)->m_sock;
}
@ -203,7 +195,7 @@ static int ddsi_udp_conn_locator (ddsi_tran_base_t base, nn_locator_t *loc)
{
int ret = -1;
ddsi_udp_conn_t uc = (ddsi_udp_conn_t) base;
if (uc->m_sock != Q_INVALID_SOCKET)
if (uc->m_sock != OS_INVALID_SOCKET)
{
loc->kind = ddsi_udp_factory_g.m_kind;
loc->port = uc->m_base.m_base.m_port;

1
src/core/ddsi/src/q_config.c
View file

@ -27,7 +27,6 @@
#include "ddsi/q_addrset.h"
#include "ddsi/q_nwif.h"
#include "ddsi/q_error.h"
#include "ddsi/sysdeps.h"
#include "util/ut_xmlparser.h"
#include "util/ut_expand_envvars.h"

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

@ -41,8 +41,6 @@
#include "ddsi/q_md5.h"
#include "ddsi/q_feature_check.h"
#include "ddsi/sysdeps.h"
static const nn_vendorid_t ownvendorid = MY_VENDOR_ID;
static int get_locator (nn_locator_t *loc, const nn_locators_t *locs, int uc_same_subnet)

3
src/core/ddsi/src/q_debmon.c
View file

@ -36,7 +36,6 @@
#include "ddsi/ddsi_tran.h"
#include "ddsi/ddsi_tcp.h"
#include "ddsi/sysdeps.h"
#include "dds__whc.h"
struct plugin {
@ -63,7 +62,7 @@ static int cpf (ddsi_tran_conn_t conn, const char *fmt, ...)
else
{
va_list ap;
ddsi_iovec_t iov;
os_iovec_t iov;
char buf[4096];
int n;
va_start (ap, fmt);

1
src/core/ddsi/src/q_ephash.c
View file

@ -13,7 +13,6 @@
#include <assert.h>
#include "os/os.h"
#include "ddsi/sysdeps.h"
#include "util/ut_hopscotch.h"
#include "ddsi/q_ephash.h"

1
src/core/ddsi/src/q_freelist.c
View file

@ -12,7 +12,6 @@
#include <stddef.h>
#include "os/os.h"
#include "ddsi/sysdeps.h"
#include "ddsi/q_freelist.h"
#if FREELIST_TYPE == FREELIST_ATOMIC_LIFO

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

@ -48,8 +48,6 @@
#include "ddsi/q_debmon.h"
#include "ddsi/q_init.h"
#include "ddsi/sysdeps.h"
#include "ddsi/ddsi_tran.h"
#include "ddsi/ddsi_udp.h"
#include "ddsi/ddsi_tcp.h"

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

@ -38,8 +38,6 @@
#include "ddsi/q_lease.h"
#include "ddsi/q_gc.h"
#include "ddsi/sysdeps.h"
/* This is absolute bottom for signed integers, where -x = x and yet x
!= 0 -- and note that it had better be 2's complement machine! */
#define TSCHED_NOT_ON_HEAP INT64_MIN

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

@ -377,7 +377,7 @@ int make_socket
return -2;
}
if (! Q_VALID_SOCKET (*sock))
if (! OS_VALID_SOCKET (*sock))
{
print_sockerror ("socket");
return rc;
@ -425,7 +425,7 @@ int make_socket
fail:
os_sockFree (*sock);
*sock = Q_INVALID_SOCKET;
*sock = OS_INVALID_SOCKET;
return rc;
}

1
src/core/ddsi/src/q_pcap.c
View file

@ -19,7 +19,6 @@
#include "ddsi/q_config.h"
#include "ddsi/q_globals.h"
#include "ddsi/q_bswap.h"
#include "ddsi/sysdeps.h"
#include "ddsi/q_pcap.h"
/* pcap format info taken from http://wiki.wireshark.org/Development/LibpcapFileFormat */

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

@ -40,8 +40,6 @@
#include "ddsi/q_thread.h"
#include "ddsi/q_globals.h" /* for mattr, cattr */
#include "ddsi/sysdeps.h"
/* OVERVIEW ------------------------------------------------------------
The receive path of DDSI2 has any number of receive threads that

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

@ -3051,8 +3051,8 @@ static int local_participant_cmp (const void *va, const void *vb)
{
const struct local_participant_desc *a = va;
const struct local_participant_desc *b = vb;
os_handle h1 = ddsi_conn_handle (a->m_conn);
os_handle h2 = ddsi_conn_handle (b->m_conn);
os_socket h1 = ddsi_conn_handle (a->m_conn);
os_socket h2 = ddsi_conn_handle (b->m_conn);
return (h1 == h2) ? 0 : (h1 < h2) ? -1 : 1;
}
@ -3298,7 +3298,7 @@ void trigger_recv_threads (void)
char buf[DDSI_LOCSTRLEN];
char dummy = 0;
const nn_locator_t *dst = gv.recv_threads[i].arg.u.single.loc;
ddsi_iovec_t iov;
os_iovec_t iov;
iov.iov_base = &dummy;
iov.iov_len = 1;
DDS_TRACE("trigger_recv_threads: %d single %s\n", i, ddsi_locator_to_string (buf, sizeof (buf), dst));

17
src/core/ddsi/src/q_security.c
View file

@ -11,10 +11,6 @@
*/
#ifdef DDSI_INCLUDE_ENCRYPTION
/* Ordering of the include files is utterly irrational but works.
Don't mess with it: you'll enter Dependency Hell Territory on
WinCE. Here Be Dragons. */
#include "ddsi/q_security.h"
#include "ddsi/q_config.h"
#include "ddsi/q_log.h"
@ -36,17 +32,6 @@
#include <openssl/bn.h>
#include <openssl/bio.h>
#include "ddsi/sysdeps.h"
/* We don't get FILENAME_MAX on WinCE but can't put it in the abstraction
* without complications to the examples so here we go: */
#ifndef FILENAME_MAX
#ifdef WINCE
#define FILENAME_MAX 260
#endif
#endif
/* Supported URI schema by parser */
#define URI_FILESCHEMA "file://"
@ -1661,7 +1646,7 @@ static os_ssize_t q_security_sendmsg
(
ddsi_tran_conn_t conn,
const nn_locator_t *dst,
size_t niov, ddsi_iovec_t *iov,
size_t niov, os_iovec_t *iov,
q_securityEncoderSet *codec,
os_uint32 encoderId,
os_uint32 flags

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

@ -60,7 +60,7 @@ struct entry {
struct os_sockWaitset
{
int kqueue;
os_handle pipe[2]; /* pipe used for triggering */
os_socket pipe[2]; /* pipe used for triggering */
os_atomic_uint32_t sz;
struct entry *entries;
struct os_sockWaitsetCtx ctx; /* set of descriptors being handled */
@ -477,7 +477,7 @@ int os_sockWaitsetNextEvent (os_sockWaitsetCtx ctx, ddsi_tran_conn_t * conn)
{
WSANETWORKEVENTS nwev;
int idx = ctx->index;
os_handle handle;
os_socket handle;
ctx->index = -1;
handle = ddsi_conn_handle (ctx->conns[idx]);
@ -528,7 +528,7 @@ int os_sockWaitsetNextEvent (os_sockWaitsetCtx ctx, ddsi_tran_conn_t * conn)
typedef struct os_sockWaitsetSet
{
ddsi_tran_conn_t * conns; /* connections in set */
os_handle * fds; /* file descriptors in set */
os_socket * fds; /* file descriptors in set */
unsigned sz; /* max number of fds in context */
unsigned n; /* actual number of fds in context */
} os_sockWaitsetSet;
@ -542,7 +542,7 @@ struct os_sockWaitsetCtx
struct os_sockWaitset
{
os_handle pipe[2]; /* pipe used for triggering */
os_socket pipe[2]; /* pipe used for triggering */
os_mutex mutex; /* concurrency guard */
int fdmax_plus_1; /* value for first parameter of select() */
os_sockWaitsetSet set; /* set of descriptors handled next */
@ -550,13 +550,13 @@ struct os_sockWaitset
};
#if defined (_WIN32)
static int make_pipe (os_handle fd[2])
static int make_pipe (os_socket fd[2])
{
struct sockaddr_in addr;
socklen_t asize = sizeof (addr);
os_socket listener = socket (AF_INET, SOCK_STREAM, 0);
os_socket s1 = socket (AF_INET, SOCK_STREAM, 0);
os_socket s2 = Q_INVALID_SOCKET;
os_socket s2 = OS_INVALID_SOCKET;
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
@ -755,7 +755,7 @@ void os_sockWaitsetTrigger (os_sockWaitset ws)
int os_sockWaitsetAdd (os_sockWaitset ws, ddsi_tran_conn_t conn)
{
os_handle handle = ddsi_conn_handle (conn);
os_socket handle = ddsi_conn_handle (conn);
os_sockWaitsetSet * set = &ws->set;
unsigned idx;
int ret;
@ -916,7 +916,7 @@ int os_sockWaitsetNextEvent (os_sockWaitsetCtx ctx, ddsi_tran_conn_t * conn)
while (ctx->index < ctx->set.n)
{
unsigned idx = ctx->index++;
os_handle fd = ctx->set.fds[idx];
os_socket fd = ctx->set.fds[idx];
assert(idx > 0);
if (FD_ISSET (fd, &ctx->rdset))
{

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

@ -42,8 +42,6 @@
#include "ddsi/q_freelist.h"
#include "ddsi/ddsi_serdata_default.h"
#include "ddsi/sysdeps.h"
#define NN_XMSG_MAX_ALIGN 8
#define NN_XMSG_CHUNK_SIZE 128
@ -73,7 +71,7 @@ struct nn_xmsg {
size_t sz;
int have_params;
struct ddsi_serdata *refd_payload;
ddsi_iovec_t refd_payload_iov;
os_iovec_t refd_payload_iov;
int64_t maxdelay;
#ifdef DDSI_INCLUDE_NETWORK_PARTITIONS
uint32_t encoderid;
@ -198,7 +196,7 @@ struct nn_xpack
ddsi_tran_conn_t conn;
os_sem_t sem;
size_t niov;
ddsi_iovec_t iov[NN_XMSG_MAX_MESSAGE_IOVECS];
os_iovec_t iov[NN_XMSG_MAX_MESSAGE_IOVECS];
enum nn_xmsg_dstmode dstmode;
union
@ -1322,7 +1320,7 @@ static ssize_t nn_xpack_send1 (const nn_locator_t *loc, void * varg)
{
/* We drop APPROXIMATELY a fraction of xmit_lossiness * 10**(-3)
of all packets to be sent */
if ((random () % 1000) < config.xmit_lossiness)
if ((os_random () % 1000) < config.xmit_lossiness)
{
DDS_TRACE("(dropped)");
xp->call_flags = 0;
@ -1803,11 +1801,11 @@ int nn_xpack_addmsg (struct nn_xpack *xp, struct nn_xmsg *m, const uint32_t flag
/* Append submessage; can possibly be merged with preceding iovec */
if ((char *) xp->iov[niov-1].iov_base + xp->iov[niov-1].iov_len == (char *) m->data->payload)
xp->iov[niov-1].iov_len += (ddsi_iov_len_t)m->sz;
xp->iov[niov-1].iov_len += (os_iov_len_t)m->sz;
else
{
xp->iov[niov].iov_base = m->data->payload;
xp->iov[niov].iov_len = (ddsi_iov_len_t)m->sz;
xp->iov[niov].iov_len = (os_iov_len_t)m->sz;
niov++;
}
sz += m->sz;

264
src/core/ddsi/src/sysdeps.c
View file

@ -19,227 +19,6 @@
#include "ddsi/q_config.h"
#include "ddsi/sysdeps.h"
#ifdef NEED_ARM_MEMBAR_SUPPORT
static void q_membar_autodecide (void);
void (*q_maybe_membar) (void) = q_membar_autodecide;
static void q_membar_nop (void) { }
static void q_membar_dmb (void) { MemoryBarrierARM; }
static void q_membar_autodecide (void)
{
SYSTEM_INFO sysinfo;
GetSystemInfo (&sysinfo);
assert (sysinfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_ARM);
if (sysinfo.wProcessorLevel >= 7)
{
q_maybe_membar = q_membar_dmb;
}
else
{
q_maybe_membar = q_membar_nop;
}
q_maybe_membar ();
}
#endif
/* MISSING IN OS ABSTRACTION LAYER ------------------------------------- */
#if ! SYSDEPS_HAVE_RECVMSG
ssize_t recvmsg (os_handle fd, struct msghdr *message, int flags)
{
ssize_t ret;
assert (message->msg_iovlen == 1);
#if SYSDEPS_MSGHDR_ACCRIGHTS
assert (message->msg_accrightslen == 0);
#else
assert (message->msg_controllen == 0);
#endif
#if SYSDEPS_MSGHDR_FLAGS
message->msg_flags = 0;
#endif
ret = recvfrom (fd, message->msg_iov[0].iov_base, (int)message->msg_iov[0].iov_len, flags,
message->msg_name, &message->msg_namelen); /* To fix the warning of conversion from 'size_t' to 'int', which may cause possible loss of data, type casting is done*/
#if defined (_WIN32)
/* Windows returns an error for too-large messages, Unix expects
original size and the MSG_TRUNC flag. MSDN says it is truncated,
which presumably means it returned as much of the message as it
could - so we return that the message was 1 byte larger than the
available space, and set MSG_TRUNC if we can. */
if (ret == -1 && os_getErrno () == WSAEMSGSIZE) {
ret = message->msg_iov[0].iov_len + 1;
#if SYSDEPS_MSGHDR_FLAGS
message->msg_flags |= MSG_TRUNC;
#endif
}
#endif
return ret;
}
#endif
#if ! SYSDEPS_HAVE_SENDMSG
#if !(defined _WIN32 && !defined WINCE)
ssize_t sendmsg (os_handle fd, const struct msghdr *message, int flags)
{
char stbuf[3072], *buf;
ssize_t sz, ret;
size_t sent = 0;
unsigned i;
#if SYSDEPS_MSGHDR_ACCRIGHTS
assert (message->msg_accrightslen == 0);
#else
assert (message->msg_controllen == 0);
#endif
if (message->msg_iovlen == 1)
{
/* if only one fragment, skip all copying */
buf = message->msg_iov[0].iov_base;
sz = message->msg_iov[0].iov_len;
}
else
{
/* first determine the size of the message, then select the
on-stack buffer or allocate one on the heap ... */
sz = 0;
for (i = 0; i < message->msg_iovlen; i++)
{
sz += message->msg_iov[i].iov_len;
}
if (sz <= sizeof (stbuf))
{
buf = stbuf;
}
else
{
buf = os_malloc (sz);
}
/* ... then copy data into buffer */
sz = 0;
for (i = 0; i < message->msg_iovlen; i++)
{
memcpy (buf + sz, message->msg_iov[i].iov_base, message->msg_iov[i].iov_len);
sz += message->msg_iov[i].iov_len;
}
}
while (TRUE)
{
ret = sendto (fd, buf + sent, sz - sent, flags, message->msg_name, message->msg_namelen);
if (ret < 0)
{
break;
}
sent += (size_t) ret;
if (sent == sz)
{
ret = sent;
break;
}
}
if (buf != stbuf)
{
os_free (buf);
}
return ret;
}
#else /* _WIN32 && !WINCE */
ssize_t sendmsg (os_handle fd, const struct msghdr *message, int flags)
{
DWORD sent;
ssize_t ret;
DDSI_IOVEC_MATCHES_WSABUF;
#if SYSDEPS_MSGHDR_ACCRIGHTS
assert (message->msg_accrightslen == 0);
#else
assert (message->msg_controllen == 0);
#endif
if (WSASendTo (fd, (WSABUF *) message->msg_iov, (DWORD)message->msg_iovlen, &sent, flags, (SOCKADDR *) message->msg_name, message->msg_namelen, NULL, NULL) == 0)
ret = (ssize_t) sent;
else
ret = -1;
return ret;
}
#endif
#endif
#ifndef SYSDEPS_HAVE_RANDOM
long random (void)
{
/* rand() is a really terribly bad PRNG */
union { long x; unsigned char c[4]; } t;
int i;
for (i = 0; i < 4; i++)
t.c[i] = (unsigned char) ((rand () >> 4) & 0xff);
#if RAND_MAX == INT32_MAX || RAND_MAX == 0x7fff
t.x &= RAND_MAX;
#elif RAND_MAX <= 0x7ffffffe
t.x %= (RAND_MAX+1);
#else
#error "RAND_MAX out of range"
#endif
return t.x;
}
#endif
#if SYSDEPS_HAVE_CLOCK_THREAD_CPUTIME
int64_t get_thread_cputime (void)
{
struct timespec ts;
clock_gettime (CLOCK_THREAD_CPUTIME_ID, &ts);
return ts.tv_sec * (int64_t) 1000000000 + ts.tv_nsec;
}
#else
int64_t get_thread_cputime (void)
{
return 0;
}
#endif
#if ! OS_HAVE_THREADEQUAL
int os_threadEqual (os_threadId a, os_threadId b)
{
/* on pthreads boxes, pthread_equal (a, b); as a workaround: */
return os_threadIdToInteger (a) == os_threadIdToInteger (b);
}
#endif
#if defined __sun && __GNUC__ && defined __sparc__
int __S_exchange_and_add (volatile int *mem, int val)
{
/* Hopefully cache lines are <= 64 bytes, we then use 8 bytes, 64
bytes. Should be a lot better than just one lock byte if it gets
used often, but the overhead is a bit larger, so who knows what's
best without trying it out?. We want 3 bits + 6 lsbs zero, so
need to shift addr_hash by 23 bits. */
static unsigned char locks[8 * 64];
unsigned addr_hash = 0xe2c7 * (unsigned short) ((os_address) mem >> 2);
unsigned lock_idx = (addr_hash >> 23) & ~0x1c0;
unsigned char * const lock = &locks[lock_idx];
int result, tmp;
__asm__ __volatile__("1: ldstub [%1], %0\n\t"
" cmp %0, 0\n\t"
" bne 1b\n\t"
" nop"
: "=&r" (tmp)
: "r" (lock)
: "memory");
result = *mem;
*mem += val;
__asm__ __volatile__("stb %%g0, [%0]"
: /* no outputs */
: "r" (lock)
: "memory");
return result;
}
#endif
#if !(defined __APPLE__ || defined __linux) || (__GNUC__ > 0 && (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40100)
void log_stacktrace (const char *name, os_threadId tid)
{
@ -304,46 +83,3 @@ void log_stacktrace (const char *name, os_threadId tid)
}
#endif
#if HAVE_ATOMIC_LIFO
static int os_atomic_casvoidp2 (volatile os_atomic_uintptr2_t *x, uintptr_t a0, uintptr_t b0, uintptr_t a1, uintptr_t b1)
{
os_atomic_uintptr2_t o, n;
o.s.a = a0; o.s.b = b0;
n.s.a = a1; n.s.b = b1;
return __sync_bool_compare_and_swap(&x->x, o.x, n.x);
}
void os_atomic_lifo_init (os_atomic_lifo_t *head)
{
head->aba_head.s.a = head->aba_head.s.b = 0;
}
void os_atomic_lifo_push (os_atomic_lifo_t *head, void *elem, size_t linkoff)
{
uintptr_t a0, b0;
do {
a0 = *((volatile uintptr_t *) &head->aba_head.s.a);
b0 = *((volatile uintptr_t *) &head->aba_head.s.b);
*((volatile uintptr_t *) ((char *) elem + linkoff)) = b0;
} while (!os_atomic_casvoidp2 (&head->aba_head, a0, b0, a0+1, (uintptr_t)elem));
}
void *os_atomic_lifo_pop (os_atomic_lifo_t *head, size_t linkoff) {
uintptr_t a0, b0, b1;
do {
a0 = *((volatile uintptr_t *) &head->aba_head.s.a);
b0 = *((volatile uintptr_t *) &head->aba_head.s.b);
if (b0 == 0) {
return NULL;
}
b1 = (*((volatile uintptr_t *) ((char *) b0 + linkoff)));
} while (!os_atomic_casvoidp2 (&head->aba_head, a0, b0, a0+1, b1));
return (void *) b0;
}
void os_atomic_lifo_pushmany (os_atomic_lifo_t *head, void *first, void *last, size_t linkoff)
{
uintptr_t a0, b0;
do {
a0 = *((volatile uintptr_t *) &head->aba_head.s.a);
b0 = *((volatile uintptr_t *) &head->aba_head.s.b);
*((volatile uintptr_t *) ((char *) last + linkoff)) = b0;
} while (!os_atomic_casvoidp2 (&head->aba_head, a0, b0, a0+1, (uintptr_t)first));
}
#endif

6
src/os/CMakeLists.txt
View file

@ -27,7 +27,8 @@ set(sources
src/os_iter.c
src/os_strlcpy.c
src/os_dns.c
src/os_process.c)
src/os_process.c
src/os_random.c)
string(TOLOWER ${CMAKE_SYSTEM_NAME} system_name)
set(system_sources
@ -39,7 +40,8 @@ set(system_sources
os_platform_sync.c
os_platform_thread.c
os_platform_time.c
os_platform_init.c)
os_platform_init.c
os_platform_rusage.c)
foreach(source ${system_sources})
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/${system_name}/${source}")

1
src/os/include/os/darwin/os_platform.h
View file

@ -29,6 +29,7 @@ extern "C" {
#endif
#define OS_DARWIN 1
#define OS_HAVE_GETRUSAGE 1
typedef double os_timeReal;
typedef int os_timeSec;

1
src/os/include/os/linux/os_platform.h
View file

@ -29,6 +29,7 @@ extern "C" {
#endif
#define OS_LINUX 1
#define OS_HAVE_GETRUSAGE 1
typedef double os_timeReal;
typedef int os_timeSec;

2
src/os/include/os/os.h
View file

@ -44,5 +44,7 @@
#include "os_iter.h"
#include "os_log.h"
#include "os_strlcpy.h"
#include "os_random.h"
#include "os_rusage.h"
#endif

14
src/os/include/os/os_atomics.h
View file

@ -157,10 +157,24 @@ OSAPI_EXPORT int os_atomic_cas64 (volatile os_atomic_uint64_t *x, uint64_t exp,
#endif
OSAPI_EXPORT int os_atomic_casptr (volatile os_atomic_uintptr_t *x, uintptr_t exp, uintptr_t des);
OSAPI_EXPORT int os_atomic_casvoidp (volatile os_atomic_voidp_t *x, void *exp, void *des);
#if OS_ATOMIC_LIFO_SUPPORT
OSAPI_EXPORT int os_atomic_casvoidp2 (volatile os_atomic_uintptr2_t *x, uintptr_t a0, uintptr_t b0, uintptr_t a1, uintptr_t b1);
#endif
/* FENCES */
OSAPI_EXPORT void os_atomic_fence (void);
OSAPI_EXPORT void os_atomic_fence_acq (void);
OSAPI_EXPORT void os_atomic_fence_rel (void);
/* LIFO */
#if OS_ATOMIC_LIFO_SUPPORT
typedef struct os_atomic_lifo {
os_atomic_uintptr2_t aba_head;
} os_atomic_lifo_t;
OSAPI_EXPORT void os_atomic_lifo_init (os_atomic_lifo_t *head);
OSAPI_EXPORT void os_atomic_lifo_push (os_atomic_lifo_t *head, void *elem, size_t linkoff);
OSAPI_EXPORT void *os_atomic_lifo_pop (os_atomic_lifo_t *head, size_t linkoff);
OSAPI_EXPORT void os_atomic_lifo_pushmany (os_atomic_lifo_t *head, void *first, void *last, size_t linkoff);
#endif /* OS_ATOMIC_LIFO_SUPPORT */
#endif /* OS_HAVE_INLINE */

23
src/os/include/os/os_atomics_gcc.h
View file

@ -25,6 +25,18 @@
#endif
#endif
#if ( OS_ATOMIC64_SUPPORT && __GCC_HAVE_SYNC_COMPARE_AND_SWAP_16) || \
(!OS_ATOMIC64_SUPPORT && __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)
#define OS_ATOMIC_LIFO_SUPPORT 1
#if OS_ATOMIC64_SUPPORT
typedef union { __int128 x; struct { uintptr_t a, b; } s; } os_atomic_uintptr2_t;
#else
typedef union { uint64_t x; struct { uintptr_t a, b; } s; } os_atomic_uintptr2_t;
#endif
#endif
#if ! OS_ATOMICS_OMIT_FUNCTIONS
/* Eliminate C warnings */
@ -73,6 +85,9 @@ OS_INLINE uintptr_t os_atomic_orptr_nv (volatile os_atomic_uintptr_t *x, uintptr
OS_INLINE int os_atomic_cas32 (volatile os_atomic_uint32_t *x, uint32_t exp, uint32_t des);
OS_INLINE int os_atomic_casptr (volatile os_atomic_uintptr_t *x, uintptr_t exp, uintptr_t des);
OS_INLINE int os_atomic_casvoidp (volatile os_atomic_voidp_t *x, void *exp, void *des);
#if OS_ATOMIC_LIFO_SUPPORT
OS_INLINE int os_atomic_casvoidp2 (volatile os_atomic_uintptr2_t *x, uintptr_t a0, uintptr_t b0, uintptr_t a1, uintptr_t b1);
#endif
OS_INLINE void os_atomic_fence (void);
OS_INLINE void os_atomic_fence_acq (void);
OS_INLINE void os_atomic_fence_rel (void);
@ -325,6 +340,14 @@ OS_INLINE int os_atomic_casptr (volatile os_atomic_uintptr_t *x, uintptr_t exp,
OS_INLINE int os_atomic_casvoidp (volatile os_atomic_voidp_t *x, void *exp, void *des) {
return os_atomic_casptr (x, (uintptr_t) exp, (uintptr_t) des);
}
#if OS_ATOMIC_LIFO_SUPPORT
OS_INLINE int os_atomic_casvoidp2 (volatile os_atomic_uintptr2_t *x, uintptr_t a0, uintptr_t b0, uintptr_t a1, uintptr_t b1) {
os_atomic_uintptr2_t o, n;
o.s.a = a0; o.s.b = b0;
n.s.a = a1; n.s.b = b1;
return __sync_bool_compare_and_swap (&x->x, o.x, n.x);
}
#endif /* OS_ATOMIC_LIFO_SUPPORT */
/* FENCES */

27
src/os/include/os/os_random.h Normal file
View file

@ -0,0 +1,27 @@
/*
* Copyright(c) 2006 to 2018 ADLINK Technology Limited and others
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
* v. 1.0 which is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
#ifndef OS_RANDOM_H
#define OS_RANDOM_H
#include "os/os_defs.h"
#if defined (__cplusplus)
extern "C" {
#endif
OSAPI_EXPORT long os_random(void);
#if defined (__cplusplus)
}
#endif
#endif /* OS_RANDOM_H */

35
src/os/include/os/os_rusage.h Normal file
View file

@ -0,0 +1,35 @@
/*
* Copyright(c) 2006 to 2018 ADLINK Technology Limited and others
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
* v. 1.0 which is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
#ifndef OS_RUSAGE_H
#define OS_RUSAGE_H
#include "os/os_defs.h"
typedef struct {
os_time utime; /* User CPU time used. */
os_time stime; /* System CPU time used. */
size_t maxrss; /* Maximum resident set size in bytes. */
size_t idrss; /* Integral unshared data size. Not maintained on (at least)
Linux and Windows. */
size_t nvcsw; /* Voluntary context switches. Not maintained on Windows. */
size_t nivcsw; /* Involuntary context switches. Not maintained on Windows. */
} os_rusage_t;
#define OS_RUSAGE_SELF 0
#define OS_RUSAGE_THREAD 1
_Pre_satisfies_((who == OS_RUSAGE_SELF) || \
(who == OS_RUSAGE_THREAD))
_Success_(return == 0)
int os_getrusage(_In_ int who, _Out_ os_rusage_t *usage);
#endif /* OS_GETRUSAGE_H */

3
src/os/include/os/os_socket.h
View file

@ -36,6 +36,7 @@ extern "C" {
* @addtogroup OS_NET
* @{
*/
#define OS_VALID_SOCKET(s) ((s) != OS_INVALID_SOCKET)
/**
* Socket handle type. SOCKET on windows, int otherwise.
@ -235,7 +236,7 @@ extern "C" {
*/
OSAPI_EXPORT int
os_sockaddr_is_unspecified(
const os_sockaddr *const sa) __nonnull_all__;
_In_ const os_sockaddr *__restrict sa) __nonnull_all__;
/**
* Check this address to see if it represents loopback.

2
src/os/include/os/os_thread.h
View file

@ -127,6 +127,8 @@ extern "C" {
OSAPI_EXPORT os_threadId
os_threadIdSelf(void);
int os_threadEqual (os_threadId a, os_threadId b);
/** \brief Wait for the termination of the identified thread
*
* If the identified thread is still running, wait for its termination

17
src/os/include/os/posix/os_platform_socket.h
View file

@ -68,9 +68,24 @@ extern "C" {
typedef int os_socket; /* signed */
#define PRIsock "d"
#define OS_SOCKET_INVALID (-1)
#define OS_INVALID_SOCKET (-1)
typedef struct iovec os_iovec_t;
typedef size_t os_iov_len_t;
#if defined(__sun) && !defined(_XPG4_2)
#define msg_accrights msg_control
#define msg_accrightslen msg_controllen
#define OS_MSGHDR_FLAGS 0
#else
#define OS_MSGHDR_FLAGS 1
#endif
#if defined(__linux)
typedef size_t os_msg_iovlen_t;
#else /* POSIX says int (which macOS, FreeBSD, Solaris do) */
typedef int os_msg_iovlen_t;
#endif
#if defined (__cplusplus)
}

1
src/os/include/os/solaris/os_platform.h
View file

@ -29,6 +29,7 @@ extern "C" {
#endif
#define OS_SOLARIS 1
#define OS_HAVE_GETRUSAGE 1
typedef double os_timeReal;
typedef int os_timeSec;

1
src/os/include/os/vxworks/os_platform.h
View file

@ -98,6 +98,7 @@ extern "C" {
#endif
#define OS_VXWORKS 1
#define OS_HAVE_GETRUSAGE 0
typedef double os_timeReal;
typedef int os_timeSec;

1
src/os/include/os/windows/os_platform.h
View file

@ -34,6 +34,7 @@ extern "C" {
#endif
#define OS_WIN32 1
#define OS_HAVE_GETRUSAGE 1
typedef double os_timeReal;
typedef int os_timeSec;

33
src/os/include/os/windows/os_platform_socket.h
View file

@ -43,7 +43,7 @@ extern "C" {
#define os_sockENOMEM WSABASEERR
#define os_sockENOSR WSABASEERR
#define os_sockENOENT WSABASEERR
#define os_sockEPERM WSABASEERR
#define os_sockEPERM WSAEACCES
#define os_sockEINTR WSAEINTR
#define os_sockEBADF WSAEBADF
#define os_sockEACCES WSAEACCES
@ -61,7 +61,36 @@ extern "C" {
typedef SOCKET os_socket;
#define PRIsock PRIuPTR
#define OS_SOCKET_INVALID (-1)
#define OS_INVALID_SOCKET (INVALID_SOCKET)
typedef unsigned os_iov_len_t;
typedef struct os_iovec {
os_iov_len_t iov_len;
void *iov_base;
} os_iovec_t;
typedef DWORD os_msg_iovlen_t;
struct msghdr {
void *msg_name;
socklen_t msg_namelen;
os_iovec_t *msg_iov;
os_msg_iovlen_t msg_iovlen;
void *msg_control;
size_t msg_controllen;
int msg_flags;
};
#define OS_MSGHDR_FLAGS 1
/* Only implements iovec of length 1, no control */
ssize_t recvmsg (os_socket fd, struct msghdr *message, int flags);
ssize_t sendmsg (os_socket fd, const struct msghdr *message, int flags);
#ifndef MSG_TRUNC
#define MSG_TRUNC 1
#endif
void os_socketModuleInit(void);
void os_socketModuleExit(void);

37
src/os/src/os_atomics.c
View file

@ -14,3 +14,40 @@
#define OS_ATOMICS_OMIT_FUNCTIONS 0 /* force inclusion of functions defs */
#include "os/os.h"
#if OS_ATOMIC_LIFO_SUPPORT
void os_atomic_lifo_init (os_atomic_lifo_t *head)
{
head->aba_head.s.a = head->aba_head.s.b = 0;
}
void os_atomic_lifo_push (os_atomic_lifo_t *head, void *elem, size_t linkoff)
{
uintptr_t a0, b0;
do {
a0 = *((volatile uintptr_t *) &head->aba_head.s.a);
b0 = *((volatile uintptr_t *) &head->aba_head.s.b);
*((volatile uintptr_t *) ((char *) elem + linkoff)) = b0;
} while (!os_atomic_casvoidp2 (&head->aba_head, a0, b0, a0+1, (uintptr_t)elem));
}
void *os_atomic_lifo_pop (os_atomic_lifo_t *head, size_t linkoff) {
uintptr_t a0, b0, b1;
do {
a0 = *((volatile uintptr_t *) &head->aba_head.s.a);
b0 = *((volatile uintptr_t *) &head->aba_head.s.b);
if (b0 == 0) {
return NULL;
}
b1 = (*((volatile uintptr_t *) ((char *) b0 + linkoff)));
} while (!os_atomic_casvoidp2 (&head->aba_head, a0, b0, a0+1, b1));
return (void *) b0;
}
void os_atomic_lifo_pushmany (os_atomic_lifo_t *head, void *first, void *last, size_t linkoff)
{
uintptr_t a0, b0;
do {
a0 = *((volatile uintptr_t *) &head->aba_head.s.a);
b0 = *((volatile uintptr_t *) &head->aba_head.s.b);
*((volatile uintptr_t *) ((char *) last + linkoff)) = b0;
} while (!os_atomic_casvoidp2 (&head->aba_head, a0, b0, a0+1, (uintptr_t)first));
}
#endif

42
src/os/src/os_random.c Normal file
View file

@ -0,0 +1,42 @@
/*
* Copyright(c) 2006 to 2018 ADLINK Technology Limited and others
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
* v. 1.0 which is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
#include <assert.h>
#include <stdlib.h>
#if WIN32
#define _CRT_RAND_S
#include <errno.h>
long random (void)
{
/* rand() is a really terribly bad PRNG */
/* FIXME: Indeed (especially if not seeded), use rand_s instead. */
union { long x; unsigned char c[4]; } t;
int i;
for (i = 0; i < 4; i++)
t.c[i] = (unsigned char) ((rand () >> 4) & 0xff);
#if RAND_MAX == INT32_MAX || RAND_MAX == 0x7fff
t.x &= RAND_MAX;
#elif RAND_MAX <= 0x7ffffffe
t.x %= (RAND_MAX+1);
#else
#error "RAND_MAX out of range"
#endif
return t.x;
}
#endif
long os_random(void)
{
/* FIXME: Not MT-safe, should use random_r (or a real PRNG) instead. */
return random();
}

2
src/os/src/os_socket.c
View file

@ -124,7 +124,7 @@ os_sockaddr_is_loopback(
#if OS_SOCKET_HAS_IPV6
case AF_INET6:
return IN6_IS_ADDR_LOOPBACK(
((const os_sockaddr_in6 *)sa)->sin6_addr);
&((const os_sockaddr_in6 *)sa)->sin6_addr);
#endif /* OS_SOCKET_HAS_IPV6 */
case AF_INET:
return (((const os_sockaddr_in *)sa)->sin_addr.s_addr

6
src/os/src/os_thread.c
View file

@ -37,3 +37,9 @@ os_threadAttrInit (
threadAttr->schedPriority = 0;
threadAttr->stackSize = 0;
}
int os_threadEqual (os_threadId a, os_threadId b)
{
/* on pthreads boxes, pthread_equal (a, b); as a workaround: */
return os_threadIdToInteger (a) == os_threadIdToInteger (b);
}

93
src/os/src/posix/os_platform_rusage.c Normal file
View file

@ -0,0 +1,93 @@
/*
* Copyright(c) 2006 to 2018 ADLINK Technology Limited and others
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
* v. 1.0 which is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
#define _GNU_SOURCE /* Required for RUSAGE_THREAD. */
#include <assert.h>
#include <errno.h>
#include <string.h>
#include <sys/resource.h>
#if defined(__APPLE__)
#include <mach/mach_init.h>
#include <mach/mach_port.h>
#include <mach/thread_act.h>
#endif
#include "os/os.h"
_Pre_satisfies_((who == OS_RUSAGE_SELF) || \
(who == OS_RUSAGE_THREAD))
_Success_(return == 0)
int os_getrusage(_In_ int who, _Out_ os_rusage_t *usage)
{
int err = 0;
struct rusage buf;
assert(who == OS_RUSAGE_SELF || who == OS_RUSAGE_THREAD);
assert(usage != NULL);
memset(&buf, 0, sizeof(buf));
#if defined(__linux)
if (getrusage(who, &buf) == -1) {
err = errno;
} else {
buf.ru_maxrss *= 1024;
}
#else
if (getrusage(RUSAGE_SELF, &buf) == -1) {
err = errno;
} else if (who == OS_RUSAGE_THREAD) {
memset(&buf.ru_utime, 0, sizeof(buf.ru_utime));
memset(&buf.ru_stime, 0, sizeof(buf.ru_stime));
buf.ru_nvcsw = 0;
buf.ru_nivcsw = 0;
#if defined(__APPLE__)
kern_return_t ret;
mach_port_t thr;
mach_msg_type_number_t cnt;
thread_basic_info_data_t info;
thr = mach_thread_self();
assert(thr != MACH_PORT_DEAD);
if (thr == MACH_PORT_NULL) {
/* Resource shortage prevented reception of send right. */
err = ENOMEM;
} else {
cnt = THREAD_BASIC_INFO_COUNT;
ret = thread_info(
thr, THREAD_BASIC_INFO, (thread_info_t)&info, &cnt);
assert(ret != KERN_INVALID_ARGUMENT);
/* Assume MIG_ARRAY_TOO_LARGE will not happen. */
buf.ru_utime.tv_sec = info.user_time.seconds;
buf.ru_utime.tv_usec = info.user_time.microseconds;
buf.ru_stime.tv_sec = info.system_time.seconds;
buf.ru_stime.tv_usec = info.system_time.microseconds;
mach_port_deallocate(mach_task_self(), thr);
}
#endif /* __APPLE__ */
}
#endif /* __linux */
if (err == 0) {
usage->utime.tv_sec = (os_timeSec)buf.ru_utime.tv_sec;
usage->utime.tv_nsec = (int32_t)buf.ru_utime.tv_usec * 1000;
usage->stime.tv_sec = (os_timeSec)buf.ru_stime.tv_sec;
usage->stime.tv_nsec = (int32_t)buf.ru_stime.tv_usec * 1000;
usage->maxrss = (size_t)buf.ru_maxrss;
usage->idrss = (size_t)buf.ru_idrss;
usage->nvcsw = (size_t)buf.ru_nvcsw;
usage->nivcsw = (size_t)buf.ru_nivcsw;
}
return err;
}

56
src/os/src/windows/os_platform_rusage.c Normal file
View file

@ -0,0 +1,56 @@
/*
* Copyright(c) 2006 to 2018 ADLINK Technology Limited and others
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
* v. 1.0 which is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
#include <assert.h>
#include <stdint.h>
#include "os/os.h"
#include <psapi.h>
static void
filetime_to_time(_In_ const FILETIME *ft, _Out_ os_time *t)
{
/* FILETIME structures express times in 100-nanosecond time units. */
uint64_t ns = ((ft->dwHighDateTime << 31) + (ft->dwLowDateTime));
t->tv_sec = (os_timeSec)(ns / (1000 * 1000 * 10));
t->tv_nsec = (int32_t)(ns % (1000 * 1000 * 10)) * 100;
}
_Pre_satisfies_((who == OS_RUSAGE_SELF) || \
(who == OS_RUSAGE_THREAD))
_Success_(return == 0)
int os_getrusage(_In_ int who, _Out_ os_rusage_t *usage)
{
FILETIME stime, utime, ctime, etime;
PROCESS_MEMORY_COUNTERS pmctrs;
assert(who == OS_RUSAGE_SELF || who == OS_RUSAGE_THREAD);
assert(usage != NULL);
/* Memory counters are per process, but populate them if thread resource
usage is requested to keep in sync with Linux. */
if ((!GetProcessMemoryInfo(GetCurrentProcess(), &pmctrs, sizeof(pmctrs)))
|| (who == OS_RUSAGE_SELF &&
!GetProcessTimes(GetCurrentProcess(), &ctime, &etime, &stime, &utime))
|| (who == OS_RUSAGE_THREAD &&
!GetThreadTimes(GetCurrentThread(), &ctime, &etime, &stime, &utime)))
{
return GetLastError();
}
memset(usage, 0, sizeof(*usage));
filetime_to_time(&stime, &usage->stime);
filetime_to_time(&utime, &usage->utime);
usage->maxrss = pmctrs.PeakWorkingSetSize;
return 0;
}

49
src/os/src/windows/os_platform_socket.c
View file

@ -548,3 +548,52 @@ os__sockSelect(
return r;
}
ssize_t recvmsg (os_socket fd, struct msghdr *message, int flags)
{
ssize_t ret;
assert (message->msg_iovlen == 1);
assert (message->msg_controllen == 0);
message->msg_flags = 0;
ret = recvfrom (fd, message->msg_iov[0].iov_base, (int)message->msg_iov[0].iov_len, flags,
message->msg_name, &message->msg_namelen); /* To fix the warning of conversion from 'size_t' to 'int', which may cause possible loss of data, type casting is done*/
/* Windows returns an error for too-large messages, Unix expects
original size and the MSG_TRUNC flag. MSDN says it is truncated,
which presumably means it returned as much of the message as it
could - so we return that the message was 1 byte larger than the
available space, and set MSG_TRUNC if we can. */
if (ret == -1 && GetLastError () == WSAEMSGSIZE) {
ret = message->msg_iov[0].iov_len + 1;
message->msg_flags |= MSG_TRUNC;
}
return ret;
}
#define ASSERT_IOVEC_MATCHES_WSABUF do { \
struct iovec_matches_WSABUF { \
char sizeof_matches[sizeof(struct os_iovec) == sizeof(WSABUF) ? 1 : -1]; \
char base_off_matches[offsetof(struct os_iovec, iov_base) == offsetof(WSABUF, buf) ? 1 : -1]; \
char base_size_matches[sizeof(((struct os_iovec *)8)->iov_base) == sizeof(((WSABUF *)8)->buf) ? 1 : -1]; \
char len_off_matches[offsetof(struct os_iovec, iov_len) == offsetof(WSABUF, len) ? 1 : -1]; \
char len_size_matches[sizeof(((struct os_iovec *)8)->iov_len) == sizeof(((WSABUF *)8)->len) ? 1 : -1]; \
}; } while (0)
ssize_t sendmsg (os_socket fd, const struct msghdr *message, int flags)
{
DWORD sent;
ssize_t ret;
ASSERT_IOVEC_MATCHES_WSABUF;
assert(message->msg_controllen == 0);
if (WSASendTo (fd, (WSABUF *) message->msg_iov, (DWORD)message->msg_iovlen, &sent, flags, (SOCKADDR *) message->msg_name, message->msg_namelen, NULL, NULL) == 0)
ret = (ssize_t) sent;
else
ret = -1;
return ret;
}

4
src/os/tests/ifaddrs.c
View file

@ -74,9 +74,9 @@ CU_Test(os_getifaddrs, ipv4)
CU_ASSERT_EQUAL(ifa->addr->sa_family, AF_INET);
if (ifa->addr->sa_family == AF_INET) {
if (ifa->flags & IFF_LOOPBACK) {
CU_ASSERT(os_sockaddrIsLoopback(ifa->addr));
CU_ASSERT(os_sockaddr_is_loopback(ifa->addr));
} else {
CU_ASSERT(!os_sockaddrIsLoopback(ifa->addr));
CU_ASSERT(!os_sockaddr_is_loopback(ifa->addr));
}
seen = 1;
}