struct discover_server {
int socket;
+ struct waitset *waitset;
struct waiter *waiter;
struct list clients;
struct device_handler *device_handler;
server->device_handler = handler;
}
-struct discover_server *discover_server_init(void)
+struct discover_server *discover_server_init(struct waitset *waitset)
{
struct discover_server *server;
struct sockaddr_un addr;
return NULL;
server->waiter = NULL;
+ server->waitset = waitset;
list_init(&server->clients);
unlink(PB_SOCKET_PATH);
goto out_err;
}
- server->waiter = waiter_register(server->socket, WAIT_IN,
- discover_server_process, server);
+ server->waiter = waiter_register(server->waitset, server->socket,
+ WAIT_IN, discover_server_process, server);
return server;
#ifndef _DISCOVER_SERVER_H
#define _DISCOVER_SERVER_H
+#include <waiter/waiter.h>
+
struct discover_server;
struct device_handler;
struct device;
-struct discover_server *discover_server_init(void);
+struct discover_server *discover_server_init(struct waitset *waitset);
void discover_server_destroy(struct discover_server *server);
{
struct device_handler *handler;
struct discover_server *server;
+ struct waitset *waitset;
struct opts opts;
struct udev *udev;
struct user_event *uev;
signal(SIGINT, sigint_handler);
- server = discover_server_init();
+ waitset = waitset_create(NULL);
+
+ server = discover_server_init(waitset);
if (!server)
return EXIT_FAILURE;
discover_server_set_device_source(server, handler);
- udev = udev_init(handler);
+ udev = udev_init(waitset, handler);
if (!udev)
return EXIT_FAILURE;
- uev = user_event_init(handler);
+ uev = user_event_init(waitset, handler);
if (!uev)
return EXIT_FAILURE;
user_event_trigger(uev);
for (running = 1; running;) {
- if (waiter_poll())
+ if (waiter_poll(waitset))
break;
}
device_handler_destroy(handler);
+ waitset_destroy(waitset);
pb_log("--- end ---\n");
return 0;
}
-struct udev *udev_init(struct device_handler *handler)
+struct udev *udev_init(struct waitset *waitset, struct device_handler *handler)
{
struct sockaddr_un addr;
struct udev *udev;
goto out_err;
}
- waiter_register(udev->socket, WAIT_IN, udev_process, udev);
+ waiter_register(waitset, udev->socket, WAIT_IN, udev_process, udev);
pb_log("%s: waiting on %s\n", __func__, PBOOT_DEVICE_SOCKET);
struct udev;
struct device_handler;
+struct waitset;
-struct udev *udev_init(struct device_handler *handler);
+struct udev *udev_init(struct waitset *waitset, struct device_handler *handler);
int udev_trigger(struct udev *udev);
void udev_destroy(struct udev *udev);
return 0;
}
-struct user_event *user_event_init(struct device_handler *handler)
+struct user_event *user_event_init(struct waitset *waitset,
+ struct device_handler *handler)
{
struct sockaddr_un addr;
struct user_event *uev;
strerror(errno));
}
- waiter_register(uev->socket, WAIT_IN, user_event_process, uev);
+ waiter_register(waitset, uev->socket, WAIT_IN, user_event_process, uev);
pb_log("%s: waiting on %s\n", __func__, PBOOT_USER_EVENT_SOCKET);
#define PBOOT_USER_EVENT_SIZE (1 * 1024)
struct user_event;
+struct waitset;
-struct user_event *user_event_init(struct device_handler *handler);
+struct user_event *user_event_init(struct waitset *waitset,
+ struct device_handler *handler);
void user_event_trigger(struct user_event *uev);
void user_event_destroy(struct user_event *uev);
#include "waiter.h"
struct waiter {
+ struct waitset *set;
int fd;
int events;
waiter_cb callback;
void *arg;
};
-static struct waiter *waiters;
-static int n_waiters;
+struct waitset {
+ struct waiter *waiters;
+ int n_waiters;
+ struct pollfd *pollfds;
+ int n_pollfds;
+};
-struct waiter *waiter_register(int fd, int events,
+struct waitset *waitset_create(void *ctx)
+{
+ struct waitset *set = talloc_zero(ctx, struct waitset);
+ return set;
+}
+
+void waitset_destroy(struct waitset *set)
+{
+ talloc_free(set);
+}
+
+struct waiter *waiter_register(struct waitset *set, int fd, int events,
waiter_cb callback, void *arg)
{
- struct waiter *waiter;
+ struct waiter *waiters, *waiter;
- n_waiters++;
+ waiters = talloc_realloc(set, set->waiters,
+ struct waiter, set->n_waiters + 1);
- waiters = talloc_realloc(NULL, waiters, struct waiter, n_waiters);
-
- if(!waiters)
+ if (!waiters)
return NULL;
-
- waiter = &waiters[n_waiters - 1];
+ set->n_waiters++;
+ set->waiters = waiters;
+
+ waiter = &set->waiters[set->n_waiters - 1];
+
+ waiter->set = set;
waiter->fd = fd;
waiter->events = events;
waiter->callback = callback;
void waiter_remove(struct waiter *waiter)
{
+ struct waitset *set = waiter->set;
int i;
- i = waiter - waiters;
- assert(i >= 0 && i < n_waiters);
+ i = waiter - set->waiters;
+ assert(i >= 0 && i < set->n_waiters);
- n_waiters--;
- memmove(&waiters[i], &waiters[i+1],
- (n_waiters - i) * sizeof(waiters[0]));
+ set->n_waiters--;
+ memmove(&set->waiters[i], &set->waiters[i+1],
+ (set->n_waiters - i) * sizeof(set->waiters[0]));
- waiters = talloc_realloc(NULL, waiters, struct waiter, n_waiters);
+ set->waiters = talloc_realloc(set->waiters, set->waiters, struct waiter,
+ set->n_waiters);
}
-int waiter_poll(void)
+int waiter_poll(struct waitset *set)
{
- static struct pollfd *pollfds;
- static int n_pollfds;
int i, rc;
- if (n_waiters != n_pollfds) {
- pollfds = talloc_realloc(NULL, pollfds,
- struct pollfd, n_waiters);
- n_pollfds = n_waiters;
+ if (set->n_waiters != set->n_pollfds) {
+ set->pollfds = talloc_realloc(set, set->pollfds,
+ struct pollfd, set->n_waiters);
+ set->n_pollfds = set->n_waiters;
}
- for (i = 0; i < n_waiters; i++) {
- pollfds[i].fd = waiters[i].fd;
- pollfds[i].events = waiters[i].events;
- pollfds[i].revents = 0;
+ for (i = 0; i < set->n_waiters; i++) {
+ set->pollfds[i].fd = set->waiters[i].fd;
+ set->pollfds[i].events = set->waiters[i].events;
+ set->pollfds[i].revents = 0;
}
- rc = poll(pollfds, n_waiters, -1);
+ rc = poll(set->pollfds, set->n_waiters, -1);
if (rc <= 0)
return rc;
- for (i = 0; i < n_waiters; i++) {
- if (pollfds[i].revents) {
- rc = waiters[i].callback(waiters[i].arg);
+ for (i = 0; i < set->n_waiters; i++) {
+ if (set->pollfds[i].revents) {
+ rc = set->waiters[i].callback(set->waiters[i].arg);
if (rc)
- waiter_remove(&waiters[i]);
+ waiter_remove(&set->waiters[i]);
}
}
#include <poll.h>
struct waiter;
+struct waitset;
enum events {
WAIT_IN = POLLIN,
typedef int (*waiter_cb)(void *);
-struct waiter *waiter_register(int fd, int events,
+struct waitset *waitset_create(void *ctx);
+void waitset_destroy(struct waitset *waitset);
+
+struct waiter *waiter_register(struct waitset *waitset, int fd, int events,
waiter_cb callback, void *arg);
void waiter_remove(struct waiter *waiter);
-int waiter_poll(void);
+int waiter_poll(struct waitset *waitset);
#endif /* _WAITER_H */
cui->on_kexec = on_kexec;
cui->timer.handle_timeout = cui_handle_timeout;
cui->dry_run = dry_run;
+ cui->waitset = waitset_create(cui);
/* Loop here for scripts that just started the server. */
atexit(nc_atexit);
nc_start();
- waiter_register(discover_client_get_fd(client), WAIT_IN,
- cui_client_process_socket, client);
+ waiter_register(cui->waitset, discover_client_get_fd(client), WAIT_IN,
+ cui_client_process_socket, client);
- waiter_register(STDIN_FILENO, WAIT_IN, cui_process_key, cui);
+ waiter_register(cui->waitset, STDIN_FILENO, WAIT_IN,
+ cui_process_key, cui);
if (js_map) {
cui->pjs = pjs_init(cui, js_map);
if (cui->pjs)
- waiter_register(pjs_get_fd(cui->pjs), WAIT_IN,
- cui_process_js, cui);
+ waiter_register(cui->waitset, pjs_get_fd(cui->pjs),
+ WAIT_IN, cui_process_js, cui);
}
return cui;
cui->current->post(cui->current);
while (1) {
- int result = waiter_poll();
+ int result = waiter_poll(cui->waitset);
if (result < 0 && errno != EINTR) {
pb_log("%s: poll: %s\n", __func__, strerror(errno));
struct nc_scr *current;
struct pmenu *main;
struct ui_timer timer;
+ struct waitset *waitset;
struct pjs *pjs;
void *platform_info;
unsigned int default_item;
static int run(struct pbt_client *client)
{
while (1) {
- int result = waiter_poll();
+ int result = waiter_poll(client->waitset);
if (result < 0 && errno != EINTR) {
pb_log("%s: poll: %s\n", __func__, strerror(errno));
talloc_set_destructor(pbt_client, (void *)pbt_client_destructor);
+ pbt_client->waitset = waitset_create(pbt_client);
+
pbt_client->sig = "pbt_client";
pbt_client->kexec_cb = kexec_cb;
pbt_client->dry_run = dry_run;
- pbt_client->frame.scr = pbt_scr_init(pbt_client, backend, width, height,
- NULL, NULL);
+ pbt_client->frame.scr = pbt_scr_init(pbt_client, pbt_client->waitset,
+ backend, width, height, NULL, NULL);
+
if (!pbt_client->frame.scr)
goto fail_scr_init;
goto fail_client_init;
}
- waiter_register(discover_client_get_fd(pbt_client->discover_client),
- WAIT_IN, (waiter_cb)discover_client_process,
- pbt_client->discover_client);
+ waiter_register(pbt_client->waitset,
+ discover_client_get_fd(pbt_client->discover_client),
+ WAIT_IN, (waiter_cb)discover_client_process,
+ pbt_client->discover_client);
return pbt_client;
struct pbt_frame frame;
struct discover_client *discover_client;
+ struct waitset *waitset;
};
struct pbt_client *pbt_client_init(enum pbt_twin_backend backend,
memset(scr, 0, sizeof(*scr));
}
-struct pbt_scr *pbt_scr_init(void *talloc_ctx, enum pbt_twin_backend backend,
+struct pbt_scr *pbt_scr_init(void *talloc_ctx,
+ struct waitset *waitset,
+ enum pbt_twin_backend backend,
unsigned int width, unsigned int height,
const char *filename_background,
twin_bool_t (*scr_event_cb)(twin_screen_t *tscreen,
assert(waiter_fd != -1);
- waiter_register(waiter_fd, WAIT_IN, (void *)pbt_twin_waiter_cb,
+ waiter_register(waitset, waiter_fd, WAIT_IN, (void *)pbt_twin_waiter_cb,
&scr->twin_ctx);
return scr;
#if !defined(_PBT_SCR_H)
#define _PBT_SCR_H
+#include <waiter/waiter.h>
+
#include <libtwin/twin.h>
#include <libtwin/twin_jpeg.h>
#include <libtwin/twin_linux_mouse.h>
twin_pixmap_t *cursor;
};
-struct pbt_scr *pbt_scr_init(void *talloc_ctx, enum pbt_twin_backend backend,
+struct pbt_scr *pbt_scr_init(void *talloc_ctx, struct waitset *waitset,
+ enum pbt_twin_backend backend,
unsigned int width, unsigned int height,
const char *filename_background,
twin_bool_t (*scr_event_cb)(twin_screen_t *tscreen,
_p->height)
-#endif
\ No newline at end of file
+#endif