2 * This file is part of the libsigrok project.
4 * Copyright (C) 2010-2012 Bert Vermeulen <bert@biot.com>
5 * Copyright (C) 2015 Daniel Elstner <daniel.kitta@gmail.com>
7 * This program is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
28 #include <libsigrok/libsigrok.h>
29 #include "libsigrok-internal.h"
32 #define LOG_PREFIX "session"
38 * Creating, using, or destroying libsigrok sessions.
42 * @defgroup grp_session Session handling
44 * Creating, using, or destroying libsigrok sessions.
49 struct datafeed_callback {
50 sr_datafeed_callback cb;
54 /** Custom GLib event source for generic descriptor I/O.
63 /* Meta-data needed to keep track of installed sources */
64 struct sr_session *session;
70 /** FD event source prepare() method.
72 static gboolean fd_source_prepare(GSource *source, int *timeout)
75 struct fd_source *fsource;
78 fsource = (struct fd_source *)source;
80 if (fsource->timeout_us >= 0) {
81 now_us = g_source_get_time(source);
83 if (fsource->due_us == 0) {
84 /* First-time initialization of the expiration time */
85 fsource->due_us = now_us + fsource->timeout_us;
87 remaining_ms = (MAX(0, fsource->due_us - now_us) + 999) / 1000;
91 *timeout = remaining_ms;
93 return (remaining_ms == 0);
96 /** FD event source check() method.
98 static gboolean fd_source_check(GSource *source)
100 struct fd_source *fsource;
101 unsigned int revents;
103 fsource = (struct fd_source *)source;
104 revents = fsource->pollfd.revents;
106 return (revents != 0 || (fsource->timeout_us >= 0
107 && fsource->due_us <= g_source_get_time(source)));
110 /** FD event source dispatch() method.
112 static gboolean fd_source_dispatch(GSource *source,
113 GSourceFunc callback, void *user_data)
115 struct fd_source *fsource;
117 unsigned int revents;
120 fsource = (struct fd_source *)source;
121 name = g_source_get_name(source);
122 revents = fsource->pollfd.revents;
125 sr_spew("%s: %s " G_POLLFD_FORMAT ", revents 0x%.2X",
126 __func__, name, fsource->pollfd.fd, revents);
128 sr_spew("%s: %s " G_POLLFD_FORMAT ", timed out",
129 __func__, name, fsource->pollfd.fd);
132 sr_err("Callback not set, cannot dispatch event.");
133 return G_SOURCE_REMOVE;
135 keep = (*(sr_receive_data_callback)callback)
136 (fsource->pollfd.fd, revents, user_data);
138 if (fsource->timeout_us >= 0 && G_LIKELY(keep)
139 && G_LIKELY(!g_source_is_destroyed(source)))
140 fsource->due_us = g_source_get_time(source)
141 + fsource->timeout_us;
145 /** FD event source finalize() method.
147 static void fd_source_finalize(GSource *source)
149 struct fd_source *fsource;
151 fsource = (struct fd_source *)source;
153 sr_dbg("%s: key %p", __func__, fsource->key);
155 sr_session_source_destroyed(fsource->session, fsource->key, source);
158 /** Create an event source for I/O on a file descriptor.
160 * In order to maintain API compatibility, this event source also doubles
161 * as a timer event source.
163 * @param session The session the event source belongs to.
164 * @param key The key used to identify this source.
165 * @param fd The file descriptor or HANDLE.
166 * @param timeout_ms The timeout interval in ms, or -1 to wait indefinitely.
167 * @return A new event source object, or NULL on failure.
169 static GSource *fd_source_new(struct sr_session *session, void *key,
170 gintptr fd, int events, int timeout_ms)
172 static GSourceFuncs fd_source_funcs = {
173 .prepare = &fd_source_prepare,
174 .check = &fd_source_check,
175 .dispatch = &fd_source_dispatch,
176 .finalize = &fd_source_finalize
179 struct fd_source *fsource;
181 source = g_source_new(&fd_source_funcs, sizeof(struct fd_source));
182 fsource = (struct fd_source *)source;
184 g_source_set_name(source, (fd < 0) ? "timer" : "fd");
186 if (timeout_ms >= 0) {
187 fsource->timeout_us = 1000 * (int64_t)timeout_ms;
190 fsource->timeout_us = -1;
191 fsource->due_us = INT64_MAX;
193 fsource->session = session;
196 fsource->pollfd.fd = fd;
197 fsource->pollfd.events = events;
198 fsource->pollfd.revents = 0;
201 g_source_add_poll(source, &fsource->pollfd);
207 * Create a new session.
209 * @param ctx The context in which to create the new session.
210 * @param new_session This will contain a pointer to the newly created
211 * session if the return value is SR_OK, otherwise the value
212 * is undefined and should not be used. Must not be NULL.
214 * @retval SR_OK Success.
215 * @retval SR_ERR_ARG Invalid argument.
219 SR_API int sr_session_new(struct sr_context *ctx,
220 struct sr_session **new_session)
222 struct sr_session *session;
227 session = g_malloc0(sizeof(struct sr_session));
231 g_mutex_init(&session->main_mutex);
233 /* To maintain API compatibility, we need a lookup table
234 * which maps poll_object IDs to GSource* pointers.
236 session->event_sources = g_hash_table_new(NULL, NULL);
238 *new_session = session;
245 * This frees up all memory used by the session.
247 * @param session The session to destroy. Must not be NULL.
249 * @retval SR_OK Success.
250 * @retval SR_ERR_ARG Invalid session passed.
254 SR_API int sr_session_destroy(struct sr_session *session)
257 sr_err("%s: session was NULL", __func__);
261 sr_session_dev_remove_all(session);
262 g_slist_free_full(session->owned_devs, (GDestroyNotify)sr_dev_inst_free);
264 g_hash_table_unref(session->event_sources);
266 g_mutex_clear(&session->main_mutex);
274 * Remove all the devices from a session.
276 * The session itself (i.e., the struct sr_session) is not free'd and still
277 * exists after this function returns.
279 * @param session The session to use. Must not be NULL.
281 * @retval SR_OK Success.
282 * @retval SR_ERR_BUG Invalid session passed.
286 SR_API int sr_session_dev_remove_all(struct sr_session *session)
288 struct sr_dev_inst *sdi;
292 sr_err("%s: session was NULL", __func__);
296 for (l = session->devs; l; l = l->next) {
297 sdi = (struct sr_dev_inst *) l->data;
301 g_slist_free(session->devs);
302 session->devs = NULL;
308 * Add a device instance to a session.
310 * @param session The session to add to. Must not be NULL.
311 * @param sdi The device instance to add to a session. Must not
312 * be NULL. Also, sdi->driver and sdi->driver->dev_open must
315 * @retval SR_OK Success.
316 * @retval SR_ERR_ARG Invalid argument.
320 SR_API int sr_session_dev_add(struct sr_session *session,
321 struct sr_dev_inst *sdi)
326 sr_err("%s: sdi was NULL", __func__);
331 sr_err("%s: session was NULL", __func__);
335 /* If sdi->session is not NULL, the device is already in this or
336 * another session. */
338 sr_err("%s: already assigned to session", __func__);
342 /* If sdi->driver is NULL, this is a virtual device. */
344 /* Just add the device, don't run dev_open(). */
345 session->devs = g_slist_append(session->devs, (gpointer)sdi);
346 sdi->session = session;
350 /* sdi->driver is non-NULL (i.e. we have a real device). */
351 if (!sdi->driver->dev_open) {
352 sr_err("%s: sdi->driver->dev_open was NULL", __func__);
356 session->devs = g_slist_append(session->devs, (gpointer)sdi);
357 sdi->session = session;
359 if (session->running) {
360 /* Adding a device to a running session. Commit settings
361 * and start acquisition on that device now. */
362 if ((ret = sr_config_commit(sdi)) != SR_OK) {
363 sr_err("Failed to commit device settings before "
364 "starting acquisition in running session (%s)",
368 if ((ret = sdi->driver->dev_acquisition_start(sdi,
369 (void *)sdi)) != SR_OK) {
370 sr_err("Failed to start acquisition of device in "
371 "running session (%s)", sr_strerror(ret));
380 * List all device instances attached to a session.
382 * @param session The session to use. Must not be NULL.
383 * @param devlist A pointer where the device instance list will be
384 * stored on return. If no devices are in the session,
385 * this will be NULL. Each element in the list points
386 * to a struct sr_dev_inst *.
387 * The list must be freed by the caller, but not the
388 * elements pointed to.
390 * @retval SR_OK Success.
391 * @retval SR_ERR_ARG Invalid argument.
395 SR_API int sr_session_dev_list(struct sr_session *session, GSList **devlist)
403 *devlist = g_slist_copy(session->devs);
409 * Remove all datafeed callbacks in a session.
411 * @param session The session to use. Must not be NULL.
413 * @retval SR_OK Success.
414 * @retval SR_ERR_ARG Invalid session passed.
418 SR_API int sr_session_datafeed_callback_remove_all(struct sr_session *session)
421 sr_err("%s: session was NULL", __func__);
425 g_slist_free_full(session->datafeed_callbacks, g_free);
426 session->datafeed_callbacks = NULL;
432 * Add a datafeed callback to a session.
434 * @param session The session to use. Must not be NULL.
435 * @param cb Function to call when a chunk of data is received.
437 * @param cb_data Opaque pointer passed in by the caller.
439 * @retval SR_OK Success.
440 * @retval SR_ERR_BUG No session exists.
444 SR_API int sr_session_datafeed_callback_add(struct sr_session *session,
445 sr_datafeed_callback cb, void *cb_data)
447 struct datafeed_callback *cb_struct;
450 sr_err("%s: session was NULL", __func__);
455 sr_err("%s: cb was NULL", __func__);
459 cb_struct = g_malloc0(sizeof(struct datafeed_callback));
461 cb_struct->cb_data = cb_data;
463 session->datafeed_callbacks =
464 g_slist_append(session->datafeed_callbacks, cb_struct);
470 * Get the trigger assigned to this session.
472 * @param session The session to use.
474 * @retval NULL Invalid (NULL) session was passed to the function.
475 * @retval other The trigger assigned to this session (can be NULL).
479 SR_API struct sr_trigger *sr_session_trigger_get(struct sr_session *session)
484 return session->trigger;
488 * Set the trigger of this session.
490 * @param session The session to use. Must not be NULL.
491 * @param trig The trigger to assign to this session. Can be NULL.
493 * @retval SR_OK Success.
494 * @retval SR_ERR_ARG Invalid argument.
498 SR_API int sr_session_trigger_set(struct sr_session *session, struct sr_trigger *trig)
503 session->trigger = trig;
508 static int verify_trigger(struct sr_trigger *trigger)
510 struct sr_trigger_stage *stage;
511 struct sr_trigger_match *match;
514 if (!trigger->stages) {
515 sr_err("No trigger stages defined.");
519 sr_spew("Checking trigger:");
520 for (l = trigger->stages; l; l = l->next) {
522 if (!stage->matches) {
523 sr_err("Stage %d has no matches defined.", stage->stage);
526 for (m = stage->matches; m; m = m->next) {
528 if (!match->channel) {
529 sr_err("Stage %d match has no channel.", stage->stage);
533 sr_err("Stage %d match is not defined.", stage->stage);
536 sr_spew("Stage %d match on channel %s, match %d", stage->stage,
537 match->channel->name, match->match);
544 /** Set up the main context the session will be executing in.
546 * Must be called just before the session starts, by the thread which
547 * will execute the session main loop. Once acquired, the main context
548 * pointer is immutable for the duration of the session run.
550 static int set_main_context(struct sr_session *session)
552 GMainContext *def_context;
554 /* May happen if sr_session_start() is called again after
555 * sr_session_run(), but the session hasn't been stopped yet.
557 if (session->main_loop) {
558 sr_err("Cannot set main context; main loop already created.");
562 g_mutex_lock(&session->main_mutex);
564 def_context = g_main_context_get_thread_default();
567 def_context = g_main_context_default();
569 * Try to use an existing main context if possible, but only if we
570 * can make it owned by the current thread. Otherwise, create our
571 * own main context so that event source callbacks can execute in
572 * the session thread.
574 if (g_main_context_acquire(def_context)) {
575 g_main_context_release(def_context);
577 sr_dbg("Using thread-default main context.");
579 session->main_context = def_context;
580 session->main_context_is_default = TRUE;
582 sr_dbg("Creating our own main context.");
584 session->main_context = g_main_context_new();
585 session->main_context_is_default = FALSE;
587 g_mutex_unlock(&session->main_mutex);
592 /** Unset the main context used for the current session run.
594 * Must be called right after stopping the session. Note that if the
595 * session is stopped asynchronously, the main loop may still be running
596 * after the main context has been unset. This is OK as long as no new
597 * event sources are created -- the main loop holds its own reference
598 * to the main context.
600 static int unset_main_context(struct sr_session *session)
604 g_mutex_lock(&session->main_mutex);
606 if (session->main_context) {
607 if (!session->main_context_is_default)
608 g_main_context_unref(session->main_context);
610 session->main_context = NULL;
613 /* May happen if the set/unset calls are not matched.
615 sr_err("No main context to unset.");
618 g_mutex_unlock(&session->main_mutex);
626 * @param session The session to use. Must not be NULL.
628 * @retval SR_OK Success.
629 * @retval SR_ERR_ARG Invalid session passed.
633 SR_API int sr_session_start(struct sr_session *session)
635 struct sr_dev_inst *sdi;
636 struct sr_channel *ch;
638 int enabled_channels, ret;
641 sr_err("%s: session was NULL", __func__);
645 if (!session->devs) {
646 sr_err("%s: session->devs was NULL; a session "
647 "cannot be started without devices.", __func__);
651 if (session->trigger && verify_trigger(session->trigger) != SR_OK)
654 ret = set_main_context(session);
658 session->running = TRUE;
660 sr_info("Starting.");
662 for (l = session->devs; l; l = l->next) {
664 enabled_channels = 0;
665 for (c = sdi->channels; c; c = c->next) {
672 if (enabled_channels == 0) {
674 sr_err("%s using connection %s has no enabled channels!",
675 sdi->driver->name, sdi->connection_id);
679 if ((ret = sr_config_commit(sdi)) != SR_OK) {
680 sr_err("Failed to commit device settings before "
681 "starting acquisition (%s)", sr_strerror(ret));
684 if ((ret = sdi->driver->dev_acquisition_start(sdi, sdi)) != SR_OK) {
685 sr_err("%s: could not start an acquisition "
686 "(%s)", __func__, sr_strerror(ret));
692 unset_main_context(session);
693 session->running = FALSE;
695 /* TODO: What if there are multiple devices? Which return code? */
703 * @param session The session to use. Must not be NULL.
705 * @retval SR_OK Success.
706 * @retval SR_ERR_ARG Invalid session passed.
707 * @retval SR_ERR Error during event processing.
711 SR_API int sr_session_run(struct sr_session *session)
714 sr_err("%s: session was NULL", __func__);
717 if (!session->devs) {
718 /* TODO: Actually the case? */
719 sr_err("%s: session->devs was NULL; a session "
720 "cannot be run without devices.", __func__);
723 if (session->main_loop) {
724 sr_err("Main loop already created.");
727 if (g_hash_table_size(session->event_sources) == 0) {
728 sr_warn("No event sources, returning immediately.");
732 g_mutex_lock(&session->main_mutex);
733 if (!session->main_context) {
734 sr_err("Cannot run without main context.");
735 g_mutex_unlock(&session->main_mutex);
740 session->main_loop = g_main_loop_new(session->main_context, FALSE);
741 g_mutex_unlock(&session->main_mutex);
743 g_main_loop_run(session->main_loop);
745 g_main_loop_unref(session->main_loop);
746 session->main_loop = NULL;
751 static gboolean session_stop_sync(void *user_data)
753 struct sr_session *session;
754 struct sr_dev_inst *sdi;
759 if (!session->running)
760 return G_SOURCE_REMOVE;
762 sr_info("Stopping.");
764 for (node = session->devs; node; node = node->next) {
766 if (sdi->driver && sdi->driver->dev_acquisition_stop)
767 sdi->driver->dev_acquisition_stop(sdi, sdi);
769 session->running = FALSE;
771 return G_SOURCE_REMOVE;
777 * The session is stopped immediately, with all acquisition sessions being
778 * stopped and hardware drivers cleaned up.
780 * If the session is run in a separate thread, this function will not block
781 * until the session is finished executing. It is the caller's responsibility
782 * to wait for the session thread to return before assuming that the session is
783 * completely decommissioned.
785 * @param session The session to use. Must not be NULL.
787 * @retval SR_OK Success.
788 * @retval SR_ERR_ARG Invalid session passed.
789 * @retval SR_ERR Other error.
793 SR_API int sr_session_stop(struct sr_session *session)
796 sr_err("%s: session was NULL", __func__);
799 g_mutex_lock(&session->main_mutex);
801 if (session->main_context) {
802 g_main_context_invoke(session->main_context,
803 &session_stop_sync, session);
805 sr_err("No main context set; already stopped?");
807 g_mutex_unlock(&session->main_mutex);
809 return unset_main_context(session);
815 * @param packet The packet to show debugging information for.
817 static void datafeed_dump(const struct sr_datafeed_packet *packet)
819 const struct sr_datafeed_logic *logic;
820 const struct sr_datafeed_analog *analog;
821 const struct sr_datafeed_analog2 *analog2;
823 /* Please use the same order as in libsigrok.h. */
824 switch (packet->type) {
826 sr_dbg("bus: Received SR_DF_HEADER packet.");
829 sr_dbg("bus: Received SR_DF_END packet.");
832 sr_dbg("bus: Received SR_DF_META packet.");
835 sr_dbg("bus: Received SR_DF_TRIGGER packet.");
838 logic = packet->payload;
839 sr_dbg("bus: Received SR_DF_LOGIC packet (%" PRIu64 " bytes, "
840 "unitsize = %d).", logic->length, logic->unitsize);
843 analog = packet->payload;
844 sr_dbg("bus: Received SR_DF_ANALOG packet (%d samples).",
845 analog->num_samples);
847 case SR_DF_FRAME_BEGIN:
848 sr_dbg("bus: Received SR_DF_FRAME_BEGIN packet.");
850 case SR_DF_FRAME_END:
851 sr_dbg("bus: Received SR_DF_FRAME_END packet.");
854 analog2 = packet->payload;
855 sr_dbg("bus: Received SR_DF_ANALOG2 packet (%d samples).",
856 analog2->num_samples);
859 sr_dbg("bus: Received unknown packet type: %d.", packet->type);
865 * Send a packet to whatever is listening on the datafeed bus.
867 * Hardware drivers use this to send a data packet to the frontend.
870 * @param packet The datafeed packet to send to the session bus.
872 * @retval SR_OK Success.
873 * @retval SR_ERR_ARG Invalid argument.
877 SR_PRIV int sr_session_send(const struct sr_dev_inst *sdi,
878 const struct sr_datafeed_packet *packet)
881 struct datafeed_callback *cb_struct;
882 struct sr_datafeed_packet *packet_in, *packet_out;
883 struct sr_transform *t;
887 sr_err("%s: sdi was NULL", __func__);
892 sr_err("%s: packet was NULL", __func__);
897 sr_err("%s: session was NULL", __func__);
902 * Pass the packet to the first transform module. If that returns
903 * another packet (instead of NULL), pass that packet to the next
904 * transform module in the list, and so on.
906 packet_in = (struct sr_datafeed_packet *)packet;
907 for (l = sdi->session->transforms; l; l = l->next) {
909 sr_spew("Running transform module '%s'.", t->module->id);
910 ret = t->module->receive(t, packet_in, &packet_out);
912 sr_err("Error while running transform module: %d.", ret);
917 * If any of the transforms don't return an output
920 sr_spew("Transform module didn't return a packet, aborting.");
924 * Use this transform module's output packet as input
925 * for the next transform module.
927 packet_in = packet_out;
933 * If the last transform did output a packet, pass it to all datafeed
936 for (l = sdi->session->datafeed_callbacks; l; l = l->next) {
937 if (sr_log_loglevel_get() >= SR_LOG_DBG)
938 datafeed_dump(packet);
940 cb_struct->cb(sdi, packet, cb_struct->cb_data);
947 * Add an event source for a file descriptor.
949 * @param session The session to use. Must not be NULL.
950 * @param key The key which identifies the event source.
951 * @param source An event source object. Must not be NULL.
952 * @retval SR_OK Success.
953 * @retval SR_ERR_ARG Invalid argument.
954 * @retval SR_ERR_BUG Event source with @a key already installed.
955 * @retval SR_ERR Other error.
957 SR_PRIV int sr_session_source_add_internal(struct sr_session *session,
958 void *key, GSource *source)
962 * This must not ever happen, since the source has already been
963 * created and its finalize() method will remove the key for the
964 * already installed source. (Well it would, if we did not have
965 * another sanity check there.)
967 if (g_hash_table_contains(session->event_sources, key)) {
968 sr_err("Event source with key %p already exists.", key);
971 g_hash_table_insert(session->event_sources, key, source);
973 g_mutex_lock(&session->main_mutex);
975 if (session->main_context) {
976 if (g_source_attach(source, session->main_context) > 0)
981 sr_err("Cannot add event source without main context.");
984 g_mutex_unlock(&session->main_mutex);
989 SR_PRIV int sr_session_fd_source_add(struct sr_session *session,
990 void *key, gintptr fd, int events, int timeout,
991 sr_receive_data_callback cb, void *cb_data)
996 source = fd_source_new(session, key, fd, events, timeout);
1000 g_source_set_callback(source, (GSourceFunc)cb, cb_data, NULL);
1002 ret = sr_session_source_add_internal(session, key, source);
1003 g_source_unref(source);
1009 * Add an event source for a file descriptor.
1011 * @param session The session to use. Must not be NULL.
1012 * @param fd The file descriptor, or a negative value to create a timer source.
1013 * @param events Events to check for.
1014 * @param timeout Max time in ms to wait before the callback is called,
1015 * or -1 to wait indefinitely.
1016 * @param cb Callback function to add. Must not be NULL.
1017 * @param cb_data Data for the callback function. Can be NULL.
1019 * @retval SR_OK Success.
1020 * @retval SR_ERR_ARG Invalid argument.
1024 SR_API int sr_session_source_add(struct sr_session *session, int fd,
1025 int events, int timeout, sr_receive_data_callback cb, void *cb_data)
1027 if (fd < 0 && timeout < 0) {
1028 sr_err("Cannot create timer source without timeout.");
1031 return sr_session_fd_source_add(session, GINT_TO_POINTER(fd),
1032 fd, events, timeout, cb, cb_data);
1036 * Add an event source for a GPollFD.
1038 * @param session The session to use. Must not be NULL.
1039 * @param pollfd The GPollFD. Must not be NULL.
1040 * @param timeout Max time in ms to wait before the callback is called,
1041 * or -1 to wait indefinitely.
1042 * @param cb Callback function to add. Must not be NULL.
1043 * @param cb_data Data for the callback function. Can be NULL.
1045 * @retval SR_OK Success.
1046 * @retval SR_ERR_ARG Invalid argument.
1050 SR_API int sr_session_source_add_pollfd(struct sr_session *session,
1051 GPollFD *pollfd, int timeout, sr_receive_data_callback cb,
1055 sr_err("%s: pollfd was NULL", __func__);
1058 return sr_session_fd_source_add(session, pollfd, pollfd->fd,
1059 pollfd->events, timeout, cb, cb_data);
1063 * Add an event source for a GIOChannel.
1065 * @param session The session to use. Must not be NULL.
1066 * @param channel The GIOChannel.
1067 * @param events Events to poll on.
1068 * @param timeout Max time in ms to wait before the callback is called,
1069 * or -1 to wait indefinitely.
1070 * @param cb Callback function to add. Must not be NULL.
1071 * @param cb_data Data for the callback function. Can be NULL.
1073 * @retval SR_OK Success.
1074 * @retval SR_ERR_ARG Invalid argument.
1078 SR_API int sr_session_source_add_channel(struct sr_session *session,
1079 GIOChannel *channel, int events, int timeout,
1080 sr_receive_data_callback cb, void *cb_data)
1085 sr_err("%s: channel was NULL", __func__);
1088 /* We should be using g_io_create_watch(), but can't without
1089 * changing the driver API, as the callback signature is different.
1092 g_io_channel_win32_make_pollfd(channel, events, &pollfd);
1094 pollfd.fd = g_io_channel_unix_get_fd(channel);
1095 pollfd.events = events;
1097 return sr_session_fd_source_add(session, channel, pollfd.fd,
1098 pollfd.events, timeout, cb, cb_data);
1102 * Remove the source identified by the specified poll object.
1104 * @param session The session to use. Must not be NULL.
1105 * @param key The key by which the source is identified.
1107 * @retval SR_OK Success
1108 * @retval SR_ERR_BUG No event source for poll_object found.
1110 SR_PRIV int sr_session_source_remove_internal(struct sr_session *session,
1115 source = g_hash_table_lookup(session->event_sources, key);
1117 * Trying to remove an already removed event source is problematic
1118 * since the poll_object handle may have been reused in the meantime.
1121 sr_warn("Cannot remove non-existing event source %p.", key);
1124 g_source_destroy(source);
1130 * Remove the source belonging to the specified file descriptor.
1132 * @param session The session to use. Must not be NULL.
1133 * @param fd The file descriptor for which the source should be removed.
1135 * @retval SR_OK Success
1136 * @retval SR_ERR_ARG Invalid argument
1137 * @retval SR_ERR_BUG Internal error.
1141 SR_API int sr_session_source_remove(struct sr_session *session, int fd)
1143 return sr_session_source_remove_internal(session, GINT_TO_POINTER(fd));
1147 * Remove the source belonging to the specified poll descriptor.
1149 * @param session The session to use. Must not be NULL.
1150 * @param pollfd The poll descriptor for which the source should be removed.
1152 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
1153 * SR_ERR_MALLOC upon memory allocation errors, SR_ERR_BUG upon
1158 SR_API int sr_session_source_remove_pollfd(struct sr_session *session,
1162 sr_err("%s: pollfd was NULL", __func__);
1165 return sr_session_source_remove_internal(session, pollfd);
1169 * Remove the source belonging to the specified channel.
1171 * @param session The session to use. Must not be NULL.
1172 * @param channel The channel for which the source should be removed.
1174 * @retval SR_OK Success.
1175 * @retval SR_ERR_ARG Invalid argument.
1176 * @return SR_ERR_BUG Internal error.
1180 SR_API int sr_session_source_remove_channel(struct sr_session *session,
1181 GIOChannel *channel)
1184 sr_err("%s: channel was NULL", __func__);
1187 return sr_session_source_remove_internal(session, channel);
1190 /** Unregister an event source that has been destroyed.
1192 * This is intended to be called from a source's finalize() method.
1194 * @param session The session to use. Must not be NULL.
1195 * @param key The key used to identify @a source.
1196 * @param source The source object that was destroyed.
1198 * @retval SR_OK Success.
1199 * @retval SR_ERR_BUG Event source for @a key does not match @a source.
1201 SR_PRIV int sr_session_source_destroyed(struct sr_session *session,
1202 void *key, GSource *source)
1204 GSource *registered_source;
1206 registered_source = g_hash_table_lookup(session->event_sources, key);
1208 * Trying to remove an already removed event source is problematic
1209 * since the poll_object handle may have been reused in the meantime.
1211 if (!registered_source) {
1212 sr_err("No event source for key %p found.", key);
1215 if (registered_source != source) {
1216 sr_err("Event source for key %p does not match"
1217 " destroyed source.", key);
1220 g_hash_table_remove(session->event_sources, key);
1222 * Quit the main loop if we just removed the last event source.
1223 * TODO: This may need an idle callback depending on when event
1224 * sources are finalized. (The issue is remove followed by add
1225 * within the same main loop iteration.)
1227 if (session->main_loop
1228 && g_hash_table_size(session->event_sources) == 0) {
1229 sr_dbg("Stopping main loop...");
1230 g_main_loop_quit(session->main_loop);
1235 static void copy_src(struct sr_config *src, struct sr_datafeed_meta *meta_copy)
1237 g_variant_ref(src->data);
1238 meta_copy->config = g_slist_append(meta_copy->config,
1239 g_memdup(src, sizeof(struct sr_config)));
1242 SR_PRIV int sr_packet_copy(const struct sr_datafeed_packet *packet,
1243 struct sr_datafeed_packet **copy)
1245 const struct sr_datafeed_meta *meta;
1246 struct sr_datafeed_meta *meta_copy;
1247 const struct sr_datafeed_logic *logic;
1248 struct sr_datafeed_logic *logic_copy;
1249 const struct sr_datafeed_analog *analog;
1250 struct sr_datafeed_analog *analog_copy;
1253 *copy = g_malloc0(sizeof(struct sr_datafeed_packet));
1254 (*copy)->type = packet->type;
1256 switch (packet->type) {
1262 payload = g_malloc(sizeof(struct sr_datafeed_header));
1263 memcpy(payload, packet->payload, sizeof(struct sr_datafeed_header));
1264 (*copy)->payload = payload;
1267 meta = packet->payload;
1268 meta_copy = g_malloc0(sizeof(struct sr_datafeed_meta));
1269 g_slist_foreach(meta->config, (GFunc)copy_src, meta_copy->config);
1270 (*copy)->payload = meta_copy;
1273 logic = packet->payload;
1274 logic_copy = g_malloc(sizeof(logic));
1275 logic_copy->length = logic->length;
1276 logic_copy->unitsize = logic->unitsize;
1277 memcpy(logic_copy->data, logic->data, logic->length * logic->unitsize);
1278 (*copy)->payload = logic_copy;
1281 analog = packet->payload;
1282 analog_copy = g_malloc(sizeof(analog));
1283 analog_copy->channels = g_slist_copy(analog->channels);
1284 analog_copy->num_samples = analog->num_samples;
1285 analog_copy->mq = analog->mq;
1286 analog_copy->unit = analog->unit;
1287 analog_copy->mqflags = analog->mqflags;
1288 memcpy(analog_copy->data, analog->data,
1289 analog->num_samples * sizeof(float));
1290 (*copy)->payload = analog_copy;
1293 sr_err("Unknown packet type %d", packet->type);
1300 void sr_packet_free(struct sr_datafeed_packet *packet)
1302 const struct sr_datafeed_meta *meta;
1303 const struct sr_datafeed_logic *logic;
1304 const struct sr_datafeed_analog *analog;
1305 struct sr_config *src;
1308 switch (packet->type) {
1314 /* Payload is a simple struct. */
1315 g_free((void *)packet->payload);
1318 meta = packet->payload;
1319 for (l = meta->config; l; l = l->next) {
1321 g_variant_unref(src->data);
1324 g_slist_free(meta->config);
1325 g_free((void *)packet->payload);
1328 logic = packet->payload;
1329 g_free(logic->data);
1330 g_free((void *)packet->payload);
1333 analog = packet->payload;
1334 g_slist_free(analog->channels);
1335 g_free(analog->data);
1336 g_free((void *)packet->payload);
1339 sr_err("Unknown packet type %d", packet->type);