[Spice-devel] [PATCH spice-common v3 1/3] agent-interface: introduce the core of the Agent Interface
Kevin Pouget
kpouget at redhat.com
Fri Oct 18 15:51:17 UTC 2019
When initialized (recorder_initialization), the Agent Interface launch
a GThread (handle_communications) that opens a TCP server socket and
waits for Smart Local Agent connections. When a Local Agent connects
to the sockets, the communication is initialized
(agent_initialize_communication), the communication socket is stored
and the list of Recorders is sent. In return, the local agent
indicates which recorders to enable.
On the SPICE side, the Agent Interface handles the record() calls
(recorder_append*). When a record is received from SPICE, and if the
recorder is enabled, the record entry is sent through the TCP
connection. Otherwise, the record is dropped.
Signed-off-by: Kevin Pouget <kpouget at redhat.com>
---
v2->v3: unchanged
---
common/agent_interface.c | 467 +++++++++++++++++++++++++++++++
common/agent_interface.h | 542 ++++++++++++++++++++++++++++++++++++
tests/test-dummy-recorder.c | 3 +-
3 files changed, 1011 insertions(+), 1 deletion(-)
create mode 100644 common/agent_interface.c
create mode 100644 common/agent_interface.h
diff --git a/common/agent_interface.c b/common/agent_interface.c
new file mode 100644
index 0000000..768b6a9
--- /dev/null
+++ b/common/agent_interface.c
@@ -0,0 +1,467 @@
+/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ Copyright (C) 2019 Red Hat, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <config.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <string.h>
+#include <glib.h>
+#include <stdio.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <unistd.h>
+#include <arpa/inet.h>
+#include <sys/eventfd.h>
+#include <errno.h>
+#include <poll.h>
+
+#include <common/agent_interface.h>
+
+typedef struct sockaddr SA;
+
+static GThread *recorder_comm_thr;
+static bool agent_terminated = false;
+static int terminate_efd = -1;
+static FILE *communication_f = NULL;
+
+#define NB_MAX_RECORDERS 16
+static recorder_info *recorders[NB_MAX_RECORDERS];
+static uint32_t nb_recorders = 0;
+
+static uintptr_t recorder_tick(void);
+
+#ifndef RECORDER_HZ
+#define RECORDER_HZ 1000000
+#endif // RECORDER_HZ
+
+static GMutex mutex_socket;
+
+static int agent_initialize_communication(int socket)
+{
+ uint32_t i;
+ int ret = -1;
+ FILE *socket_f;
+
+ g_mutex_lock(&mutex_socket);
+
+ if (communication_f != NULL) {
+ g_warning("A client is already connected, rejecting the connection.");
+
+ goto unlock;
+ }
+
+ socket_f = fdopen(socket, "w+b");
+
+ fprintf(socket_f, "Recorders: ");
+ for (i = 0; i < nb_recorders; i++) {
+ g_debug("Sending %s", recorders[i]->name);
+ fprintf(socket_f, "%s;", recorders[i]->name);
+ }
+ fprintf(socket_f, "\n");
+ fflush(socket_f);
+
+ for (i = 0; i < nb_recorders; i++) {
+ char enable;
+
+ if (read(socket, &enable, sizeof(enable)) != sizeof(enable)) {
+ g_warning("Invalid read on the client socket");
+
+ goto unlock;
+ }
+ if (enable != '0' && enable != '1') {
+ g_critical("Invalid enable-value received for recorder '%s': %u",
+ recorders[i]->name, enable);
+
+ goto unlock;
+ }
+
+ if (enable == '0') {
+ continue;
+ }
+
+ recorders[i]->trace = 1;
+ g_info("Enable recorder '%s'", recorders[i]->name);
+ }
+
+ communication_f = socket_f;
+ ret = 0;
+
+unlock:
+ g_mutex_unlock(&mutex_socket);
+
+ return ret;
+}
+
+static void agent_finalize_communication(int socket)
+{
+ uint32_t i;
+ g_info("Communication socket closed.");
+
+ g_mutex_lock(&mutex_socket);
+ g_assert(socket == fileno(communication_f));
+
+ fclose(communication_f);
+ communication_f = NULL;
+
+ for (i = 0; i < nb_recorders; i++) {
+ recorders[i]->trace = 0;
+ }
+ g_mutex_unlock(&mutex_socket);
+}
+
+static int agent_process_communication(int socket)
+{
+ static char msg_in[128];
+
+ static long unsigned int len = 0;
+
+ g_assert(socket == fileno(communication_f));
+
+ int nbytes = read(socket, msg_in + len, 1);
+
+ if (nbytes < 0 && errno == EINTR) {
+ return 0;
+ }
+
+ if (nbytes <= 0) {
+ agent_finalize_communication(socket);
+ return -1; // socket closed
+ }
+
+ if (msg_in[len] == '\0') {
+ // TODO: process quality indicator
+ len = 0;
+ return 0;
+ }
+
+ len += nbytes;
+
+ if (len >= sizeof(msg_in) - 1) {
+ msg_in[sizeof(msg_in) - 1] = '\0';
+ g_warning("Invalid message received (too long?): %s", msg_in);
+ len = 0;
+ }
+
+ return 0;
+}
+
+static int make_socket(guint port)
+{
+ struct sockaddr_in servaddr;
+ int listen_socket = socket(AF_INET, SOCK_STREAM, 0);
+
+ if (listen_socket == -1) {
+ g_critical("socket creation failed");
+ return -1;
+ }
+
+ int enable = 1;
+ if (setsockopt(listen_socket, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int)) < 0) {
+ g_critical("setsockopt(SO_REUSEADDR) failed");
+ close(listen_socket);
+ return -1;
+ }
+
+ memset(&servaddr, 0, sizeof(servaddr));
+
+ servaddr.sin_family = AF_INET;
+ servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
+ servaddr.sin_port = htons(port);
+
+ if (bind(listen_socket, (SA *) &servaddr, sizeof(servaddr)) != 0) {
+ g_critical("socket bind failed");
+ close(listen_socket);
+ return -1;
+ }
+
+ return listen_socket;
+}
+
+static gpointer handle_communications(gpointer user_data)
+{
+ struct pollfd fds[3];
+ int nb_fd = 0;
+ int listen_socket;
+ int i;
+ guint port = GPOINTER_TO_UINT(user_data);
+
+ listen_socket = make_socket(port);
+ if (listen_socket < 0) {
+ return NULL;
+ }
+
+ g_debug("Listening!");
+
+ if ((listen(listen_socket, 1)) != 0) {
+ g_critical("listen failed: %m");
+ return NULL;
+ }
+
+ fds[0].fd = terminate_efd;
+ fds[0].events = POLLIN;
+ fds[1].fd = listen_socket;
+ fds[1].events = POLLIN;
+ nb_fd = 2;
+
+ while (!agent_terminated) {
+
+ /* Block until input arrives on one or more active sockets. */
+ int ret = poll(fds, nb_fd, -1);
+
+ if (ret < 0) {
+ g_critical("poll failed: %m");
+ break;
+ }
+
+ /* Service all the sockets with input pending. */
+ for (i = 0; i < nb_fd; i++) {
+ int fd = fds[i].fd;
+ if (fd == terminate_efd) {
+ if (fds[i].revents & POLLIN) {
+ g_assert(agent_terminated);
+ break;
+ }
+ } else if (fd == listen_socket) {
+ if (fds[i].revents & ~POLLIN) {
+ g_critical("server socket closed");
+ break;
+ }
+ if (!(fds[i].revents & POLLIN)) {
+ continue;
+ }
+
+ /* Connection request on original socket. */
+ int new_fd = accept(listen_socket, NULL, NULL);
+
+ if (new_fd < 0) {
+ g_critical("accept failed: %m");
+ break;
+ }
+
+ if (nb_fd == 3) {
+ close(new_fd);
+ g_warning("Too many clients accepted ...");
+ continue;
+ }
+
+ g_debug("Agent Interface: client connected!");
+
+ if (agent_initialize_communication(new_fd)) {
+ close(new_fd);
+ g_warning("Initialization failed ...");
+ continue;
+ }
+
+ fds[nb_fd].fd = new_fd;
+ fds[nb_fd].events = POLLIN;
+ nb_fd++;
+
+ /* fds array modified, restart the poll. */
+ break;
+ } else {
+ if (!(fds[i].revents & POLLIN)) {
+ continue;
+ }
+
+ /* Data arriving on an already-connected socket. */
+ if (agent_process_communication(fd) < 0) {
+ nb_fd--;
+ }
+ }
+ }
+ }
+
+ close(terminate_efd);
+ close(listen_socket);
+
+ g_info("Agent interface thread: bye!");
+ return NULL;
+}
+
+static void recorder_deregister(void);
+
+static void recorder_initialization(unsigned int port)
+{
+ GError *error = NULL;
+
+ terminate_efd = eventfd(0, 0);
+ if (terminate_efd == -1) {
+ g_critical("eventfd failed: %m");
+ return;
+ }
+
+ recorder_comm_thr = g_thread_try_new("smart_agent_interface",
+ handle_communications,
+ GUINT_TO_POINTER((guint) port), &error);
+ if (error) {
+ g_assert(!recorder_comm_thr);
+ g_critical("Error: Could not start the agent interface thread: %s", error->message);
+ g_error_free(error);
+ return;
+ }
+
+ atexit(recorder_deregister);
+}
+
+static void recorder_interrupt_communications(void)
+{
+ agent_terminated = true;
+
+ uint64_t msg = 1;
+ ssize_t s = write(terminate_efd, &msg, sizeof(uint64_t));
+
+ if (s != sizeof(uint64_t)) {
+ g_warning("failed to send recorder thread termination event: %m");
+ }
+}
+
+
+static void recorder_deregister(void)
+{
+ if (recorder_comm_thr) {
+ recorder_interrupt_communications();
+ g_thread_join(recorder_comm_thr);
+ recorder_comm_thr = NULL;
+ }
+}
+
+void recorder_activate(recorder_info *recorder)
+{
+ if (nb_recorders >= NB_MAX_RECORDERS) {
+ g_critical("Too many recorders configured (nb max: %d)", NB_MAX_RECORDERS);
+ return;
+ }
+
+ recorders[nb_recorders] = recorder;
+ nb_recorders++;
+}
+
+static void do_send_entry(FILE *dest, recorder_info *info, recorder_entry *entry, va_list args)
+{
+ fprintf(dest, "Name: %s\nFunction: %s\nTime: %lu\n",
+ info->name, entry->where, entry->timestamp);
+
+ vfprintf(dest, entry->format, args);
+ fprintf(dest, "\n\n");
+
+ fflush(dest);
+}
+
+
+static void recorder_trace_entry(recorder_info *info, recorder_entry *entry, ...)
+// ----------------------------------------------------------------------------
+// Show a recorder entry when a trace is enabled
+// ----------------------------------------------------------------------------
+{
+ va_list args;
+
+ if (strchr(entry->format, '\n') != NULL) {
+ g_critical("Agent records cannot contain '\n' char ... (%s)", entry->where);
+ return;
+ }
+
+ // send info/entry to the socket
+ g_mutex_lock(&mutex_socket);
+
+ if (communication_f == NULL) {
+ g_mutex_unlock(&mutex_socket);
+ return;
+ }
+
+ va_start(args, entry);
+ do_send_entry(communication_f, info, entry, args);
+ va_end(args);
+
+ if (g_strcmp0(g_getenv("SPICE_AGENT_LOG_RECORDS"), "1") == 0) {
+ va_start(args, entry);
+ do_send_entry(stderr, info, entry, args);
+ va_end(args);
+ }
+
+ g_mutex_unlock(&mutex_socket);
+}
+
+void recorder_append(recorder_info *rec,
+ const char *where,
+ const char *format,
+ uintptr_t a0,
+ uintptr_t a1,
+ uintptr_t a2,
+ uintptr_t a3)
+// ----------------------------------------------------------------------------
+// Enter a record entry in ring buffer with given set of args
+// ----------------------------------------------------------------------------
+{
+ recorder_entry entry;
+
+ if (!rec->trace) {
+ return;
+ }
+
+ entry.format = format;
+ entry.timestamp = recorder_tick();
+ entry.where = where;
+
+ recorder_trace_entry(rec, &entry, a0, a1, a2, a3);
+}
+
+void recorder_append2(recorder_info *rec,
+ const char *where,
+ const char *format,
+ uintptr_t a0,
+ uintptr_t a1,
+ uintptr_t a2,
+ uintptr_t a3,
+ uintptr_t a4,
+ uintptr_t a5,
+ uintptr_t a6,
+ uintptr_t a7)
+// ----------------------------------------------------------------------------
+// Enter a double record (up to 8 args)
+// ----------------------------------------------------------------------------
+{
+ recorder_entry entry;
+
+ if (!rec->trace) {
+ return;
+ }
+
+ entry.format = format;
+ entry.timestamp = recorder_tick();
+ entry.where = where;
+
+ recorder_trace_entry(rec, &entry, a0, a1, a2, a3, a4, a5, a6, a7);
+}
+
+// ============================================================================
+//
+// Support functions
+//
+// ============================================================================
+
+static uintptr_t recorder_tick(void)
+// ----------------------------------------------------------------------------
+// Return the "ticks" as stored in the recorder
+// ----------------------------------------------------------------------------
+{
+ struct timeval t;
+
+ gettimeofday(&t, NULL);
+
+ return t.tv_sec * RECORDER_HZ + t.tv_usec / (1000000 / RECORDER_HZ);
+}
diff --git a/common/agent_interface.h b/common/agent_interface.h
new file mode 100644
index 0000000..042120e
--- /dev/null
+++ b/common/agent_interface.h
@@ -0,0 +1,542 @@
+#pragma once
+
+// *****************************************************************************
+// This software is licensed under the GNU Lesser General Public License v2+
+// (C) 2017-2019, Christophe de Dinechin <christophe at dinechin.org>
+// *****************************************************************************
+// This file was part of Recorder
+//
+// Recorder is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 2 of the License, or
+// (at your option) any later version.
+//
+// Recorder is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with Recorder, in a file named COPYING.
+// If not, see <https://www.gnu.org/licenses/>.
+// *****************************************************************************
+/* This file is based on Recorder's recorder.h file, that describes a general-
+ * purpose instrumentation interface. agent_interface.h is a trimmed-down
+ * version of it. */
+
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+static inline void
+recorder_dump_on_common_signals(unsigned add, unsigned remove)
+{
+}
+
+// ============================================================================
+//
+// Recorder data structures
+//
+// ============================================================================
+
+typedef struct recorder_entry
+/// ---------------------------------------------------------------------------
+/// Entry in the flight recorder.
+///----------------------------------------------------------------------------
+/// Notice that the arguments are stored as "intptr_t" because that type
+/// is guaranteed to be the same size as a pointer. This allows us to
+/// properly align recorder entries to powers of 2 for efficiency.
+/// Also read explanations of \ref _recorder_double and \ref _recorder_float
+/// below regarding how to use floating-point with the recorder.
+{
+ const char *format; ///< Printf-style format for record + file/line
+ uintptr_t timestamp; ///< Time at which record took place
+ const char *where; ///< Source code function
+ uintptr_t args[4]; ///< Four arguments, for a total of 8 fields
+} recorder_entry;
+
+
+/// A global counter indicating the order of entries across recorders.
+/// this is incremented atomically for each record() call.
+/// It must be exposed because all XYZ_record() implementations need to
+/// touch the same shared variable in order to provide a global order.
+extern uintptr_t recorder_order;
+
+typedef struct recorder_info
+///----------------------------------------------------------------------------
+/// A linked list of the activated recorders
+///----------------------------------------------------------------------------
+{
+ intptr_t trace; ///< Trace this recorder
+ const char * name; ///< Name of this parameter / recorder
+ const char * description;///< Description of what is recorded
+ recorder_entry data[0]; ///< Data for this recorder
+} recorder_info;
+
+// ============================================================================
+//
+// Adding data to a recorder
+//
+// ============================================================================
+
+extern void recorder_append(recorder_info *rec,
+ const char *where,
+ const char *format,
+ uintptr_t a0,
+ uintptr_t a1,
+ uintptr_t a2,
+ uintptr_t a3);
+extern void recorder_append2(recorder_info *rec,
+ const char *where,
+ const char *format,
+ uintptr_t a0,
+ uintptr_t a1,
+ uintptr_t a2,
+ uintptr_t a3,
+ uintptr_t a4,
+ uintptr_t a5,
+ uintptr_t a6,
+ uintptr_t a7);
+extern void recorder_append3(recorder_info *rec,
+ const char *where,
+ const char *format,
+ uintptr_t a0,
+ uintptr_t a1,
+ uintptr_t a2,
+ uintptr_t a3,
+ uintptr_t a4,
+ uintptr_t a5,
+ uintptr_t a6,
+ uintptr_t a7,
+ uintptr_t a8,
+ uintptr_t a9,
+ uintptr_t a10,
+ uintptr_t a11);
+
+/// Activate a recorder (during construction time)
+extern void recorder_activate(recorder_info *recorder);
+
+// ============================================================================
+//
+// Declaration of recorders and tweaks
+//
+// ============================================================================
+
+#define RECORDER_DECLARE(Name) \
+/* ----------------------------------------------------------------*/ \
+/* Declare a recorder with the given name (for use in headers) */ \
+/* ----------------------------------------------------------------*/ \
+ extern recorder_info * const recorder_info_ptr_for_##Name; \
+ extern struct recorder_info_for_##Name recorder_info_for_##Name
+
+
+// ============================================================================
+//
+// Definition of recorders and tweaks
+//
+// ============================================================================
+
+#define RECORDER(Name, Size, Info) RECORDER_DEFINE(Name,Size,Info)
+
+#define RECORDER_DEFINE(Name, Size, Info) \
+/*!----------------------------------------------------------------*/ \
+/*! Define a recorder type with Size elements */ \
+/*!----------------------------------------------------------------*/ \
+/*! \param Name is the C name fo the recorder. \
+ *! \param Size is the number of entries in the circular buffer. \
+ *! \param Info is a description of the recorder for help. */ \
+ \
+/* The entry in linked list for this type */ \
+struct recorder_info_for_##Name \
+{ \
+ recorder_info info; \
+ recorder_entry data[Size]; \
+} \
+recorder_info_for_##Name = \
+{ \
+ { \
+ 0, #Name, Info, {} \
+ }, \
+ {} \
+}; \
+recorder_info * const recorder_info_ptr_for_##Name = \
+ &recorder_info_for_##Name.info; \
+ \
+RECORDER_CONSTRUCTOR \
+static void recorder_activate_##Name(void) \
+/* ----------------------------------------------------------------*/ \
+/* Activate recorder before entering main() */ \
+/* ----------------------------------------------------------------*/ \
+{ \
+ recorder_activate(RECORDER_INFO(Name)); \
+} \
+ \
+/* Purposefully generate compile error if macro not followed by ; */ \
+extern void recorder_activate(recorder_info *recorder)
+
+typedef struct SpiceDummyTweak {
+ intptr_t tweak_value;
+} SpiceDummyTweak;
+
+typedef struct SpiceEmptyStruct {
+ char dummy[0];
+} SpiceEmptyStruct;
+
+#define RECORDER_TWEAK_DECLARE(rec) \
+ extern const SpiceDummyTweak spice_recorder_tweak_ ## rec
+
+#define RECORDER_TWEAK_DEFINE(rec, value, comment) \
+ const SpiceDummyTweak spice_recorder_tweak_ ## rec = { (value) }
+
+#define RECORDER_TWEAK(rec) \
+ ((spice_recorder_tweak_ ## rec).tweak_value)
+
+#define RECORDER_TRACE(rec) \
+ (sizeof(struct recorder_info_for_ ## rec) != sizeof(SpiceEmptyStruct))
+
+
+// ============================================================================
+//
+// Access to recorder and tweak info
+//
+// ============================================================================
+
+#define RECORDER_INFO(Name) (recorder_info_ptr_for_##Name)
+
+// ============================================================================
+//
+// Recording stuff
+//
+// ============================================================================
+
+#define record(Name, ...) RECORD_MACRO(Name, __VA_ARGS__)
+#define RECORD(Name,...) RECORD_MACRO(Name, __VA_ARGS__)
+#define RECORD_MACRO(Name, Format,...) \
+ RECORD_(RECORD,RECORD_COUNT_(__VA_ARGS__),Name,Format,##__VA_ARGS__)
+#define RECORD_(RECORD,RCOUNT,Name,Format,...) \
+ RECORD__(RECORD,RCOUNT,Name,Format,## __VA_ARGS__)
+#define RECORD__(RECORD,RCOUNT,Name,Format,...) \
+ RECORD##RCOUNT(Name,Format,##__VA_ARGS__)
+#define RECORD_COUNT_(...) RECORD_COUNT__(Dummy,##__VA_ARGS__,_X,_X,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1,_0)
+#define RECORD_COUNT__(Dummy,_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_N,...) _N
+
+#define RECORD_0(Name, Format) \
+ recorder_append(RECORDER_INFO(Name), \
+ RECORDER_SOURCE_FUNCTION, \
+ RECORDER_SOURCE_LOCATION \
+ Format, 0, 0, 0, 0)
+#define RECORD_1(Name, Format, a) \
+ recorder_append(RECORDER_INFO(Name), \
+ RECORDER_SOURCE_FUNCTION, \
+ RECORDER_SOURCE_LOCATION \
+ Format, \
+ RECORDER_ARG(a), 0, 0, 0)
+#define RECORD_2(Name, Format, a,b) \
+ recorder_append(RECORDER_INFO(Name), \
+ RECORDER_SOURCE_FUNCTION, \
+ RECORDER_SOURCE_LOCATION \
+ Format, \
+ RECORDER_ARG(a), \
+ RECORDER_ARG(b), 0, 0)
+#define RECORD_3(Name, Format, a,b,c) \
+ recorder_append(RECORDER_INFO(Name), \
+ RECORDER_SOURCE_FUNCTION, \
+ RECORDER_SOURCE_LOCATION \
+ Format, \
+ RECORDER_ARG(a), \
+ RECORDER_ARG(b), \
+ RECORDER_ARG(c), 0)
+#define RECORD_4(Name, Format, a,b,c,d) \
+ recorder_append(RECORDER_INFO(Name), \
+ RECORDER_SOURCE_FUNCTION, \
+ RECORDER_SOURCE_LOCATION \
+ Format, \
+ RECORDER_ARG(a), \
+ RECORDER_ARG(b), \
+ RECORDER_ARG(c), \
+ RECORDER_ARG(d))
+#define RECORD_5(Name, Format, a,b,c,d,e) \
+ recorder_append2(RECORDER_INFO(Name), \
+ RECORDER_SOURCE_FUNCTION, \
+ RECORDER_SOURCE_LOCATION \
+ Format, \
+ RECORDER_ARG(a), \
+ RECORDER_ARG(b), \
+ RECORDER_ARG(c), \
+ RECORDER_ARG(d), \
+ RECORDER_ARG(e), 0, 0, 0)
+#define RECORD_6(Name, Format, a,b,c,d,e,f) \
+ recorder_append2(RECORDER_INFO(Name), \
+ RECORDER_SOURCE_FUNCTION, \
+ RECORDER_SOURCE_LOCATION \
+ Format, \
+ RECORDER_ARG(a), \
+ RECORDER_ARG(b), \
+ RECORDER_ARG(c), \
+ RECORDER_ARG(d), \
+ RECORDER_ARG(e), \
+ RECORDER_ARG(f), 0, 0)
+#define RECORD_7(Name, Format, a,b,c,d,e,f,g) \
+ recorder_append2(RECORDER_INFO(Name), \
+ RECORDER_SOURCE_FUNCTION, \
+ RECORDER_SOURCE_LOCATION \
+ Format, \
+ RECORDER_ARG(a), \
+ RECORDER_ARG(b), \
+ RECORDER_ARG(c), \
+ RECORDER_ARG(d), \
+ RECORDER_ARG(e), \
+ RECORDER_ARG(f), \
+ RECORDER_ARG(g), 0)
+#define RECORD_8(Name, Format, a,b,c,d,e,f,g,h) \
+ recorder_append2(RECORDER_INFO(Name), \
+ RECORDER_SOURCE_FUNCTION, \
+ RECORDER_SOURCE_LOCATION \
+ Format, \
+ RECORDER_ARG(a), \
+ RECORDER_ARG(b), \
+ RECORDER_ARG(c), \
+ RECORDER_ARG(d), \
+ RECORDER_ARG(e), \
+ RECORDER_ARG(f), \
+ RECORDER_ARG(g), \
+ RECORDER_ARG(h))
+#define RECORD_9(Name, Format, a,b,c,d,e,f,g,h,i) \
+ recorder_append3(RECORDER_INFO(Name), \
+ RECORDER_SOURCE_FUNCTION, \
+ RECORDER_SOURCE_LOCATION \
+ Format, \
+ RECORDER_ARG(a), \
+ RECORDER_ARG(b), \
+ RECORDER_ARG(c), \
+ RECORDER_ARG(d), \
+ RECORDER_ARG(e), \
+ RECORDER_ARG(f), \
+ RECORDER_ARG(g), \
+ RECORDER_ARG(h), \
+ RECORDER_ARG(i), 0,0,0)
+#define RECORD_10(Name, Format, a,b,c,d,e,f,g,h,i,j) \
+ recorder_append3(RECORDER_INFO(Name), \
+ RECORDER_SOURCE_FUNCTION, \
+ RECORDER_SOURCE_LOCATION \
+ Format, \
+ RECORDER_ARG(a), \
+ RECORDER_ARG(b), \
+ RECORDER_ARG(c), \
+ RECORDER_ARG(d), \
+ RECORDER_ARG(e), \
+ RECORDER_ARG(f), \
+ RECORDER_ARG(g), \
+ RECORDER_ARG(h), \
+ RECORDER_ARG(i), \
+ RECORDER_ARG(j), 0,0)
+#define RECORD_11(Name, Format, a,b,c,d,e,f,g,h,i,j,k) \
+ recorder_append3(RECORDER_INFO(Name), \
+ RECORDER_SOURCE_FUNCTION, \
+ RECORDER_SOURCE_LOCATION \
+ Format, \
+ RECORDER_ARG(a), \
+ RECORDER_ARG(b), \
+ RECORDER_ARG(c), \
+ RECORDER_ARG(d), \
+ RECORDER_ARG(e), \
+ RECORDER_ARG(f), \
+ RECORDER_ARG(g), \
+ RECORDER_ARG(h), \
+ RECORDER_ARG(i), \
+ RECORDER_ARG(j), \
+ RECORDER_ARG(k),0)
+#define RECORD_12(Name,Format,a,b,c,d,e,f,g,h,i,j,k,l) \
+ recorder_append3(RECORDER_INFO(Name), \
+ RECORDER_SOURCE_FUNCTION, \
+ RECORDER_SOURCE_LOCATION \
+ Format, \
+ RECORDER_ARG(a), \
+ RECORDER_ARG(b), \
+ RECORDER_ARG(c), \
+ RECORDER_ARG(d), \
+ RECORDER_ARG(e), \
+ RECORDER_ARG(f), \
+ RECORDER_ARG(g), \
+ RECORDER_ARG(h), \
+ RECORDER_ARG(i), \
+ RECORDER_ARG(j), \
+ RECORDER_ARG(k), \
+ RECORDER_ARG(l))
+#define RECORD_X(Name, Format, ...) RECORD_TOO_MANY_ARGS(printf(Format, __VA_ARGS__))
+
+
+// Some ugly macro drudgery to make things easy to use. Adjust type.
+#ifdef __cplusplus
+#define RECORDER_ARG(arg) _recorder_arg(arg)
+#else // !__cplusplus
+
+#if defined(__GNUC__) && !defined(__clang__)
+# if __GNUC__ <= 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 9)
+# define RECORDER_WITHOUT_GENERIC
+# endif
+#endif // __GNUC__
+
+#ifdef RECORDER_WITHOUT_GENERIC
+#define RECORDER_ARG(arg) ((uintptr_t) (arg))
+#else // !RECORDER_WITHOUT_GENERIC
+#define RECORDER_ARG(arg) \
+ _Generic(arg, \
+ unsigned char: _recorder_unsigned, \
+ unsigned short: _recorder_unsigned, \
+ unsigned: _recorder_unsigned, \
+ unsigned long: _recorder_unsigned, \
+ unsigned long long:_recorder_unsigned, \
+ char: _recorder_char, \
+ signed char: _recorder_signed, \
+ signed short: _recorder_signed, \
+ signed: _recorder_signed, \
+ signed long: _recorder_signed, \
+ signed long long: _recorder_signed, \
+ float: _recorder_float, \
+ double: _recorder_double, \
+ default: _recorder_pointer)(arg)
+#endif // RECORDER_WITHOUT_GENERIC
+#endif // __cplusplus
+
+// ============================================================================
+//
+// Timing information
+//
+// ============================================================================
+
+#define RECORD_TIMING_BEGIN(rec) \
+ do { RECORD(rec, "begin");
+#define RECORD_TIMING_END(rec, op, name, value) \
+ RECORD(rec, "end" op name); \
+ } while (0)
+
+
+// ============================================================================
+//
+// Support macros
+//
+// ============================================================================
+
+#define RECORDER_SOURCE_FUNCTION __func__ /* Works in C99 and C++11 */
+#define RECORDER_SOURCE_LOCATION __FILE__ ":" RECORDER_STRING(__LINE__) ":"
+#define RECORDER_STRING(LINE) RECORDER_STRING_(LINE)
+#define RECORDER_STRING_(LINE) #LINE
+
+#ifdef __GNUC__
+#define RECORDER_CONSTRUCTOR __attribute__((constructor))
+#else
+#define RECORDER_CONSTRUCTOR
+#endif
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+// ============================================================================
+//
+// Utility: Convert floating point values for vararg format
+//
+// ============================================================================
+//
+// The recorder stores only uintptr_t in recorder entries. Integer types
+// are promoted, pointer types are converted. Floating point values
+// are converted a floating point type of the same size as uintptr_t,
+// i.e. float are converted to double on 64-bit platforms, and conversely.
+
+#ifdef __cplusplus
+#include <string>
+
+// In C++, we don't use _Generic but actual overloading
+template <class inttype>
+static inline uintptr_t _recorder_arg(inttype i)
+{
+ return (uintptr_t) i;
+}
+
+
+static inline uintptr_t _recorder_arg(const std::string &arg)
+{
+ return (uintptr_t) arg.c_str();
+}
+#define _recorder_float _recorder_arg
+#define _recorder_double _recorder_arg
+
+#else // !__cplusplus
+
+static inline uintptr_t _recorder_char(char c)
+// ----------------------------------------------------------------------------
+// Necessary because of the way generic selections work
+// ----------------------------------------------------------------------------
+{
+ return c;
+}
+
+
+static inline uintptr_t _recorder_unsigned(uintptr_t i)
+// ----------------------------------------------------------------------------
+// Necessary because of the way generic selections work
+// ----------------------------------------------------------------------------
+{
+ return i;
+}
+
+
+static inline uintptr_t _recorder_signed(intptr_t i)
+// ----------------------------------------------------------------------------
+// Necessary because of the way generic selections work
+// ----------------------------------------------------------------------------
+{
+ return (uintptr_t) i;
+}
+
+
+static inline uintptr_t _recorder_pointer(const void *i)
+// ----------------------------------------------------------------------------
+// Necessary because of the way generic selections work
+// ----------------------------------------------------------------------------
+{
+ return (uintptr_t) i;
+}
+
+#endif // __cplusplus
+
+
+static inline uintptr_t _recorder_float(float f)
+// ----------------------------------------------------------------------------
+// Convert floating point number to intptr_t representation for recorder
+// ----------------------------------------------------------------------------
+{
+ if (sizeof(float) == sizeof(intptr_t)) {
+ union { float f; uintptr_t i; } u;
+ u.f = f;
+ return u.i;
+ } else {
+ union { double d; uintptr_t i; } u;
+ u.d = (double) f;
+ return u.i;
+ }
+}
+
+
+static inline uintptr_t _recorder_double(double d)
+// ----------------------------------------------------------------------------
+// Convert double-precision floating point number to intptr_t representation
+// ----------------------------------------------------------------------------
+{
+ if (sizeof(double) == sizeof(intptr_t)) {
+ union { double d; uintptr_t i; } u;
+ u.d = d;
+ return u.i;
+ } else {
+ // Better to lose precision than not store any data
+ union { float f; uintptr_t i; } u;
+ u.f = d;
+ return u.i;
+ }
+}
diff --git a/tests/test-dummy-recorder.c b/tests/test-dummy-recorder.c
index 4e674a9..5be4cbd 100644
--- a/tests/test-dummy-recorder.c
+++ b/tests/test-dummy-recorder.c
@@ -19,7 +19,8 @@
#include <config.h>
#include <assert.h>
-#undef ENABLE_RECORDER
+#undef ENABLE_C3D_RECORDER
+#undef ENABLE_AGENT_INTERFACE
#include <common/recorder.h>
--
2.21.0
More information about the Spice-devel
mailing list