xen-project/xen
1
0 Fork 0
mirror of https://github.com/xen-project/xen.git synced 2026-10-28 02:01:24 +01:00
Code Issues Activity

tools/libs/light: replace _libxl_list.h with _xen_list.h

Browse Source 
Remove generating _libxl_list.h and use the common _xen_list.h instead.

Signed-off-by: Juergen Gross <jgross@suse.com>
Acked-by: Anthony PERARD <anthony.perard@citrix.com>
This commit is contained in:
Juergen Gross authored and Andrew Cooper committed 2022-02-08 11:10:52 +00:00
1 parent 9b8dcd08e6
commit 9096f0e01e
12 files changed
+206 -214
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

tools/include/libxl.h
+2 -2
View File
@@ -747,7 +747,7 @@
typedef struct libxl__ctx libxl_ctx;
#include <libxl_uuid.h>
#include <_libxl_list.h>
#include <_xen_list.h>
/* API compatibility. */
#ifdef LIBXL_API_VERSION
@@ -1448,7 +1448,7 @@ typedef struct {
} libxl_enum_string_table;
struct libxl_event;
typedef LIBXL_TAILQ_ENTRY(struct libxl_event) libxl_ev_link;
typedef XEN_TAILQ_ENTRY(struct libxl_event) libxl_ev_link;
/*
* A boolean variable with an explicit default state.
tools/libs/light/Makefile
+3 -7
View File
@@ -153,14 +153,14 @@ LIBXL_TEST_OBJS += $(foreach t, $(LIBXL_TESTS_INSIDE),libxl_test_$t.opic)
TEST_PROG_OBJS += $(foreach t, $(LIBXL_TESTS_PROGS),test_$t.o) test_common.o
TEST_PROGS += $(foreach t, $(LIBXL_TESTS_PROGS),test_$t)
AUTOINCS = $(XEN_INCLUDE)/_libxl_list.h _libxl_save_msgs_callout.h _libxl_save_msgs_helper.h
AUTOINCS = _libxl_save_msgs_callout.h _libxl_save_msgs_helper.h
AUTOSRCS = _libxl_save_msgs_callout.c _libxl_save_msgs_helper.c
CLIENTS = testidl libxl-save-helper
SAVE_HELPER_OBJS = libxl_save_helper.o _libxl_save_msgs_helper.o
LIBHEADER := libxl.h libxl_event.h libxl_json.h _libxl_types.h _libxl_types_json.h _libxl_list.h libxl_utils.h libxl_uuid.h
LIBHEADER := libxl.h libxl_event.h libxl_json.h _libxl_types.h _libxl_types_json.h libxl_utils.h libxl_uuid.h
NO_HEADERS_CHK := y
@@ -201,17 +201,13 @@ _libxl.api-for-check: $(XEN_INCLUDE)/libxl.h $(AUTOINCS)
>$@.new
mv -f $@.new $@
$(XEN_INCLUDE)/_libxl_list.h: $(XEN_INCLUDE)/xen-external/bsd-sys-queue-h-seddery $(XEN_INCLUDE)/xen-external/bsd-sys-queue.h
$(PERL) $^ --prefix=libxl >$(notdir $@).new
$(call move-if-changed,$(notdir $@).new,$@)
_libxl_save_msgs_helper.c _libxl_save_msgs_callout.c \
_libxl_save_msgs_helper.h _libxl_save_msgs_callout.h: \
libxl_save_msgs_gen.pl
$(PERL) -w $< $@ >$@.new
$(call move-if-changed,$@.new,$@)
$(XEN_INCLUDE)/libxl.h: $(XEN_INCLUDE)/_libxl_types.h $(XEN_INCLUDE)/_libxl_list.h
$(XEN_INCLUDE)/libxl.h: $(XEN_INCLUDE)/_libxl_types.h
$(XEN_INCLUDE)/libxl_json.h: $(XEN_INCLUDE)/_libxl_types_json.h
libxl_internal.h: _libxl_types_internal.h _libxl_types_private.h _libxl_types_internal_private.h
libxl_internal_json.h: _libxl_types_internal_json.h
tools/libs/light/libxl.c
+20 -20
View File
@@ -41,29 +41,29 @@ int libxl_ctx_alloc(libxl_ctx **pctx, int version,
ctx->nogc_gc.alloc_maxsize = -1;
ctx->nogc_gc.owner = ctx;
LIBXL_TAILQ_INIT(&ctx->occurred);
XEN_TAILQ_INIT(&ctx->occurred);
ctx->osevent_hooks = 0;
ctx->poller_app = 0;
LIBXL_LIST_INIT(&ctx->pollers_event);
LIBXL_LIST_INIT(&ctx->pollers_idle);
LIBXL_LIST_INIT(&ctx->pollers_active);
XEN_LIST_INIT(&ctx->pollers_event);
XEN_LIST_INIT(&ctx->pollers_idle);
XEN_LIST_INIT(&ctx->pollers_active);
LIBXL_LIST_INIT(&ctx->efds);
LIBXL_TAILQ_INIT(&ctx->etimes);
XEN_LIST_INIT(&ctx->efds);
XEN_TAILQ_INIT(&ctx->etimes);
ctx->watch_slots = 0;
LIBXL_SLIST_INIT(&ctx->watch_freeslots);
XEN_SLIST_INIT(&ctx->watch_freeslots);
libxl__ev_fd_init(&ctx->watch_efd);
ctx->xce = 0;
LIBXL_LIST_INIT(&ctx->evtchns_waiting);
XEN_LIST_INIT(&ctx->evtchns_waiting);
libxl__ev_fd_init(&ctx->evtchn_efd);
LIBXL_LIST_INIT(&ctx->aos_inprogress);
XEN_LIST_INIT(&ctx->aos_inprogress);
LIBXL_TAILQ_INIT(&ctx->death_list);
XEN_TAILQ_INIT(&ctx->death_list);
libxl__ev_xswatch_init(&ctx->death_watch);
ctx->childproc_hooks = &libxl__childproc_default_hooks;
@@ -122,14 +122,14 @@ int libxl_ctx_alloc(libxl_ctx **pctx, int version,
static void free_disable_deaths(libxl__gc *gc,
struct libxl__evgen_domain_death_list *l) {
libxl_evgen_domain_death *death;
while ((death = LIBXL_TAILQ_FIRST(l)))
while ((death = XEN_TAILQ_FIRST(l)))
libxl__evdisable_domain_death(gc, death);
}
static void discard_events(struct libxl__event_list *l) {
/* doesn't bother unlinking from the list, so l is corrupt on return */
libxl_event *ev, *next;
LIBXL_TAILQ_FOREACH_SAFE(ev, l, link, next)
XEN_TAILQ_FOREACH_SAFE(ev, l, link, next)
libxl_event_free(0, ev);
}
@@ -150,7 +150,7 @@ int libxl_ctx_free(libxl_ctx *ctx)
free_disable_deaths(gc, &CTX->death_reported);
libxl_evgen_disk_eject *eject;
while ((eject = LIBXL_LIST_FIRST(&CTX->disk_eject_evgens)))
while ((eject = XEN_LIST_FIRST(&CTX->disk_eject_evgens)))
libxl__evdisable_disk_eject(gc, eject);
libxl_childproc_setmode(CTX,0,0);
@@ -162,10 +162,10 @@ int libxl_ctx_free(libxl_ctx *ctx)
/* Now there should be no more events requested from the application: */
assert(LIBXL_LIST_EMPTY(&ctx->efds));
assert(LIBXL_TAILQ_EMPTY(&ctx->etimes));
assert(LIBXL_LIST_EMPTY(&ctx->evtchns_waiting));
assert(LIBXL_LIST_EMPTY(&ctx->aos_inprogress));
assert(XEN_LIST_EMPTY(&ctx->efds));
assert(XEN_TAILQ_EMPTY(&ctx->etimes));
assert(XEN_LIST_EMPTY(&ctx->evtchns_waiting));
assert(XEN_LIST_EMPTY(&ctx->aos_inprogress));
if (ctx->xch) xc_interface_close(ctx->xch);
libxl_version_info_dispose(&ctx->version_info);
@@ -174,10 +174,10 @@ int libxl_ctx_free(libxl_ctx *ctx)
libxl__poller_put(ctx, ctx->poller_app);
ctx->poller_app = NULL;
assert(LIBXL_LIST_EMPTY(&ctx->pollers_event));
assert(LIBXL_LIST_EMPTY(&ctx->pollers_active));
assert(XEN_LIST_EMPTY(&ctx->pollers_event));
assert(XEN_LIST_EMPTY(&ctx->pollers_active));
libxl__poller *poller, *poller_tmp;
LIBXL_LIST_FOREACH_SAFE(poller, &ctx->pollers_idle, entry, poller_tmp) {
XEN_LIST_FOREACH_SAFE(poller, &ctx->pollers_idle, entry, poller_tmp) {
libxl__poller_dispose(poller);
free(poller);
}
tools/libs/light/libxl_aoutils.c
+10 -10
View File
@@ -106,7 +106,7 @@ void libxl__datacopier_init(libxl__datacopier_state *dc)
libxl__ao_abortable_init(&dc->abrt);
libxl__ev_fd_init(&dc->toread);
libxl__ev_fd_init(&dc->towrite);
LIBXL_TAILQ_INIT(&dc->bufs);
XEN_TAILQ_INIT(&dc->bufs);
}
void libxl__datacopier_kill(libxl__datacopier_state *dc)
@@ -117,9 +117,9 @@ void libxl__datacopier_kill(libxl__datacopier_state *dc)
libxl__ao_abortable_deregister(&dc->abrt);
libxl__ev_fd_deregister(gc, &dc->toread);
libxl__ev_fd_deregister(gc, &dc->towrite);
LIBXL_TAILQ_FOREACH_SAFE(buf, &dc->bufs, entry, tbuf)
XEN_TAILQ_FOREACH_SAFE(buf, &dc->bufs, entry, tbuf)
free(buf);
LIBXL_TAILQ_INIT(&dc->bufs);
XEN_TAILQ_INIT(&dc->bufs);
}
static void datacopier_callback(libxl__egc *egc, libxl__datacopier_state *dc,
@@ -182,7 +182,7 @@ void libxl__datacopier_prefixdata(libxl__egc *egc, libxl__datacopier_state *dc,
memcpy(buf->buf, ptr, buf->used);
dc->used += buf->used;
LIBXL_TAILQ_INSERT_TAIL(&dc->bufs, buf, entry);
XEN_TAILQ_INSERT_TAIL(&dc->bufs, buf, entry);
}
}
@@ -235,18 +235,18 @@ static void datacopier_readable(libxl__egc *egc, libxl__ev_fd *ev,
r = read(ev->fd, dc->readbuf + dc->used, dc->bytes_to_read);
} else {
while (dc->used >= dc->maxsz) {
libxl__datacopier_buf *rm = LIBXL_TAILQ_FIRST(&dc->bufs);
libxl__datacopier_buf *rm = XEN_TAILQ_FIRST(&dc->bufs);
dc->used -= rm->used;
assert(dc->used >= 0);
LIBXL_TAILQ_REMOVE(&dc->bufs, rm, entry);
XEN_TAILQ_REMOVE(&dc->bufs, rm, entry);
free(rm);
}
buf = LIBXL_TAILQ_LAST(&dc->bufs, libxl__datacopier_bufs);
buf = XEN_TAILQ_LAST(&dc->bufs, libxl__datacopier_bufs);
if (!buf || buf->used >= sizeof(buf->buf)) {
buf = libxl__malloc(NOGC, sizeof(*buf));
buf->used = 0;
LIBXL_TAILQ_INSERT_TAIL(&dc->bufs, buf, entry);
XEN_TAILQ_INSERT_TAIL(&dc->bufs, buf, entry);
}
r = read(ev->fd, buf->buf + buf->used,
min_t(size_t, sizeof(buf->buf) - buf->used,
@@ -331,11 +331,11 @@ static void datacopier_writable(libxl__egc *egc, libxl__ev_fd *ev,
}
assert(revents & POLLOUT);
for (;;) {
libxl__datacopier_buf *buf = LIBXL_TAILQ_FIRST(&dc->bufs);
libxl__datacopier_buf *buf = XEN_TAILQ_FIRST(&dc->bufs);
if (!buf)
break;
if (!buf->used) {
LIBXL_TAILQ_REMOVE(&dc->bufs, buf, entry);
XEN_TAILQ_REMOVE(&dc->bufs, buf, entry);
free(buf);
continue;
}
tools/libs/light/libxl_device.c
+13 -14
View File
@@ -1476,7 +1476,7 @@ static void qdisk_spawn_outcome(libxl__egc *egc, libxl__dm_spawn_state *dmss,
*/
typedef struct libxl__ddomain_device {
libxl__device *dev;
LIBXL_SLIST_ENTRY(struct libxl__ddomain_device) next;
XEN_SLIST_ENTRY(struct libxl__ddomain_device) next;
} libxl__ddomain_device;
/*
@@ -1485,8 +1485,8 @@ typedef struct libxl__ddomain_device {
typedef struct libxl__ddomain_guest {
uint32_t domid;
int num_qdisks;
LIBXL_SLIST_HEAD(, struct libxl__ddomain_device) devices;
LIBXL_SLIST_ENTRY(struct libxl__ddomain_guest) next;
XEN_SLIST_HEAD(, struct libxl__ddomain_device) devices;
XEN_SLIST_ENTRY(struct libxl__ddomain_guest) next;
} libxl__ddomain_guest;
/*
@@ -1496,7 +1496,7 @@ typedef struct libxl__ddomain_guest {
typedef struct {
libxl__ao *ao;
libxl__ev_xswatch watch;
LIBXL_SLIST_HEAD(, struct libxl__ddomain_guest) guests;
XEN_SLIST_HEAD(, struct libxl__ddomain_guest) guests;
} libxl__ddomain;
static libxl__ddomain_guest *search_for_guest(libxl__ddomain *ddomain,
@@ -1504,7 +1504,7 @@ static libxl__ddomain_guest *search_for_guest(libxl__ddomain *ddomain,
{
libxl__ddomain_guest *dguest;
LIBXL_SLIST_FOREACH(dguest, &ddomain->guests, next) {
XEN_SLIST_FOREACH(dguest, &ddomain->guests, next) {
if (dguest->domid == domid)
return dguest;
}
@@ -1516,7 +1516,7 @@ static libxl__ddomain_device *search_for_device(libxl__ddomain_guest *dguest,
{
libxl__ddomain_device *ddev;
LIBXL_SLIST_FOREACH(ddev, &dguest->devices, next) {
XEN_SLIST_FOREACH(ddev, &dguest->devices, next) {
#define LIBXL_DEVICE_CMP(dev1, dev2, entry) (dev1->entry == dev2->entry)
if (LIBXL_DEVICE_CMP(ddev->dev, dev, backend_devid) &&
LIBXL_DEVICE_CMP(ddev->dev, dev, backend_domid) &&
@@ -1537,8 +1537,8 @@ static void check_and_maybe_remove_guest(libxl__gc *gc,
{
assert(ddomain);
if (dguest != NULL && LIBXL_SLIST_FIRST(&dguest->devices) == NULL) {
LIBXL_SLIST_REMOVE(&ddomain->guests, dguest, libxl__ddomain_guest,
if (dguest != NULL && XEN_SLIST_FIRST(&dguest->devices) == NULL) {
XEN_SLIST_REMOVE(&ddomain->guests, dguest, libxl__ddomain_guest,
next);
LOGD(DEBUG, dguest->domid, "Removed domain from the list of active guests");
/* Clear any leftovers in libxl/<domid> */
@@ -1572,7 +1572,7 @@ static int add_device(libxl__egc *egc, libxl__ao *ao,
ddev = libxl__zalloc(NOGC, sizeof(*ddev));
ddev->dev = libxl__zalloc(NOGC, sizeof(*ddev->dev));
*ddev->dev = *dev;
LIBXL_SLIST_INSERT_HEAD(&dguest->devices, ddev, next);
XEN_SLIST_INSERT_HEAD(&dguest->devices, ddev, next);
LOGD(DEBUG, dev->domid, "Added device %s to the list of active devices",
libxl__device_backend_path(gc, dev));
@@ -1649,8 +1649,7 @@ static int remove_device(libxl__egc *egc, libxl__ao *ao,
* above or from add_device make a copy of the data they use, so
* there's no risk of dereferencing.
*/
LIBXL_SLIST_REMOVE(&dguest->devices, ddev, libxl__ddomain_device,
next);
XEN_SLIST_REMOVE(&dguest->devices, ddev, libxl__ddomain_device, next);
LOGD(DEBUG, dev->domid, "Removed device %s from the list of active devices",
libxl__device_backend_path(gc, dev));
@@ -1716,8 +1715,8 @@ static void backend_watch_callback(libxl__egc *egc, libxl__ev_xswatch *watch,
/* Create a new guest struct and initialize it */
dguest = libxl__zalloc(NOGC, sizeof(*dguest));
dguest->domid = dev->domid;
LIBXL_SLIST_INIT(&dguest->devices);
LIBXL_SLIST_INSERT_HEAD(&ddomain->guests, dguest, next);
XEN_SLIST_INIT(&dguest->devices);
XEN_SLIST_INSERT_HEAD(&ddomain->guests, dguest, next);
LOGD(DEBUG, dguest->domid, "Added domain to the list of active guests");
}
ddev = search_for_device(dguest, dev);
@@ -1766,7 +1765,7 @@ int libxl_device_events_handler(libxl_ctx *ctx,
int i, j, k;
ddomain.ao = ao;
LIBXL_SLIST_INIT(&ddomain.guests);
XEN_SLIST_INIT(&ddomain.guests);
rc = libxl__get_domid(gc, &domid);
if (rc) {
tools/libs/light/libxl_disk.c
+2 -2
View File
@@ -88,7 +88,7 @@ int libxl_evenable_disk_eject(libxl_ctx *ctx, uint32_t guest_domid,
memset(evg, 0, sizeof(*evg));
evg->user = user;
evg->domid = guest_domid;
LIBXL_LIST_INSERT_HEAD(&CTX->disk_eject_evgens, evg, entry);
XEN_LIST_INSERT_HEAD(&CTX->disk_eject_evgens, evg, entry);
uint32_t domid = libxl_get_stubdom_id(ctx, guest_domid);
@@ -133,7 +133,7 @@ int libxl_evenable_disk_eject(libxl_ctx *ctx, uint32_t guest_domid,
void libxl__evdisable_disk_eject(libxl__gc *gc, libxl_evgen_disk_eject *evg) {
CTX_LOCK;
LIBXL_LIST_REMOVE(evg, entry);
XEN_LIST_REMOVE(evg, entry);
if (libxl__ev_xswatch_isregistered(&evg->watch))
libxl__ev_xswatch_deregister(gc, &evg->watch);
tools/libs/light/libxl_domain.c
+9 -9
View File
@@ -867,7 +867,7 @@ static void domain_death_occurred(libxl__egc *egc,
LOGD(DEBUG, evg->domid, "%s", why);
libxl_evgen_domain_death *evg_next = LIBXL_TAILQ_NEXT(evg, entry);
libxl_evgen_domain_death *evg_next = XEN_TAILQ_NEXT(evg, entry);
*evg_upd = evg_next;
libxl_event *ev = NEW_EVENT(egc, DOMAIN_DEATH, evg->domid, evg->user);
@@ -875,8 +875,8 @@ static void domain_death_occurred(libxl__egc *egc,
libxl__event_occurred(egc, ev);
evg->death_reported = 1;
LIBXL_TAILQ_REMOVE(&CTX->death_list, evg, entry);
LIBXL_TAILQ_INSERT_HEAD(&CTX->death_reported, evg, entry);
XEN_TAILQ_REMOVE(&CTX->death_list, evg, entry);
XEN_TAILQ_INSERT_HEAD(&CTX->death_reported, evg, entry);
}
static void domain_death_xswatch_callback(libxl__egc *egc, libxl__ev_xswatch *w,
@@ -887,12 +887,12 @@ static void domain_death_xswatch_callback(libxl__egc *egc, libxl__ev_xswatch *w,
CTX_LOCK;
evg = LIBXL_TAILQ_FIRST(&CTX->death_list);
evg = XEN_TAILQ_FIRST(&CTX->death_list);
for (;;) {
if (!evg) goto out;
int nentries = LIBXL_TAILQ_NEXT(evg, entry) ? 200 : 1;
int nentries = XEN_TAILQ_NEXT(evg, entry) ? 200 : 1;
xc_domaininfo_t domaininfos[nentries];
const xc_domaininfo_t *got = domaininfos, *gotend;
@@ -966,7 +966,7 @@ static void domain_death_xswatch_callback(libxl__egc *egc, libxl__ev_xswatch *w,
evg->shutdown_reported = 1;
}
evg = LIBXL_TAILQ_NEXT(evg, entry);
evg = XEN_TAILQ_NEXT(evg, entry);
}
assert(rc); /* rc==0 results in us eating all evgs and quitting */
@@ -1015,13 +1015,13 @@ void libxl__evdisable_domain_death(libxl__gc *gc,
CTX_LOCK;
if (!evg->death_reported)
LIBXL_TAILQ_REMOVE(&CTX->death_list, evg, entry);
XEN_TAILQ_REMOVE(&CTX->death_list, evg, entry);
else
LIBXL_TAILQ_REMOVE(&CTX->death_reported, evg, entry);
XEN_TAILQ_REMOVE(&CTX->death_reported, evg, entry);
free(evg);
if (!LIBXL_TAILQ_FIRST(&CTX->death_list) &&
if (!XEN_TAILQ_FIRST(&CTX->death_list) &&
libxl__ev_xswatch_isregistered(&CTX->death_watch))
libxl__ev_xswatch_deregister(gc, &CTX->death_watch);
tools/libs/light/libxl_event.c
+63 -65
View File
@@ -165,7 +165,7 @@ static void ao__check_destroy(libxl_ctx *ctx, libxl__ao *ao);
*/
static void pollers_note_osevent_added(libxl_ctx *ctx) {
libxl__poller *poller;
LIBXL_LIST_FOREACH(poller, &ctx->pollers_active, active_entry)
XEN_LIST_FOREACH(poller, &ctx->pollers_active, active_entry)
poller->osevents_added = 1;
}
@@ -189,7 +189,7 @@ void libxl__egc_ao_cleanup_1_baton(libxl__gc *gc)
if (CTX->poller_app->osevents_added)
baton_wake(gc, CTX->poller_app);
LIBXL_LIST_FOREACH(search, &CTX->pollers_active, active_entry) {
XEN_LIST_FOREACH(search, &CTX->pollers_active, active_entry) {
if (search == CTX->poller_app)
/* This one is special. We can't give it the baton. */
continue;
@@ -279,7 +279,7 @@ void libxl__egc_ao_cleanup_1_baton(libxl__gc *gc)
struct libxl__osevent_hook_nexus {
void *ev;
void *for_app_reg;
LIBXL_SLIST_ENTRY(libxl__osevent_hook_nexus) next;
XEN_SLIST_ENTRY(libxl__osevent_hook_nexus) next;
};
static void *osevent_ev_from_hook_nexus(libxl_ctx *ctx,
@@ -293,7 +293,7 @@ static void osevent_release_nexus(libxl__gc *gc,
libxl__osevent_hook_nexus *nexus)
{
nexus->ev = 0;
LIBXL_SLIST_INSERT_HEAD(nexi_idle, nexus, next);
XEN_SLIST_INSERT_HEAD(nexi_idle, nexus, next);
}
/*----- OSEVENT* hook functions for nexusop "alloc" -----*/
@@ -301,9 +301,9 @@ static void osevent_hook_pre_alloc(libxl__gc *gc, void *ev,
libxl__osevent_hook_nexi *nexi_idle,
libxl__osevent_hook_nexus **nexus_r)
{
libxl__osevent_hook_nexus *nexus = LIBXL_SLIST_FIRST(nexi_idle);
libxl__osevent_hook_nexus *nexus = XEN_SLIST_FIRST(nexi_idle);
if (nexus) {
LIBXL_SLIST_REMOVE_HEAD(nexi_idle, next);
XEN_SLIST_REMOVE_HEAD(nexi_idle, next);
} else {
nexus = libxl__zalloc(NOGC, sizeof(*nexus));
}
@@ -364,7 +364,7 @@ int libxl__ev_fd_register(libxl__gc *gc, libxl__ev_fd *ev,
ev->events = events;
ev->func = func;
LIBXL_LIST_INSERT_HEAD(&CTX->efds, ev, entry);
XEN_LIST_INSERT_HEAD(&CTX->efds, ev, entry);
pollers_note_osevent_added(CTX);
rc = 0;
@@ -409,10 +409,10 @@ void libxl__ev_fd_deregister(libxl__gc *gc, libxl__ev_fd *ev)
DBG("ev_fd=%p deregister fd=%d", ev, ev->fd);
OSEVENT_HOOK_VOID(fd,deregister, release, ev->fd, ev->nexus->for_app_reg);
LIBXL_LIST_REMOVE(ev, entry);
XEN_LIST_REMOVE(ev, entry);
ev->fd = -1;
LIBXL_LIST_FOREACH(poller, &CTX->pollers_active, active_entry)
XEN_LIST_FOREACH(poller, &CTX->pollers_active, active_entry)
poller->fds_deregistered = 1;
out:
@@ -504,7 +504,7 @@ static void time_deregister(libxl__gc *gc, libxl__ev_time *ev)
OSEVENT_HOOK_VOID(timeout,modify,
noop /* release nexus in _occurred_ */,
&ev->nexus->for_app_reg, right_away);
LIBXL_TAILQ_REMOVE(&CTX->etimes, ev, entry);
XEN_TAILQ_REMOVE(&CTX->etimes, ev, entry);
}
}
@@ -640,7 +640,7 @@ static void time_occurs(libxl__egc *egc, libxl__ev_time *etime, int rc)
libxl__ev_xswatch *libxl__watch_slot_contents(libxl__gc *gc, int slotnum)
{
libxl__ev_watch_slot *slot = &CTX->watch_slots[slotnum];
libxl__ev_watch_slot *slotcontents = LIBXL_SLIST_NEXT(slot, empty);
libxl__ev_watch_slot *slotcontents = XEN_SLIST_NEXT(slot, empty);
if (slotcontents == NULL ||
((uintptr_t)slotcontents >= (uintptr_t)CTX->watch_slots &&
@@ -672,7 +672,7 @@ libxl__ev_xswatch *libxl__watch_slot_contents(libxl__gc *gc, int slotnum)
static void libxl__set_watch_slot_contents(libxl__ev_watch_slot *slot,
libxl__ev_xswatch *w)
{
/* we look a bit behind the curtain of LIBXL_SLIST, to explicitly
/* we look a bit behind the curtain of XEN_SLIST, to explicitly
* assign to the pointer that's the next link. See the comment
* by the definition of libxl__ev_watch_slot */
slot->empty.sle_next = (void*)w;
@@ -784,7 +784,7 @@ int libxl__ev_xswatch_register(libxl__gc *gc, libxl__ev_xswatch *w,
if (rc) goto out_rc;
}
if (LIBXL_SLIST_EMPTY(&CTX->watch_freeslots)) {
if (XEN_SLIST_EMPTY(&CTX->watch_freeslots)) {
/* Free list is empty so there is not in fact a linked
* free list in the array and we can safely realloc it */
int newarraysize = (CTX->watch_nslots + 1) << 2;
@@ -794,14 +794,13 @@ int libxl__ev_xswatch_register(libxl__gc *gc, libxl__ev_xswatch *w,
CTX->watch_slots, sizeof(*newarray) * newarraysize);
if (!newarray) goto out_nomem;
for (i = CTX->watch_nslots; i < newarraysize; i++)
LIBXL_SLIST_INSERT_HEAD(&CTX->watch_freeslots,
&newarray[i], empty);
XEN_SLIST_INSERT_HEAD(&CTX->watch_freeslots, &newarray[i], empty);
CTX->watch_slots = newarray;
CTX->watch_nslots = newarraysize;
}
use = LIBXL_SLIST_FIRST(&CTX->watch_freeslots);
use = XEN_SLIST_FIRST(&CTX->watch_freeslots);
assert(use);
LIBXL_SLIST_REMOVE_HEAD(&CTX->watch_freeslots, empty);
XEN_SLIST_REMOVE_HEAD(&CTX->watch_freeslots, empty);
path_copy = strdup(path);
if (!path_copy) goto out_nomem;
@@ -832,7 +831,7 @@ int libxl__ev_xswatch_register(libxl__gc *gc, libxl__ev_xswatch *w,
rc = ERROR_NOMEM;
out_rc:
if (use)
LIBXL_SLIST_INSERT_HEAD(&CTX->watch_freeslots, use, empty);
XEN_SLIST_INSERT_HEAD(&CTX->watch_freeslots, use, empty);
free(path_copy);
watches_check_fd_deregister(gc);
CTX_UNLOCK;
@@ -856,7 +855,7 @@ void libxl__ev_xswatch_deregister(libxl__gc *gc, libxl__ev_xswatch *w)
LOGEV(ERROR, errno, "remove watch for path %s", w->path);
libxl__ev_watch_slot *slot = &CTX->watch_slots[w->slotnum];
LIBXL_SLIST_INSERT_HEAD(&CTX->watch_freeslots, slot, empty);
XEN_SLIST_INSERT_HEAD(&CTX->watch_freeslots, slot, empty);
w->slotnum = -1;
CTX->nwatches--;
watches_check_fd_deregister(gc);
@@ -927,7 +926,7 @@ static void evtchn_fd_callback(libxl__egc *egc, libxl__ev_fd *ev,
return;
}
LIBXL_LIST_FOREACH(evev, &CTX->evtchns_waiting, entry)
XEN_LIST_FOREACH(evev, &CTX->evtchns_waiting, entry)
if (port == evev->port)
goto found;
/* not found */
@@ -937,7 +936,7 @@ static void evtchn_fd_callback(libxl__egc *egc, libxl__ev_fd *ev,
found:
DBG("ev_evtchn=%p port=%d signaled", evev, port);
evev->waiting = 0;
LIBXL_LIST_REMOVE(evev, entry);
XEN_LIST_REMOVE(evev, entry);
evev->callback(egc, evev);
}
}
@@ -972,7 +971,7 @@ int libxl__ctx_evtchn_init(libxl__gc *gc) {
static void evtchn_check_fd_deregister(libxl__gc *gc)
{
if (CTX->xce && LIBXL_LIST_EMPTY(&CTX->evtchns_waiting))
if (CTX->xce && XEN_LIST_EMPTY(&CTX->evtchns_waiting))
libxl__ev_fd_deregister(gc, &CTX->evtchn_efd);
}
@@ -1003,7 +1002,7 @@ int libxl__ev_evtchn_wait(libxl__gc *gc, libxl__ev_evtchn *evev)
}
evev->waiting = 1;
LIBXL_LIST_INSERT_HEAD(&CTX->evtchns_waiting, evev, entry);
XEN_LIST_INSERT_HEAD(&CTX->evtchns_waiting, evev, entry);
return 0;
out:
@@ -1020,7 +1019,7 @@ void libxl__ev_evtchn_cancel(libxl__gc *gc, libxl__ev_evtchn *evev)
return;
evev->waiting = 0;
LIBXL_LIST_REMOVE(evev, entry);
XEN_LIST_REMOVE(evev, entry);
evtchn_check_fd_deregister(gc);
}
@@ -1095,7 +1094,7 @@ int libxl__ev_devstate_wait(libxl__ao *ao, libxl__ev_devstate *ds,
void libxl__ev_immediate_register(libxl__egc *egc, libxl__ev_immediate *ei)
{
LIBXL_STAILQ_INSERT_TAIL(&egc->ev_immediates, ei, entry);
XEN_STAILQ_INSERT_TAIL(&egc->ev_immediates, ei, entry);
}
/*
@@ -1221,7 +1220,7 @@ static int beforepoll_internal(libxl__gc *gc, libxl__poller *poller,
#define REQUIRE_FDS(BODY) do{ \
\
LIBXL_LIST_FOREACH(efd, &CTX->efds, entry) \
XEN_LIST_FOREACH(efd, &CTX->efds, entry) \
REQUIRE_FD(efd->fd, efd->events, BODY); \
\
REQUIRE_FD(poller->wakeup_pipe[0], POLLIN, BODY); \
@@ -1298,7 +1297,7 @@ static int beforepoll_internal(libxl__gc *gc, libxl__poller *poller,
poller->fds_deregistered = 0;
poller->osevents_added = 0;
libxl__ev_time *etime = LIBXL_TAILQ_FIRST(&CTX->etimes);
libxl__ev_time *etime = XEN_TAILQ_FIRST(&CTX->etimes);
if (etime) {
int our_timeout;
struct timeval rel;
@@ -1436,7 +1435,7 @@ static void afterpoll_internal(libxl__egc *egc, libxl__poller *poller,
* so that we don't call the same function again. */
int revents;
LIBXL_LIST_FOREACH(efd, &CTX->efds, entry) {
XEN_LIST_FOREACH(efd, &CTX->efds, entry) {
if (!efd->events)
continue;
@@ -1454,7 +1453,7 @@ static void afterpoll_internal(libxl__egc *egc, libxl__poller *poller,
}
for (;;) {
libxl__ev_time *etime = LIBXL_TAILQ_FIRST(&CTX->etimes);
libxl__ev_time *etime = XEN_TAILQ_FIRST(&CTX->etimes);
if (!etime)
break;
@@ -1494,8 +1493,8 @@ void libxl_osevent_register_hooks(libxl_ctx *ctx,
{
GC_INIT(ctx);
CTX_LOCK;
assert(LIBXL_LIST_EMPTY(&ctx->efds));
assert(LIBXL_TAILQ_EMPTY(&ctx->etimes));
assert(XEN_LIST_EMPTY(&ctx->efds));
assert(XEN_TAILQ_EMPTY(&ctx->etimes));
ctx->osevent_hooks = hooks;
ctx->osevent_user = user;
CTX_UNLOCK;
@@ -1534,7 +1533,7 @@ void libxl_osevent_occurred_timeout(libxl_ctx *ctx, void *for_libxl)
if (!ev) goto out;
assert(!ev->infinite);
LIBXL_TAILQ_REMOVE(&CTX->etimes, ev, entry);
XEN_TAILQ_REMOVE(&CTX->etimes, ev, entry);
time_occurs(egc, ev, ERROR_TIMEDOUT);
@@ -1577,9 +1576,9 @@ static void egc_run_callbacks(libxl__egc *egc)
libxl__aop_occurred *aop, *aop_tmp;
libxl__ev_immediate *ei;
while (!LIBXL_STAILQ_EMPTY(&egc->ev_immediates)) {
ei = LIBXL_STAILQ_FIRST(&egc->ev_immediates);
LIBXL_STAILQ_REMOVE_HEAD(&egc->ev_immediates, entry);
while (!XEN_STAILQ_EMPTY(&egc->ev_immediates)) {
ei = XEN_STAILQ_FIRST(&egc->ev_immediates);
XEN_STAILQ_REMOVE_HEAD(&egc->ev_immediates, entry);
CTX_LOCK;
/* This callback is internal to libxl and expects CTX to be
* locked. */
@@ -1587,15 +1586,15 @@ static void egc_run_callbacks(libxl__egc *egc)
CTX_UNLOCK;
}
LIBXL_TAILQ_FOREACH_SAFE(ev, &egc->occurred_for_callback, link, ev_tmp) {
LIBXL_TAILQ_REMOVE(&egc->occurred_for_callback, ev, link);
XEN_TAILQ_FOREACH_SAFE(ev, &egc->occurred_for_callback, link, ev_tmp) {
XEN_TAILQ_REMOVE(&egc->occurred_for_callback, ev, link);
LOG(DEBUG,"event %p callback type=%s",
ev, libxl_event_type_to_string(ev->type));
CTX->event_hooks->event_occurs(CTX->event_hooks_user, ev);
}
LIBXL_TAILQ_FOREACH_SAFE(aop, &egc->aops_for_callback, entry, aop_tmp) {
LIBXL_TAILQ_REMOVE(&egc->aops_for_callback, aop, entry);
XEN_TAILQ_FOREACH_SAFE(aop, &egc->aops_for_callback, entry, aop_tmp) {
XEN_TAILQ_REMOVE(&egc->aops_for_callback, aop, entry);
LOG(DEBUG,"ao %p: progress report: callback aop=%p", aop->ao, aop);
aop->how->callback(CTX, aop->ev, aop->how->for_callback);
@@ -1607,9 +1606,9 @@ static void egc_run_callbacks(libxl__egc *egc)
}
libxl__ao *ao, *ao_tmp;
LIBXL_TAILQ_FOREACH_SAFE(ao, &egc->aos_for_callback,
entry_for_callback, ao_tmp) {
LIBXL_TAILQ_REMOVE(&egc->aos_for_callback, ao, entry_for_callback);
XEN_TAILQ_FOREACH_SAFE(ao, &egc->aos_for_callback,
entry_for_callback, ao_tmp) {
XEN_TAILQ_REMOVE(&egc->aos_for_callback, ao, entry_for_callback);
LOG(DEBUG,"ao %p: completion callback", ao);
ao->how.callback(CTX, ao->rc, ao->how.u.for_callback);
CTX_LOCK;
@@ -1648,12 +1647,12 @@ void libxl__event_occurred(libxl__egc *egc, libxl_event *event)
* from libxl. This helps avoid reentrancy bugs: parts of
* libxl that call libxl__event_occurred do not have to worry
* that libxl might be reentered at that point. */
LIBXL_TAILQ_INSERT_TAIL(&egc->occurred_for_callback, event, link);
XEN_TAILQ_INSERT_TAIL(&egc->occurred_for_callback, event, link);
return;
} else {
libxl__poller *poller;
LIBXL_TAILQ_INSERT_TAIL(&CTX->occurred, event, link);
LIBXL_LIST_FOREACH(poller, &CTX->pollers_event, entry)
XEN_TAILQ_INSERT_TAIL(&CTX->occurred, event, link);
XEN_LIST_FOREACH(poller, &CTX->pollers_event, entry)
libxl__poller_wakeup(gc, poller);
}
}
@@ -1691,7 +1690,7 @@ static int event_check_internal(libxl__egc *egc, libxl_event **event_r,
libxl_event *ev;
int rc;
LIBXL_TAILQ_FOREACH(ev, &CTX->occurred, link) {
XEN_TAILQ_FOREACH(ev, &CTX->occurred, link) {
if (!(typemask & ((uint64_t)1 << ev->type)))
continue;
@@ -1699,7 +1698,7 @@ static int event_check_internal(libxl__egc *egc, libxl_event **event_r,
continue;
/* got one! */
LIBXL_TAILQ_REMOVE(&CTX->occurred, ev, link);
XEN_TAILQ_REMOVE(&CTX->occurred, ev, link);
*event_r = ev;
rc = 0;
goto out;
@@ -1820,9 +1819,9 @@ libxl__poller *libxl__poller_get(libxl__gc *gc)
/* must be called with ctx locked */
int rc;
libxl__poller *p = LIBXL_LIST_FIRST(&CTX->pollers_idle);
libxl__poller *p = XEN_LIST_FIRST(&CTX->pollers_idle);
if (p) {
LIBXL_LIST_REMOVE(p, entry);
XEN_LIST_REMOVE(p, entry);
} else {
p = libxl__zalloc(NOGC, sizeof(*p));
@@ -1833,16 +1832,15 @@ libxl__poller *libxl__poller_get(libxl__gc *gc)
}
}
LIBXL_LIST_INSERT_HEAD(&CTX->pollers_active, p,
active_entry);
XEN_LIST_INSERT_HEAD(&CTX->pollers_active, p, active_entry);
return p;
}
void libxl__poller_put(libxl_ctx *ctx, libxl__poller *p)
{
if (!p) return;
LIBXL_LIST_REMOVE(p, active_entry);
LIBXL_LIST_INSERT_HEAD(&ctx->pollers_idle, p, entry);
XEN_LIST_REMOVE(p, active_entry);
XEN_LIST_INSERT_HEAD(&ctx->pollers_idle, p, entry);
}
void libxl__poller_wakeup(libxl__gc *gc, libxl__poller *p)
@@ -2048,7 +2046,7 @@ void libxl__ao_create_fail(libxl__ao *ao)
assert(!ao->complete);
assert(!ao->progress_reports_outstanding);
assert(!ao->aborting);
LIBXL_LIST_REMOVE(ao, inprogress_entry);
XEN_LIST_REMOVE(ao, inprogress_entry);
libxl__ao__destroy(CTX, ao);
}
@@ -2070,7 +2068,7 @@ void libxl__ao_complete(libxl__egc *egc, libxl__ao *ao, int rc)
assert(!ao->nested_progeny);
ao->complete = 1;
ao->rc = rc;
LIBXL_LIST_REMOVE(ao, inprogress_entry);
XEN_LIST_REMOVE(ao, inprogress_entry);
if (ao->outstanding_killed_child)
LOG(DEBUG, "ao %p: .. but waiting for %d fork to exit",
ao, ao->outstanding_killed_child);
@@ -2107,7 +2105,7 @@ void libxl__ao_complete_check_progress_reports(libxl__egc *egc, libxl__ao *ao)
libxl__poller_wakeup(gc, ao->poller);
} else if (ao->how.callback) {
LOG(DEBUG, "ao %p: complete for callback", ao);
LIBXL_TAILQ_INSERT_TAIL(&egc->aos_for_callback, ao, entry_for_callback);
XEN_TAILQ_INSERT_TAIL(&egc->aos_for_callback, ao, entry_for_callback);
} else {
libxl_event *ev;
ev = NEW_EVENT(egc, OPERATION_COMPLETE, ao->domid, ao->how.u.for_event);
@@ -2148,7 +2146,7 @@ libxl__ao *libxl__ao_create(libxl_ctx *ctx, uint32_t domid,
"ao %p: create: how=%p callback=%p poller=%p",
ao, how, ao->how.callback, ao->poller);
LIBXL_LIST_INSERT_HEAD(&ctx->aos_inprogress, ao, inprogress_entry);
XEN_LIST_INSERT_HEAD(&ctx->aos_inprogress, ao, inprogress_entry);
return ao;
@@ -2255,7 +2253,7 @@ static int ao__abort(libxl_ctx *ctx, libxl__ao *parent)
parent->aborting = 1;
if (LIBXL_LIST_EMPTY(&parent->abortables)) {
if (XEN_LIST_EMPTY(&parent->abortables)) {
LIBXL__LOG(ctx, LIBXL__LOG_DEBUG,
"ao %p: abort requested and noted, but no-one interested",
parent);
@@ -2264,13 +2262,13 @@ static int ao__abort(libxl_ctx *ctx, libxl__ao *parent)
}
/* We keep calling abort hooks until there are none left */
while (!LIBXL_LIST_EMPTY(&parent->abortables)) {
while (!XEN_LIST_EMPTY(&parent->abortables)) {
assert(!parent->complete);
libxl__ao_abortable *abrt = LIBXL_LIST_FIRST(&parent->abortables);
libxl__ao_abortable *abrt = XEN_LIST_FIRST(&parent->abortables);
assert(parent == ao_nested_root(abrt->ao));
LIBXL_LIST_REMOVE(abrt, entry);
XEN_LIST_REMOVE(abrt, entry);
abrt->registered = 0;
LIBXL__LOG(ctx, LIBXL__LOG_DEBUG,
@@ -2300,7 +2298,7 @@ int libxl_ao_abort(libxl_ctx *ctx, const libxl_asyncop_how *how)
libxl__ctx_lock(ctx);
int rc;
LIBXL_LIST_FOREACH(search, &ctx->aos_inprogress, inprogress_entry) {
XEN_LIST_FOREACH(search, &ctx->aos_inprogress, inprogress_entry) {
if (how) {
/* looking for ao to be reported by callback or event */
if (search->poller)
@@ -2356,7 +2354,7 @@ int libxl__ao_abortable_register(libxl__ao_abortable *abrt)
}
DBG("ao=%p, abrt=%p: registering (root=%p)", ao, abrt, root);
LIBXL_LIST_INSERT_HEAD(&root->abortables, abrt, entry);
XEN_LIST_INSERT_HEAD(&root->abortables, abrt, entry);
abrt->registered = 1;
return 0;
@@ -2372,7 +2370,7 @@ _hidden void libxl__ao_abortable_deregister(libxl__ao_abortable *abrt)
AO_GC;
DBG("ao=%p, abrt=%p: deregistering (root=%p)", ao, abrt, root);
LIBXL_LIST_REMOVE(abrt, entry);
XEN_LIST_REMOVE(abrt, entry);
abrt->registered = 0;
}
@@ -2408,7 +2406,7 @@ void libxl__ao_progress_report(libxl__egc *egc, libxl__ao *ao,
aop->ao = ao;
aop->ev = ev;
aop->how = how;
LIBXL_TAILQ_INSERT_TAIL(&egc->aops_for_callback, aop, entry);
XEN_TAILQ_INSERT_TAIL(&egc->aops_for_callback, aop, entry);
LOG(DEBUG,"ao %p: progress report: callback queued aop=%p",ao,aop);
} else {
LOG(DEBUG,"ao %p: progress report: event queued ev=%p type=%s",
tools/libs/light/libxl_fork.c
+22 -22
View File
@@ -37,14 +37,14 @@
*/
struct libxl__carefd {
LIBXL_LIST_ENTRY(libxl__carefd) entry;
XEN_LIST_ENTRY(libxl__carefd) entry;
int fd;
};
static pthread_mutex_t no_forking = PTHREAD_MUTEX_INITIALIZER;
static int atfork_registered;
static LIBXL_LIST_HEAD(, libxl__carefd) carefds =
LIBXL_LIST_HEAD_INITIALIZER(carefds);
static XEN_LIST_HEAD(, libxl__carefd) carefds =
XEN_LIST_HEAD_INITIALIZER(carefds);
/* Protected against concurrency by no_forking. sigchld_users is
* protected against being interrupted by SIGCHLD (and thus read
@@ -52,8 +52,8 @@ static LIBXL_LIST_HEAD(, libxl__carefd) carefds =
* below). */
static bool sigchld_installed; /* 0 means not */
static pthread_mutex_t sigchld_defer_mutex = PTHREAD_MUTEX_INITIALIZER;
static LIBXL_LIST_HEAD(, libxl_ctx) sigchld_users =
LIBXL_LIST_HEAD_INITIALIZER(sigchld_users);
static XEN_LIST_HEAD(, libxl_ctx) sigchld_users =
XEN_LIST_HEAD_INITIALIZER(sigchld_users);
static struct sigaction sigchld_saved_action;
static void sigchld_removehandler_core(void); /* idempotent */
@@ -105,7 +105,7 @@ libxl__carefd *libxl__carefd_record(libxl_ctx *ctx, int fd)
libxl_fd_set_cloexec(ctx, fd, 1);
cf = libxl__zalloc(&ctx->nogc_gc, sizeof(*cf));
cf->fd = fd;
LIBXL_LIST_INSERT_HEAD(&carefds, cf, entry);
XEN_LIST_INSERT_HEAD(&carefds, cf, entry);
return cf;
}
@@ -141,7 +141,7 @@ void libxl_postfork_child_noexec(libxl_ctx *ctx)
atfork_lock();
LIBXL_LIST_FOREACH_SAFE(cf, &carefds, entry, cf_tmp) {
XEN_LIST_FOREACH_SAFE(cf, &carefds, entry, cf_tmp) {
if (cf->fd >= 0) {
r = close(cf->fd);
if (r)
@@ -151,7 +151,7 @@ void libxl_postfork_child_noexec(libxl_ctx *ctx)
}
free(cf);
}
LIBXL_LIST_INIT(&carefds);
XEN_LIST_INIT(&carefds);
if (sigchld_installed) {
/* We are in theory not at risk of concurrent execution of the
@@ -172,7 +172,7 @@ void libxl_postfork_child_noexec(libxl_ctx *ctx)
* use SIGCHLD, but instead just waits for the child(ren). */
defer_sigchld();
LIBXL_LIST_INIT(&sigchld_users);
XEN_LIST_INIT(&sigchld_users);
/* After this the ->sigchld_user_registered entries in the
* now-obsolete contexts may be lies. But that's OK because
* no-one will look at them. */
@@ -190,7 +190,7 @@ int libxl__carefd_close(libxl__carefd *cf)
atfork_lock();
int r = cf->fd < 0 ? 0 : close(cf->fd);
int esave = errno;
LIBXL_LIST_REMOVE(cf, entry);
XEN_LIST_REMOVE(cf, entry);
atfork_unlock();
free(cf);
errno = esave;
@@ -238,7 +238,7 @@ static void sigchld_handler(int signo)
int r = pthread_mutex_lock(&sigchld_defer_mutex);
assert(!r);
LIBXL_LIST_FOREACH(notify, &sigchld_users, sigchld_users_entry) {
XEN_LIST_FOREACH(notify, &sigchld_users, sigchld_users_entry) {
int e = libxl__self_pipe_wakeup(notify->sigchld_selfpipe[1]);
if (e) abort(); /* errors are probably EBADF, very bad */
}
@@ -362,11 +362,11 @@ static void sigchld_user_remove(libxl_ctx *ctx) /* idempotent */
atfork_lock();
defer_sigchld();
LIBXL_LIST_REMOVE(ctx, sigchld_users_entry);
XEN_LIST_REMOVE(ctx, sigchld_users_entry);
release_sigchld();
if (LIBXL_LIST_EMPTY(&sigchld_users))
if (XEN_LIST_EMPTY(&sigchld_users))
sigchld_removehandler_core();
atfork_unlock();
@@ -404,7 +404,7 @@ int libxl__sigchld_needed(libxl__gc *gc) /* non-reentrant, idempotent */
defer_sigchld();
LIBXL_LIST_INSERT_HEAD(&sigchld_users, CTX, sigchld_users_entry);
XEN_LIST_INSERT_HEAD(&sigchld_users, CTX, sigchld_users_entry);
release_sigchld();
atfork_unlock();
@@ -421,7 +421,7 @@ static bool chldmode_ours(libxl_ctx *ctx, bool creating)
{
switch (ctx->childproc_hooks->chldowner) {
case libxl_sigchld_owner_libxl:
return creating || !LIBXL_LIST_EMPTY(&ctx->children);
return creating || !XEN_LIST_EMPTY(&ctx->children);
case libxl_sigchld_owner_mainloop:
return 0;
case libxl_sigchld_owner_libxl_always:
@@ -452,7 +452,7 @@ static void childproc_reaped_ours(libxl__egc *egc, libxl__ev_child *ch,
int status)
{
pid_t pid = ch->pid;
LIBXL_LIST_REMOVE(ch, entry);
XEN_LIST_REMOVE(ch, entry);
ch->pid = -1;
ch->callback(egc, ch, pid, status);
}
@@ -462,7 +462,7 @@ static int childproc_reaped(libxl__egc *egc, pid_t pid, int status)
EGC_GC;
libxl__ev_child *ch;
LIBXL_LIST_FOREACH(ch, &CTX->children, entry)
XEN_LIST_FOREACH(ch, &CTX->children, entry)
if (ch->pid == pid)
goto found;
@@ -497,7 +497,7 @@ static void childproc_checkall(libxl__egc *egc)
int status;
pid_t got;
LIBXL_LIST_FOREACH(ch, &CTX->children, entry) {
XEN_LIST_FOREACH(ch, &CTX->children, entry) {
got = checked_waitpid(egc, ch->pid, &status);
if (got)
goto found;
@@ -625,7 +625,7 @@ pid_t libxl__ev_child_fork(libxl__gc *gc, libxl__ev_child *ch,
ch->pid = pid;
ch->callback = death;
LIBXL_LIST_INSERT_HEAD(&CTX->children, ch, entry);
XEN_LIST_INSERT_HEAD(&CTX->children, ch, entry);
rc = pid;
out:
@@ -640,7 +640,7 @@ void libxl_childproc_setmode(libxl_ctx *ctx, const libxl_childproc_hooks *hooks,
GC_INIT(ctx);
CTX_LOCK;
assert(LIBXL_LIST_EMPTY(&CTX->children));
assert(XEN_LIST_EMPTY(&CTX->children));
if (!hooks)
hooks = &libxl__childproc_default_hooks;
@@ -698,10 +698,10 @@ void libxl__ev_child_kill_deregister(libxl__ao *ao, libxl__ev_child *ch,
new_ch->ao = ao;
new_ch->ch.pid = pid;
new_ch->ch.callback = deregistered_child_callback;
LIBXL_LIST_INSERT_HEAD(&CTX->children, &new_ch->ch, entry);
XEN_LIST_INSERT_HEAD(&CTX->children, &new_ch->ch, entry);
ao->outstanding_killed_child++;
LIBXL_LIST_REMOVE(ch, entry);
XEN_LIST_REMOVE(ch, entry);
ch->pid = -1;
int r = kill(pid, sig);
if (r)
tools/libs/light/libxl_internal.h
+43 -43
View File
@@ -245,7 +245,7 @@ struct libxl__ev_fd {
short events;
libxl__ev_fd_callback *func;
/* remainder is private for libxl__ev_fd... */
LIBXL_LIST_ENTRY(libxl__ev_fd) entry;
XEN_LIST_ENTRY(libxl__ev_fd) entry;
libxl__osevent_hook_nexus *nexus;
};
@@ -260,7 +260,7 @@ struct libxl__ao_abortable {
libxl__ao_abortable_callback *callback;
/* remainder is private for abort machinery */
bool registered;
LIBXL_LIST_ENTRY(libxl__ao_abortable) entry;
XEN_LIST_ENTRY(libxl__ao_abortable) entry;
/*
* For nested aos:
* Semantically, abort affects the whole tree of aos,
@@ -296,7 +296,7 @@ struct libxl__ev_time {
libxl__ev_time_callback *func;
/* remainder is private for libxl__ev_time... */
int infinite; /* not registered in list or with app if infinite */
LIBXL_TAILQ_ENTRY(libxl__ev_time) entry;
XEN_TAILQ_ENTRY(libxl__ev_time) entry;
struct timeval abs;
libxl__osevent_hook_nexus *nexus;
libxl__ao_abortable abrt;
@@ -323,7 +323,7 @@ struct libxl__ev_evtchn {
int port;
/* remainder is private for libxl__ev_evtchn_... */
bool waiting;
LIBXL_LIST_ENTRY(libxl__ev_evtchn) entry;
XEN_LIST_ENTRY(libxl__ev_evtchn) entry;
};
/*
@@ -341,7 +341,7 @@ struct libxl__ev_evtchn {
* xswatch pointers when we store and retrieve them.
*/
typedef struct libxl__ev_watch_slot {
LIBXL_SLIST_ENTRY(struct libxl__ev_watch_slot) empty;
XEN_SLIST_ENTRY(struct libxl__ev_watch_slot) empty;
} libxl__ev_watch_slot;
_hidden libxl__ev_xswatch *libxl__watch_slot_contents(libxl__gc *gc,
@@ -357,7 +357,7 @@ struct libxl__ev_child {
pid_t pid; /* -1 means unused ("unregistered", ie Idle) */
libxl__ev_child_callback *callback;
/* remainder is private for libxl__ev_... */
LIBXL_LIST_ENTRY(struct libxl__ev_child) entry;
XEN_LIST_ENTRY(struct libxl__ev_child) entry;
};
/* libxl__ev_immediate
@@ -370,7 +370,7 @@ struct libxl__ev_immediate {
/* filled by user */
void (*callback)(libxl__egc *, libxl__ev_immediate *);
/* private to libxl__ev_immediate */
LIBXL_STAILQ_ENTRY(libxl__ev_immediate) entry;
XEN_STAILQ_ENTRY(libxl__ev_immediate) entry;
};
void libxl__ev_immediate_register(libxl__egc *, libxl__ev_immediate *);
@@ -582,7 +582,7 @@ _hidden void libxl__qmp_param_add_integer(libxl__gc *gc,
struct libxl__evgen_domain_death {
uint32_t domid;
unsigned shutdown_reported:1, death_reported:1;
LIBXL_TAILQ_ENTRY(libxl_evgen_domain_death) entry;
XEN_TAILQ_ENTRY(libxl_evgen_domain_death) entry;
/* on list .death_reported ? CTX->death_list : CTX->death_reported */
libxl_ev_user user;
};
@@ -592,7 +592,7 @@ libxl__evdisable_domain_death(libxl__gc*, libxl_evgen_domain_death*);
struct libxl__evgen_disk_eject {
libxl__ev_xswatch watch;
uint32_t domid;
LIBXL_LIST_ENTRY(libxl_evgen_disk_eject) entry;
XEN_LIST_ENTRY(libxl_evgen_disk_eject) entry;
libxl_ev_user user;
char *vdev, *be_ptr_path;
};
@@ -620,7 +620,7 @@ struct libxl__poller {
* The "poller_app" is never idle, but is sometimes on
* pollers_event.
*/
LIBXL_LIST_ENTRY(libxl__poller) entry;
XEN_LIST_ENTRY(libxl__poller) entry;
struct pollfd *fd_polls;
int fd_polls_allocd;
@@ -653,7 +653,7 @@ struct libxl__poller {
* a promise to also make this check, so the baton will never be
* dropped.
*/
LIBXL_LIST_ENTRY(libxl__poller) active_entry;
XEN_LIST_ENTRY(libxl__poller) active_entry;
bool fds_deregistered;
bool osevents_added;
};
@@ -687,7 +687,7 @@ struct libxl__ctx {
* documented in the libxl public interface.
*/
LIBXL_TAILQ_HEAD(libxl__event_list, libxl_event) occurred;
XEN_TAILQ_HEAD(libxl__event_list, libxl_event) occurred;
int osevent_in_hook;
const libxl_osevent_hooks *osevent_hooks;
@@ -696,40 +696,40 @@ struct libxl__ctx {
* for restrictions on the use of the osevent fields. */
libxl__poller *poller_app; /* libxl_osevent_beforepoll and _afterpoll */
LIBXL_LIST_HEAD(, libxl__poller) pollers_event, pollers_idle;
LIBXL_LIST_HEAD(, libxl__poller) pollers_active;
XEN_LIST_HEAD(, libxl__poller) pollers_event, pollers_idle;
XEN_LIST_HEAD(, libxl__poller) pollers_active;
LIBXL_SLIST_HEAD(libxl__osevent_hook_nexi, libxl__osevent_hook_nexus)
XEN_SLIST_HEAD(libxl__osevent_hook_nexi, libxl__osevent_hook_nexus)
hook_fd_nexi_idle, hook_timeout_nexi_idle;
LIBXL_LIST_HEAD(, libxl__ev_fd) efds;
LIBXL_TAILQ_HEAD(, libxl__ev_time) etimes;
XEN_LIST_HEAD(, libxl__ev_fd) efds;
XEN_TAILQ_HEAD(, libxl__ev_time) etimes;
libxl__ev_watch_slot *watch_slots;
int watch_nslots, nwatches;
LIBXL_SLIST_HEAD(, libxl__ev_watch_slot) watch_freeslots;
XEN_SLIST_HEAD(, libxl__ev_watch_slot) watch_freeslots;
uint32_t watch_counter; /* helps disambiguate slot reuse */
libxl__ev_fd watch_efd;
xenevtchn_handle *xce; /* waiting must be done only with libxl__ev_evtchn* */
LIBXL_LIST_HEAD(, libxl__ev_evtchn) evtchns_waiting;
XEN_LIST_HEAD(, libxl__ev_evtchn) evtchns_waiting;
libxl__ev_fd evtchn_efd;
LIBXL_LIST_HEAD(, libxl__ao) aos_inprogress;
XEN_LIST_HEAD(, libxl__ao) aos_inprogress;
LIBXL_TAILQ_HEAD(libxl__evgen_domain_death_list, libxl_evgen_domain_death)
XEN_TAILQ_HEAD(libxl__evgen_domain_death_list, libxl_evgen_domain_death)
death_list /* sorted by domid */,
death_reported;
libxl__ev_xswatch death_watch;
LIBXL_LIST_HEAD(, libxl_evgen_disk_eject) disk_eject_evgens;
XEN_LIST_HEAD(, libxl_evgen_disk_eject) disk_eject_evgens;
const libxl_childproc_hooks *childproc_hooks;
void *childproc_user;
int sigchld_selfpipe[2]; /* [0]==-1 means handler not installed */
libxl__ev_fd sigchld_selfpipe_efd;
LIBXL_LIST_HEAD(, libxl__ev_child) children;
XEN_LIST_HEAD(, libxl__ev_child) children;
bool sigchld_user_registered;
LIBXL_LIST_ENTRY(libxl_ctx) sigchld_users_entry;
XEN_LIST_ENTRY(libxl_ctx) sigchld_users_entry;
libxl_version_info version_info;
@@ -774,9 +774,9 @@ struct libxl__egc {
* The egc and its gc may be accessed only on the creating thread. */
struct libxl__gc gc;
struct libxl__event_list occurred_for_callback;
LIBXL_TAILQ_HEAD(, libxl__ao) aos_for_callback;
LIBXL_TAILQ_HEAD(, libxl__aop_occurred) aops_for_callback;
LIBXL_STAILQ_HEAD(, libxl__ev_immediate) ev_immediates;
XEN_TAILQ_HEAD(, libxl__ao) aos_for_callback;
XEN_TAILQ_HEAD(, libxl__aop_occurred) aops_for_callback;
XEN_STAILQ_HEAD(, libxl__ev_immediate) ev_immediates;
};
struct libxl__aop_occurred {
@@ -787,7 +787,7 @@ struct libxl__aop_occurred {
* While an aop exists, it corresponds to one refcount in
* ao->progress_reports_outstanding, preventing ao destruction.
*/
LIBXL_TAILQ_ENTRY(libxl__aop_occurred) entry;
XEN_TAILQ_ENTRY(libxl__aop_occurred) entry;
libxl__ao *ao;
libxl_event *ev;
const libxl_asyncprogress_how *how;
@@ -819,13 +819,13 @@ struct libxl__ao {
int nested_progeny;
int progress_reports_outstanding;
int rc;
LIBXL_LIST_HEAD(, libxl__ao_abortable) abortables;
LIBXL_LIST_ENTRY(libxl__ao) inprogress_entry;
XEN_LIST_HEAD(, libxl__ao_abortable) abortables;
XEN_LIST_ENTRY(libxl__ao) inprogress_entry;
libxl__gc gc;
libxl_asyncop_how how;
libxl__poller *poller;
uint32_t domid;
LIBXL_TAILQ_ENTRY(libxl__ao) entry_for_callback;
XEN_TAILQ_ENTRY(libxl__ao) entry_for_callback;
int outstanding_killed_child;
};
@@ -2379,10 +2379,10 @@ bool libxl__stubdomain_is_linux(libxl_domain_build_info *b_info)
#define LIBXL_INIT_EGC(egc,ctx) do{ \
LIBXL_INIT_GC((egc).gc,ctx); \
LIBXL_TAILQ_INIT(&(egc).occurred_for_callback); \
LIBXL_TAILQ_INIT(&(egc).aos_for_callback); \
LIBXL_TAILQ_INIT(&(egc).aops_for_callback); \
LIBXL_STAILQ_INIT(&(egc).ev_immediates); \
XEN_TAILQ_INIT(&(egc).occurred_for_callback); \
XEN_TAILQ_INIT(&(egc).aos_for_callback); \
XEN_TAILQ_INIT(&(egc).aops_for_callback); \
XEN_STAILQ_INIT(&(egc).ev_immediates); \
} while(0)
_hidden void libxl__egc_ao_cleanup_1_baton(libxl__gc *gc);
@@ -3141,7 +3141,7 @@ typedef void libxl__datacopier_callback(libxl__egc *egc,
struct libxl__datacopier_buf {
/* private to datacopier */
LIBXL_TAILQ_ENTRY(libxl__datacopier_buf) entry;
XEN_TAILQ_ENTRY(libxl__datacopier_buf) entry;
int used;
char buf[1000];
};
@@ -3163,7 +3163,7 @@ struct libxl__datacopier_state {
libxl__ao_abortable abrt;
libxl__ev_fd toread, towrite;
ssize_t used;
LIBXL_TAILQ_HEAD(libxl__datacopier_bufs, libxl__datacopier_buf) bufs;
XEN_TAILQ_HEAD(libxl__datacopier_bufs, libxl__datacopier_buf) bufs;
};
_hidden void libxl__datacopier_init(libxl__datacopier_state *dc);
@@ -3443,7 +3443,7 @@ typedef struct libxl__stream_read_state libxl__stream_read_state;
typedef struct libxl__sr_record_buf {
/* private to stream read helper */
LIBXL_STAILQ_ENTRY(struct libxl__sr_record_buf) entry;
XEN_STAILQ_ENTRY(struct libxl__sr_record_buf) entry;
libxl__sr_rec_hdr hdr;
void *body; /* iff hdr.length != 0 */
} libxl__sr_record_buf;
@@ -3473,7 +3473,7 @@ struct libxl__stream_read_state {
/* Main stream-reading data. */
libxl__datacopier_state dc; /* Only used when reading a record */
libxl__sr_hdr hdr;
LIBXL_STAILQ_HEAD(, libxl__sr_record_buf) record_queue; /* NOGC */
XEN_STAILQ_HEAD(, libxl__sr_record_buf) record_queue; /* NOGC */
enum {
SRS_PHASE_NORMAL,
SRS_PHASE_BUFFERING,
@@ -4599,9 +4599,9 @@ static inline int libxl__defbool_is_default(libxl_defbool *db)
#define LIBXL_TAILQ_INSERT_SORTED(head, entry, elm_new, elm_search, \
search_body, new_after_search_p) \
do { \
for ((elm_search) = LIBXL_TAILQ_FIRST((head)); \
for ((elm_search) = XEN_TAILQ_FIRST((head)); \
(elm_search); \
(elm_search) = LIBXL_TAILQ_NEXT((elm_search), entry)) { \
(elm_search) = XEN_TAILQ_NEXT((elm_search), entry)) { \
search_body; \
if (!(new_after_search_p)) \
break; \
@@ -4610,9 +4610,9 @@ static inline int libxl__defbool_is_default(libxl_defbool *db)
* to place elm_new, or NULL meaning we want to put elm_new at \
* the end */ \
if ((elm_search)) \
LIBXL_TAILQ_INSERT_BEFORE((elm_search), (elm_new), entry); \
XEN_TAILQ_INSERT_BEFORE((elm_search), (elm_new), entry); \
else \
LIBXL_TAILQ_INSERT_TAIL((head), (elm_new), entry); \
XEN_TAILQ_INSERT_TAIL((head), (elm_new), entry); \
} while(0)
tools/libs/light/libxl_qmp.c
+9 -10
View File
@@ -63,7 +63,7 @@
#include <yajl/yajl_gen.h>
#include "_libxl_list.h"
#include "_xen_list.h"
#include "libxl_internal.h"
/* #define DEBUG_RECEIVED */
@@ -107,7 +107,7 @@ typedef struct callback_id_pair {
qmp_callback_t callback;
void *opaque;
qmp_request_context *context;
LIBXL_STAILQ_ENTRY(struct callback_id_pair) next;
XEN_STAILQ_ENTRY(struct callback_id_pair) next;
} callback_id_pair;
struct libxl__qmp_handler {
@@ -123,7 +123,7 @@ struct libxl__qmp_handler {
uint32_t domid;
int last_id_used;
LIBXL_STAILQ_HEAD(callback_list, callback_id_pair) callback_list;
XEN_STAILQ_HEAD(callback_list, callback_id_pair) callback_list;
struct {
int major;
int minor;
@@ -189,7 +189,7 @@ static callback_id_pair *qmp_get_callback_from_id(libxl__qmp_handler *qmp,
if (id_object) {
id = libxl__json_object_get_integer(id_object);
LIBXL_STAILQ_FOREACH(pp, &qmp->callback_list, next) {
XEN_STAILQ_FOREACH(pp, &qmp->callback_list, next) {
if (pp->id == id) {
return pp;
}
@@ -217,7 +217,7 @@ static void qmp_handle_error_response(libxl__gc *gc, libxl__qmp_handler *qmp,
/* tell that the id have been processed */
qmp->wait_for_id = 0;
}
LIBXL_STAILQ_REMOVE(&qmp->callback_list, pp, callback_id_pair, next);
XEN_STAILQ_REMOVE(&qmp->callback_list, pp, callback_id_pair, next);
free(pp);
}
@@ -266,8 +266,7 @@ static int qmp_handle_response(libxl__gc *gc, libxl__qmp_handler *qmp,
/* tell that the id have been processed */
qmp->wait_for_id = 0;
}
LIBXL_STAILQ_REMOVE(&qmp->callback_list, pp, callback_id_pair,
next);
XEN_STAILQ_REMOVE(&qmp->callback_list, pp, callback_id_pair, next);
free(pp);
}
return 0;
@@ -325,7 +324,7 @@ static libxl__qmp_handler *qmp_init_handler(libxl__gc *gc, uint32_t domid)
qmp->domid = domid;
qmp->timeout = 5;
LIBXL_STAILQ_INIT(&qmp->callback_list);
XEN_STAILQ_INIT(&qmp->callback_list);
return qmp;
}
@@ -383,7 +382,7 @@ static void qmp_close(libxl__qmp_handler *qmp)
callback_id_pair *tmp = NULL;
close(qmp->qmp_fd);
LIBXL_STAILQ_FOREACH(pp, &qmp->callback_list, next) {
XEN_STAILQ_FOREACH(pp, &qmp->callback_list, next) {
free(tmp);
tmp = pp;
}
@@ -547,7 +546,7 @@ static char *qmp_send_prepare(libxl__gc *gc, libxl__qmp_handler *qmp,
elm->callback = callback;
elm->opaque = opaque;
elm->context = context;
LIBXL_STAILQ_INSERT_TAIL(&qmp->callback_list, elm, next);
XEN_STAILQ_INSERT_TAIL(&qmp->callback_list, elm, next);
LOGD(DEBUG, qmp->domid, "next qmp command: '%s'", buf);
tools/libs/light/libxl_stream_read.c
+10 -10
View File
@@ -214,7 +214,7 @@ void libxl__stream_read_init(libxl__stream_read_state *stream)
stream->sync_teardown = false;
FILLZERO(stream->dc);
FILLZERO(stream->hdr);
LIBXL_STAILQ_INIT(&stream->record_queue);
XEN_STAILQ_INIT(&stream->record_queue);
stream->phase = SRS_PHASE_NORMAL;
stream->recursion_guard = false;
stream->incoming_record = NULL;
@@ -402,7 +402,7 @@ static void stream_continue(libxl__egc *egc,
* processing the record. There should never be two records
* in the queue.
*/
if (LIBXL_STAILQ_EMPTY(&stream->record_queue))
if (XEN_STAILQ_EMPTY(&stream->record_queue))
setup_read_record(egc, stream);
else {
if (process_record(egc, stream))
@@ -412,7 +412,7 @@ static void stream_continue(libxl__egc *egc,
* process_record() had better have consumed the one and
* only record in the queue.
*/
assert(LIBXL_STAILQ_EMPTY(&stream->record_queue));
assert(XEN_STAILQ_EMPTY(&stream->record_queue));
}
break;
@@ -428,7 +428,7 @@ static void stream_continue(libxl__egc *egc,
* the tail to spot the CHECKPOINT_END record, and switch to
* the unbuffering phase.
*/
libxl__sr_record_buf *rec = LIBXL_STAILQ_LAST(
libxl__sr_record_buf *rec = XEN_STAILQ_LAST(
&stream->record_queue, libxl__sr_record_buf, entry);
assert(stream->in_checkpoint);
@@ -537,7 +537,7 @@ static void record_body_done(libxl__egc *egc,
if (rc)
goto err;
LIBXL_STAILQ_INSERT_TAIL(&stream->record_queue, rec, entry);
XEN_STAILQ_INSERT_TAIL(&stream->record_queue, rec, entry);
stream->incoming_record = NULL;
stream_continue(egc, stream);
@@ -567,9 +567,9 @@ static bool process_record(libxl__egc *egc,
int rc = 0;
/* Pop a record from the head of the queue. */
assert(!LIBXL_STAILQ_EMPTY(&stream->record_queue));
rec = LIBXL_STAILQ_FIRST(&stream->record_queue);
LIBXL_STAILQ_REMOVE_HEAD(&stream->record_queue, entry);
assert(!XEN_STAILQ_EMPTY(&stream->record_queue));
rec = XEN_STAILQ_FIRST(&stream->record_queue);
XEN_STAILQ_REMOVE_HEAD(&stream->record_queue, entry);
LOG(DEBUG, "Record: %u, length %u", rec->hdr.type, rec->hdr.length);
@@ -813,9 +813,9 @@ static void stream_done(libxl__egc *egc,
/* The record queue had better be empty if the stream believes
* itself to have been successful. */
assert(LIBXL_STAILQ_EMPTY(&stream->record_queue) || stream->rc);
assert(XEN_STAILQ_EMPTY(&stream->record_queue) || stream->rc);
LIBXL_STAILQ_FOREACH_SAFE(rec, &stream->record_queue, entry, trec)
XEN_STAILQ_FOREACH_SAFE(rec, &stream->record_queue, entry, trec)
free_record(rec);
if (!stream->back_channel) {
Reference in new issue
xen-project/xen
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.

The note is not visible to the blocked user.