HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/libsystemd/sd-event/sd-event.c

181,814 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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);
}