HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/libsystemd/sd-event/sd-event.c
Git blob: 231ed955b540a6e71c82e47bc4d98bc301ac14ac
Lines 5001–5529 of 5,529
r = sd_event_run(e, UINT64_MAX);
if (r < 0)
return r;
}
return e->exit_code;
}
_public_ int sd_event_get_fd(sd_event *e) {
assert_return(e, -EINVAL);
assert_return(e = event_resolve(e), -ENOPKG);
assert_return(!event_origin_changed(e), -ECHILD);
return e->epoll_fd;
}
_public_ int sd_event_get_state(sd_event *e) {
assert_return(e, -EINVAL);
assert_return(e = event_resolve(e), -ENOPKG);
assert_return(!event_origin_changed(e), -ECHILD);
return e->state;
}
_public_ int sd_event_get_exit_code(sd_event *e, int *ret) {
assert_return(e, -EINVAL);
assert_return(e = event_resolve(e), -ENOPKG);
assert_return(!event_origin_changed(e), -ECHILD);
if (!e->exit_requested)
return -ENODATA;
if (ret)
*ret = e->exit_code;
return 0;
}
_public_ int sd_event_exit(sd_event *e, int code) {
assert_return(e, -EINVAL);
assert_return(e = event_resolve(e), -ENOPKG);
assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
assert_return(!event_origin_changed(e), -ECHILD);
e->exit_requested = true;
e->exit_code = code;
return 0;
}
_public_ int sd_event_now(sd_event *e, clockid_t clock, uint64_t *ret) {
assert_return(e, -EINVAL);
assert_return(e = event_resolve(e), -ENOPKG);
assert_return(ret, -EINVAL);
assert_return(!event_origin_changed(e), -ECHILD);
if (!TRIPLE_TIMESTAMP_HAS_CLOCK(clock))
return -EOPNOTSUPP;
if (!triple_timestamp_is_set(&e->timestamp)) {
/* Implicitly fall back to now() if we never ran before and thus have no cached time. */
*ret = now(clock);
return 1;
}
*ret = triple_timestamp_by_clock(&e->timestamp, clock);
return 0;
}
_public_ int sd_event_default(sd_event **ret) {
sd_event *e = NULL;
int r;
if (!ret)
return !!default_event;
if (default_event) {
*ret = sd_event_ref(default_event);
return 0;
}
r = sd_event_new(&e);
if (r < 0)
return r;
e->default_event_ptr = &default_event;
e->tid = gettid();
default_event = e;
*ret = e;
return 1;
}
_public_ int sd_event_get_tid(sd_event *e, pid_t *ret) {
assert_return(e, -EINVAL);
assert_return(e = event_resolve(e), -ENOPKG);
assert_return(ret, -EINVAL);
assert_return(!event_origin_changed(e), -ECHILD);
if (e->tid == 0)
return -ENXIO;
*ret = e->tid;
return 0;
}
_public_ int sd_event_set_watchdog(sd_event *e, int b) {
int r;
assert_return(e, -EINVAL);
assert_return(e = event_resolve(e), -ENOPKG);
assert_return(!event_origin_changed(e), -ECHILD);
if (e->watchdog == !!b)
return e->watchdog;
if (b) {
r = sd_watchdog_enabled(false, &e->watchdog_period);
if (r <= 0)
return r;
/* Issue first ping immediately */
sd_notify(false, "WATCHDOG=1");
e->watchdog_last = now(CLOCK_MONOTONIC);
e->watchdog_fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
if (e->watchdog_fd < 0)
return -errno;
r = arm_watchdog(e);
if (r < 0)
goto fail;
struct epoll_event ev = {
.events = EPOLLIN,
.data.ptr = INT_TO_PTR(SOURCE_WATCHDOG),
};
if (epoll_ctl(e->epoll_fd, EPOLL_CTL_ADD, e->watchdog_fd, &ev) < 0) {
r = -errno;
goto fail;
}
} else {
if (e->watchdog_fd >= 0) {
(void) epoll_ctl(e->epoll_fd, EPOLL_CTL_DEL, e->watchdog_fd, NULL);
e->watchdog_fd = safe_close(e->watchdog_fd);
}
}
e->watchdog = b;
return e->watchdog;
fail:
e->watchdog_fd = safe_close(e->watchdog_fd);
return r;
}
_public_ int sd_event_get_watchdog(sd_event *e) {
assert_return(e, -EINVAL);
assert_return(e = event_resolve(e), -ENOPKG);
assert_return(!event_origin_changed(e), -ECHILD);
return e->watchdog;
}
_public_ int sd_event_get_iteration(sd_event *e, uint64_t *ret) {
assert_return(e, -EINVAL);
assert_return(e = event_resolve(e), -ENOPKG);
assert_return(ret, -EINVAL);
assert_return(!event_origin_changed(e), -ECHILD);
*ret = e->iteration;
return 0;
}
_public_ int sd_event_source_set_destroy_callback(sd_event_source *s, sd_event_destroy_t callback) {
assert_return(s, -EINVAL);
assert_return(s->event, -EINVAL);
assert_return(!event_origin_changed(s->event), -ECHILD);
s->destroy_callback = callback;
return 0;
}
_public_ int sd_event_source_get_destroy_callback(sd_event_source *s, sd_event_destroy_t *ret) {
assert_return(s, -EINVAL);
assert_return(!event_origin_changed(s->event), -ECHILD);
if (ret)
*ret = s->destroy_callback;
return !!s->destroy_callback;
}
_public_ int sd_event_source_get_floating(sd_event_source *s) {
assert_return(s, -EINVAL);
assert_return(!event_origin_changed(s->event), -ECHILD);
return s->floating;
}
_public_ int sd_event_source_set_floating(sd_event_source *s, int b) {
assert_return(s, -EINVAL);
assert_return(!event_origin_changed(s->event), -ECHILD);
if (s->floating == !!b)
return 0;
if (!s->event) /* Already disconnected */
return -ESTALE;
s->floating = b;
if (b) {
sd_event_source_ref(s);
sd_event_unref(s->event);
} else {
sd_event_ref(s->event);
sd_event_source_unref(s);
}
return 1;
}
_public_ int sd_event_source_get_exit_on_failure(sd_event_source *s) {
assert_return(s, -EINVAL);
assert_return(s->type != SOURCE_EXIT, -EDOM);
assert_return(!event_origin_changed(s->event), -ECHILD);
return s->exit_on_failure;
}
_public_ int sd_event_source_set_exit_on_failure(sd_event_source *s, int b) {
assert_return(s, -EINVAL);
assert_return(s->type != SOURCE_EXIT, -EDOM);
assert_return(!event_origin_changed(s->event), -ECHILD);
if (s->exit_on_failure == !!b)
return 0;
s->exit_on_failure = b;
return 1;
}
_public_ int sd_event_source_set_ratelimit(sd_event_source *s, uint64_t interval, unsigned burst) {
int r;
assert_return(s, -EINVAL);
assert_return(!event_origin_changed(s->event), -ECHILD);
/* Turning on ratelimiting on event source types that don't support it, is a loggable offense. Doing
* so is a programming error. */
assert_return(EVENT_SOURCE_CAN_RATE_LIMIT(s->type), -EDOM);
/* When ratelimiting is configured we'll always reset the rate limit state first and start fresh,
* non-ratelimited. */
r = event_source_leave_ratelimit(s, /* run_callback= */ false);
if (r < 0)
return r;
s->rate_limit = (RateLimit) { interval, burst };
return 0;
}
_public_ int sd_event_source_set_ratelimit_expire_callback(sd_event_source *s, sd_event_handler_t callback) {
assert_return(s, -EINVAL);
assert_return(!event_origin_changed(s->event), -ECHILD);
s->ratelimit_expire_callback = callback;
return 0;
}
_public_ int sd_event_source_get_ratelimit(sd_event_source *s, uint64_t *ret_interval, unsigned *ret_burst) {
assert_return(s, -EINVAL);
assert_return(!event_origin_changed(s->event), -ECHILD);
/* Querying whether an event source has ratelimiting configured is not a loggable offense, hence
* don't use assert_return(). Unlike turning on ratelimiting it's not really a programming error. */
if (!EVENT_SOURCE_CAN_RATE_LIMIT(s->type))
return -EDOM;
if (!ratelimit_configured(&s->rate_limit))
return -ENOEXEC;
if (ret_interval)
*ret_interval = s->rate_limit.interval;
if (ret_burst)
*ret_burst = s->rate_limit.burst;
return 0;
}
_public_ int sd_event_source_is_ratelimited(sd_event_source *s) {
assert_return(s, -EINVAL);
assert_return(!event_origin_changed(s->event), -ECHILD);
if (!EVENT_SOURCE_CAN_RATE_LIMIT(s->type))
return false;
if (!ratelimit_configured(&s->rate_limit))
return false;
return s->ratelimited;
}
_public_ int sd_event_source_leave_ratelimit(sd_event_source *s) {
int r;
assert_return(s, -EINVAL);
if (!EVENT_SOURCE_CAN_RATE_LIMIT(s->type))
return 0;
if (!ratelimit_configured(&s->rate_limit))
return 0;
if (!s->ratelimited)
return 0;
r = event_source_leave_ratelimit(s, /* run_callback= */ false);
if (r < 0)
return r;
return 1; /* tell caller that we indeed just left the ratelimit state */
}
_public_ int sd_event_set_signal_exit(sd_event *e, int b) {
bool change = false;
int r;
assert_return(e, -EINVAL);
assert_return(e = event_resolve(e), -ENOPKG);
assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
assert_return(!event_origin_changed(e), -ECHILD);
if (b) {
/* We want to maintain pointers to these event sources, so that we can destroy them when told
* so. But we also don't want them to pin the event loop itself. Hence we mark them as
* floating after creation (and undo this before deleting them again). */
if (!e->sigint_event_source) {
r = sd_event_add_signal(e, &e->sigint_event_source, SIGINT | SD_EVENT_SIGNAL_PROCMASK, NULL, NULL);
if (r < 0)
return r;
assert_se(sd_event_source_set_floating(e->sigint_event_source, true) >= 0);
change = true;
}
if (!e->sigterm_event_source) {
r = sd_event_add_signal(e, &e->sigterm_event_source, SIGTERM | SD_EVENT_SIGNAL_PROCMASK, NULL, NULL);
if (r < 0) {
if (change) {
assert_se(sd_event_source_set_floating(e->sigint_event_source, false) >= 0);
e->sigint_event_source = sd_event_source_unref(e->sigint_event_source);
}
return r;
}
assert_se(sd_event_source_set_floating(e->sigterm_event_source, true) >= 0);
change = true;
}
} else {
if (e->sigint_event_source) {
assert_se(sd_event_source_set_floating(e->sigint_event_source, false) >= 0);
e->sigint_event_source = sd_event_source_unref(e->sigint_event_source);
change = true;
}
if (e->sigterm_event_source) {
assert_se(sd_event_source_set_floating(e->sigterm_event_source, false) >= 0);
e->sigterm_event_source = sd_event_source_unref(e->sigterm_event_source);
change = true;
}
}
return change;
}
_public_ int sd_event_set_exit_on_idle(sd_event *e, int b) {
assert_return(e, -EINVAL);
assert_return(e = event_resolve(e), -ENOPKG);
assert_return(!event_origin_changed(e), -ECHILD);
return e->exit_on_idle = b;
}
_public_ int sd_event_get_exit_on_idle(sd_event *e) {
assert_return(e, -EINVAL);
assert_return(e = event_resolve(e), -ENOPKG);
assert_return(!event_origin_changed(e), -ECHILD);
return e->exit_on_idle;
}
static int event_source_set_pressure_type(sd_event_source *s, const char *ty) {
_cleanup_free_ char *b = NULL;
_cleanup_free_ void *w = NULL;
assert_return(s, -EINVAL);
assert_return(EVENT_SOURCE_IS_PRESSURE(s), -EDOM);
assert_return(ty, -EINVAL);
assert_return(!event_origin_changed(s->event), -ECHILD);
if (!STR_IN_SET(ty, "some", "full"))
return -EINVAL;
if (s->pressure.locked) /* Refuse adjusting parameters, if caller told us how to watch for events */
return -EBUSY;
char* space = memchr(s->pressure.write_buffer, ' ', s->pressure.write_buffer_size);
if (!space)
return -EINVAL;
size_t l = space - (char*) s->pressure.write_buffer;
b = memdup_suffix0(s->pressure.write_buffer, l);
if (!b)
return -ENOMEM;
if (!STR_IN_SET(b, "some", "full"))
return -EINVAL;
if (streq(b, ty))
return 0;
size_t nl = strlen(ty) + (s->pressure.write_buffer_size - l);
w = new(char, nl);
if (!w)
return -ENOMEM;
memcpy(stpcpy(w, ty), space, (s->pressure.write_buffer_size - l));
free_and_replace(s->pressure.write_buffer, w);
s->pressure.write_buffer_size = nl;
s->pressure.locked = false;
return 1;
}
_public_ int sd_event_source_set_memory_pressure_type(sd_event_source *s, const char *ty) {
assert_return(s, -EINVAL);
assert_return(s->type == SOURCE_MEMORY_PRESSURE, -EDOM);
return event_source_set_pressure_type(s, ty);
}
_public_ int sd_event_source_set_cpu_pressure_type(sd_event_source *s, const char *ty) {
assert_return(s, -EINVAL);
assert_return(s->type == SOURCE_CPU_PRESSURE, -EDOM);
return event_source_set_pressure_type(s, ty);
}
_public_ int sd_event_source_set_io_pressure_type(sd_event_source *s, const char *ty) {
assert_return(s, -EINVAL);
assert_return(s->type == SOURCE_IO_PRESSURE, -EDOM);
return event_source_set_pressure_type(s, ty);
}
static int event_source_set_pressure_period(sd_event_source *s, uint64_t threshold_usec, uint64_t window_usec) {
_cleanup_free_ char *b = NULL;
_cleanup_free_ void *w = NULL;
assert_return(s, -EINVAL);
assert_return(EVENT_SOURCE_IS_PRESSURE(s), -EDOM);
assert_return(!event_origin_changed(s->event), -ECHILD);
if (threshold_usec <= 0 || threshold_usec >= UINT64_MAX)
return -ERANGE;
if (window_usec <= 0 || window_usec >= UINT64_MAX)
return -ERANGE;
if (threshold_usec > window_usec)
return -EINVAL;
if (s->pressure.locked) /* Refuse adjusting parameters, if caller told us how to watch for events */
return -EBUSY;
char* space = memchr(s->pressure.write_buffer, ' ', s->pressure.write_buffer_size);
if (!space)
return -EINVAL;
size_t l = space - (char*) s->pressure.write_buffer;
b = memdup_suffix0(s->pressure.write_buffer, l);
if (!b)
return -ENOMEM;
if (!STR_IN_SET(b, "some", "full"))
return -EINVAL;
if (asprintf((char**) &w,
"%s " USEC_FMT " " USEC_FMT "",
b,
threshold_usec,
window_usec) < 0)
return -EINVAL;
l = strlen(w) + 1;
if (memcmp_nn(s->pressure.write_buffer, s->pressure.write_buffer_size, w, l) == 0)
return 0;
free_and_replace(s->pressure.write_buffer, w);
s->pressure.write_buffer_size = l;
s->pressure.locked = false;
return 1;
}
_public_ int sd_event_source_set_memory_pressure_period(sd_event_source *s, uint64_t threshold_usec, uint64_t window_usec) {
assert_return(s, -EINVAL);
assert_return(s->type == SOURCE_MEMORY_PRESSURE, -EDOM);
return event_source_set_pressure_period(s, threshold_usec, window_usec);
}
_public_ int sd_event_source_set_cpu_pressure_period(sd_event_source *s, uint64_t threshold_usec, uint64_t window_usec) {
assert_return(s, -EINVAL);
assert_return(s->type == SOURCE_CPU_PRESSURE, -EDOM);
return event_source_set_pressure_period(s, threshold_usec, window_usec);
}
_public_ int sd_event_source_set_io_pressure_period(sd_event_source *s, uint64_t threshold_usec, uint64_t window_usec) {
assert_return(s, -EINVAL);
assert_return(s->type == SOURCE_IO_PRESSURE, -EDOM);
return event_source_set_pressure_period(s, threshold_usec, window_usec);
}