}
static int pretty_boot_time(sd_bus *bus, char **_buf) {
- char ts[FORMAT_TIMESPAN_MAX];
BootTimes *t;
static char buf[4096];
size_t size;
size = strpcpyf(&ptr, size, "Startup finished in ");
if (t->firmware_time > 0)
- size = strpcpyf(&ptr, size, "%s (firmware) + ", format_timespan(ts, sizeof(ts), t->firmware_time - t->loader_time, USEC_PER_MSEC));
+ size = strpcpyf(&ptr, size, "%s (firmware) + ", FORMAT_TIMESPAN(t->firmware_time - t->loader_time, USEC_PER_MSEC));
if (t->loader_time > 0)
- size = strpcpyf(&ptr, size, "%s (loader) + ", format_timespan(ts, sizeof(ts), t->loader_time, USEC_PER_MSEC));
+ size = strpcpyf(&ptr, size, "%s (loader) + ", FORMAT_TIMESPAN(t->loader_time, USEC_PER_MSEC));
if (t->kernel_done_time > 0)
- size = strpcpyf(&ptr, size, "%s (kernel) + ", format_timespan(ts, sizeof(ts), t->kernel_done_time, USEC_PER_MSEC));
+ size = strpcpyf(&ptr, size, "%s (kernel) + ", FORMAT_TIMESPAN(t->kernel_done_time, USEC_PER_MSEC));
if (t->initrd_time > 0)
- size = strpcpyf(&ptr, size, "%s (initrd) + ", format_timespan(ts, sizeof(ts), t->userspace_time - t->initrd_time, USEC_PER_MSEC));
+ size = strpcpyf(&ptr, size, "%s (initrd) + ", FORMAT_TIMESPAN(t->userspace_time - t->initrd_time, USEC_PER_MSEC));
- size = strpcpyf(&ptr, size, "%s (userspace) ", format_timespan(ts, sizeof(ts), t->finish_time - t->userspace_time, USEC_PER_MSEC));
+ size = strpcpyf(&ptr, size, "%s (userspace) ", FORMAT_TIMESPAN(t->finish_time - t->userspace_time, USEC_PER_MSEC));
if (t->kernel_done_time > 0)
- strpcpyf(&ptr, size, "= %s ", format_timespan(ts, sizeof(ts), t->firmware_time + t->finish_time, USEC_PER_MSEC));
+ strpcpyf(&ptr, size, "= %s ", FORMAT_TIMESPAN(t->firmware_time + t->finish_time, USEC_PER_MSEC));
if (unit_id && timestamp_is_set(activated_time)) {
usec_t base = t->userspace_time > 0 ? t->userspace_time : t->reverse_offset;
size = strpcpyf(&ptr, size, "\n%s reached after %s in userspace", unit_id,
- format_timespan(ts, sizeof(ts), activated_time - base, USEC_PER_MSEC));
+ FORMAT_TIMESPAN(activated_time - base, USEC_PER_MSEC));
} else if (unit_id && activated_time == 0)
size = strpcpyf(&ptr, size, "\n%s was never reached", unit_id);
else if (unit_id && activated_time == USEC_INFINITY)
}
static int plot_unit_times(UnitTimes *u, double width, int y) {
- char ts[FORMAT_TIMESPAN_MAX];
bool b;
if (!u->name)
b = u->activating * SCALE_X < width / 2;
if (u->time)
svg_text(b, u->activating, y, "%s (%s)",
- u->name, format_timespan(ts, sizeof(ts), u->time, USEC_PER_MSEC));
+ u->name, FORMAT_TIMESPAN(u->time, USEC_PER_MSEC));
else
svg_text(b, u->activating, y, "%s", u->name);
UnitTimes *times,
BootTimes *boot) {
- char ts[FORMAT_TIMESPAN_MAX], ts2[FORMAT_TIMESPAN_MAX];
-
for (unsigned i = level; i != 0; i--)
printf("%s", special_glyph(branches & (1 << (i-1)) ? SPECIAL_GLYPH_TREE_VERTICAL : SPECIAL_GLYPH_TREE_SPACE));
if (times) {
if (times->time > 0)
printf("%s%s @%s +%s%s", ansi_highlight_red(), name,
- format_timespan(ts, sizeof(ts), times->activating - boot->userspace_time, USEC_PER_MSEC),
- format_timespan(ts2, sizeof(ts2), times->time, USEC_PER_MSEC), ansi_normal());
+ FORMAT_TIMESPAN(times->activating - boot->userspace_time, USEC_PER_MSEC),
+ FORMAT_TIMESPAN(times->time, USEC_PER_MSEC), ansi_normal());
else if (times->activated > boot->userspace_time)
- printf("%s @%s", name, format_timespan(ts, sizeof(ts), times->activated - boot->userspace_time, USEC_PER_MSEC));
+ printf("%s @%s", name, FORMAT_TIMESPAN(times->activated - boot->userspace_time, USEC_PER_MSEC));
else
printf("%s", name);
} else
static int list_dependencies(sd_bus *bus, const char *name) {
_cleanup_strv_free_ char **units = NULL;
- char ts[FORMAT_TIMESPAN_MAX];
UnitTimes *times;
int r;
const char *id;
if (times) {
if (times->time)
printf("%s%s +%s%s\n", ansi_highlight_red(), id,
- format_timespan(ts, sizeof(ts), times->time, USEC_PER_MSEC), ansi_normal());
+ FORMAT_TIMESPAN(times->time, USEC_PER_MSEC), ansi_normal());
else if (times->activated > boot->userspace_time)
- printf("%s @%s\n", id, format_timespan(ts, sizeof(ts), times->activated - boot->userspace_time, USEC_PER_MSEC));
+ printf("%s @%s\n", id,
+ FORMAT_TIMESPAN(times->activated - boot->userspace_time, USEC_PER_MSEC));
else
printf("%s\n", id);
}
n = st.st_size - 4;
if (DEBUG_LOGGING) {
- char ts[FORMAT_TIMESPAN_MAX];
- usec_t end;
-
- end = now(CLOCK_MONOTONIC);
+ usec_t end = now(CLOCK_MONOTONIC);
if (end > begin + EFI_RETRY_DELAY)
log_debug("Detected slow EFI variable read access on %s: %s",
- variable, format_timespan(ts, sizeof(ts), end - begin, 1));
+ variable, FORMAT_TIMESPAN(end - begin, 1));
}
/* Note that efivarfs interestingly doesn't require ftruncate() to update an existing EFI variable
* see C11 §6.5.2.5, and
* https://stackoverflow.com/questions/34880638/compound-literal-lifetime-and-if-blocks */
#define FORMAT_TIMESTAMP(t) format_timestamp((char[FORMAT_TIMESTAMP_MAX]){}, FORMAT_TIMESTAMP_MAX, t)
+#define FORMAT_TIMESPAN(t, accuracy) format_timespan((char[FORMAT_TIMESPAN_MAX]){}, FORMAT_TIMESPAN_MAX, t, accuracy)
int parse_timestamp(const char *t, usec_t *usec);
while (!quit) {
usec_t t;
char key;
- char h[FORMAT_TIMESPAN_MAX];
t = now(CLOCK_MONOTONIC);
case '+':
arg_delay = usec_add(arg_delay, arg_delay < USEC_PER_SEC ? USEC_PER_MSEC * 250 : USEC_PER_SEC);
- fprintf(stdout, "\nIncreased delay to %s.", format_timespan(h, sizeof(h), arg_delay, 0));
+ fprintf(stdout, "\nIncreased delay to %s.", FORMAT_TIMESPAN(arg_delay, 0));
fflush(stdout);
sleep(1);
break;
else
arg_delay = usec_sub_unsigned(arg_delay, arg_delay < USEC_PER_MSEC * 1250 ? USEC_PER_MSEC * 250 : USEC_PER_SEC);
- fprintf(stdout, "\nDecreased delay to %s.", format_timespan(h, sizeof(h), arg_delay, 0));
+ fprintf(stdout, "\nDecreased delay to %s.", FORMAT_TIMESPAN(arg_delay, 0));
fflush(stdout);
sleep(1);
break;
}
static void automount_dump(Unit *u, FILE *f, const char *prefix) {
- char time_string[FORMAT_TIMESPAN_MAX];
Automount *a = AUTOMOUNT(u);
assert(a);
prefix, automount_result_to_string(a->result),
prefix, a->where,
prefix, a->directory_mode,
- prefix, format_timespan(time_string, FORMAT_TIMESPAN_MAX, a->timeout_idle_usec, USEC_PER_SEC));
+ prefix, FORMAT_TIMESPAN(a->timeout_idle_usec, USEC_PER_SEC));
}
static void automount_enter_dead(Automount *a, AutomountResult f) {
CGroupSocketBindItem *bi;
IPAddressAccessItem *iaai;
char **path;
- char q[FORMAT_TIMESPAN_MAX];
- char v[FORMAT_TIMESPAN_MAX];
char cda[FORMAT_CGROUP_DIFF_MAX];
char cdb[FORMAT_CGROUP_DIFF_MAX];
prefix, c->startup_cpu_weight,
prefix, c->cpu_shares,
prefix, c->startup_cpu_shares,
- prefix, format_timespan(q, sizeof(q), c->cpu_quota_per_sec_usec, 1),
- prefix, format_timespan(v, sizeof(v), c->cpu_quota_period_usec, 1),
+ prefix, FORMAT_TIMESPAN(c->cpu_quota_per_sec_usec, 1),
+ prefix, FORMAT_TIMESPAN(c->cpu_quota_period_usec, 1),
prefix, strempty(cpuset_cpus),
prefix, strempty(cpuset_mems),
prefix, c->io_weight,
"%sIODeviceLatencyTargetSec: %s %s\n",
prefix,
l->path,
- format_timespan(q, sizeof(q), l->target_usec, 1));
+ FORMAT_TIMESPAN(l->target_usec, 1));
LIST_FOREACH(device_limits, il, c->io_device_limits) {
char buf[FORMAT_BYTES_MAX];
new_period = cgroup_cpu_adjust_period(period, quota, USEC_PER_MSEC, USEC_PER_SEC);
if (new_period != period) {
- char v[FORMAT_TIMESPAN_MAX];
log_unit_full(u, u->warned_clamping_cpu_quota_period ? LOG_DEBUG : LOG_WARNING,
"Clamping CPU interval for cpu.max: period is now %s",
- format_timespan(v, sizeof(v), new_period, 1));
+ FORMAT_TIMESPAN(new_period, 1));
u->warned_clamping_cpu_quota_period = true;
}
unit_invalidate_cgroup(u, CGROUP_MASK_CPU);
if (c->cpu_quota_period_usec == USEC_INFINITY)
unit_write_setting(u, flags, "CPUQuotaPeriodSec", "CPUQuotaPeriodSec=");
- else {
- char v[FORMAT_TIMESPAN_MAX];
+ else
unit_write_settingf(u, flags, "CPUQuotaPeriodSec",
"CPUQuotaPeriodSec=%s",
- format_timespan(v, sizeof(v), c->cpu_quota_period_usec, 1));
- }
+ FORMAT_TIMESPAN(c->cpu_quota_period_usec, 1));
}
return 1;
if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
_cleanup_free_ char *buf = NULL;
_cleanup_fclose_ FILE *f = NULL;
- char ts[FORMAT_TIMESPAN_MAX];
CGroupIODeviceLatency *a;
size_t size = 0;
fputs("IODeviceLatencyTargetSec=\n", f);
LIST_FOREACH(device_latencies, a, c->io_device_latencies)
fprintf(f, "IODeviceLatencyTargetSec=%s %s\n",
- a->path, format_timespan(ts, sizeof(ts), a->target_usec, 1));
+ a->path, FORMAT_TIMESPAN(a->target_usec, 1));
r = fflush_and_check(f);
if (r < 0)
sd_bus_error *error) {
if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
- char ts[FORMAT_TIMESPAN_MAX];
TimerValue *v;
unit_write_settingf(UNIT(t), flags|UNIT_ESCAPE_SPECIFIERS, name,
"%s=%s",
timer_base_to_string(base),
- format_timespan(ts, sizeof ts, usec, USEC_PER_MSEC));
+ FORMAT_TIMESPAN(usec, USEC_PER_MSEC));
v = new(TimerValue, 1);
if (!v)
return r;
if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
- char *n, ts[FORMAT_TIMESPAN_MAX];
-
if (fix_0)
*p = v != 0 ? v: USEC_INFINITY;
else
*p = v;
- n = strndupa(name, strlen(name) - 4);
- unit_write_settingf(u, flags, name, "%sSec=%s", n,
- format_timespan(ts, sizeof(ts), v, USEC_PER_MSEC));
+ char *n = strndupa(name, strlen(name) - 4);
+ unit_write_settingf(u, flags, name, "%sSec=%s", n, FORMAT_TIMESPAN(v, USEC_PER_MSEC));
}
return 1;
}
void exec_context_dump(const ExecContext *c, FILE* f, const char *prefix) {
- char **e, **d, buf_clean[FORMAT_TIMESPAN_MAX];
+ char **e, **d;
int r;
assert(c);
fprintf(f, "%s%s: %s\n", prefix, exec_directory_type_to_string(dt), *d);
}
- fprintf(f,
- "%sTimeoutCleanSec: %s\n",
- prefix, format_timespan(buf_clean, sizeof(buf_clean), c->timeout_clean_usec, USEC_PER_SEC));
+ fprintf(f, "%sTimeoutCleanSec: %s\n", prefix, FORMAT_TIMESPAN(c->timeout_clean_usec, USEC_PER_SEC));
if (c->nice_set)
- fprintf(f,
- "%sNice: %i\n",
- prefix, c->nice);
+ fprintf(f, "%sNice: %i\n", prefix, c->nice);
if (c->oom_score_adjust_set)
- fprintf(f,
- "%sOOMScoreAdjust: %i\n",
- prefix, c->oom_score_adjust);
+ fprintf(f, "%sOOMScoreAdjust: %i\n", prefix, c->oom_score_adjust);
if (c->coredump_filter_set)
- fprintf(f,
- "%sCoredumpFilter: 0x%"PRIx64"\n",
- prefix, c->coredump_filter);
+ fprintf(f, "%sCoredumpFilter: 0x%"PRIx64"\n", prefix, c->coredump_filter);
for (unsigned i = 0; i < RLIM_NLIMITS; i++)
if (c->rlimit[i]) {
fprintf(f, "%sLogLevelMax: %s\n", prefix, strna(t));
}
- if (c->log_ratelimit_interval_usec > 0) {
- char buf_timespan[FORMAT_TIMESPAN_MAX];
-
+ if (c->log_ratelimit_interval_usec > 0)
fprintf(f,
"%sLogRateLimitIntervalSec: %s\n",
- prefix, format_timespan(buf_timespan, sizeof(buf_timespan), c->log_ratelimit_interval_usec, USEC_PER_SEC));
- }
+ prefix, FORMAT_TIMESPAN(c->log_ratelimit_interval_usec, USEC_PER_SEC));
if (c->log_ratelimit_burst > 0)
fprintf(f, "%sLogRateLimitBurst: %u\n", prefix, c->log_ratelimit_burst);
char *switch_root_dir = NULL, *switch_root_init = NULL;
usec_t before_startup, after_startup;
static char systemd[] = "systemd";
- char timespan[FORMAT_TIMESPAN_MAX];
const char *shutdown_verb = NULL, *error_message = NULL;
int r, retval = EXIT_FAILURE;
Manager *m = NULL;
log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
"Loaded units and determined initial transaction in %s.",
- format_timespan(timespan, sizeof(timespan), after_startup - before_startup, 100 * USEC_PER_MSEC));
+ FORMAT_TIMESPAN(after_startup - before_startup, 100 * USEC_PER_MSEC));
if (arg_action == ACTION_TEST) {
manager_test_summary(m);
for (ManagerTimestamp q = 0; q < _MANAGER_TIMESTAMP_MAX; q++) {
const dual_timestamp *t = m->timestamps + q;
- char buf[FORMAT_TIMESPAN_MAX];
if (dual_timestamp_is_set(t))
fprintf(f, "%sTimestamp %s: %s\n",
strempty(prefix),
manager_timestamp_to_string(q),
timestamp_is_set(t->realtime) ? FORMAT_TIMESTAMP(t->realtime) :
- format_timespan(buf, sizeof buf, t->monotonic, 1));
+ FORMAT_TIMESPAN(t->monotonic, 1));
}
manager_dump_units(m, f, prefix);
unsigned counter = 0, print_nr;
char cylon[6 + CYLON_BUFFER_EXTRA + 1];
unsigned cylon_pos;
- char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
uint64_t x;
assert(m);
m->jobs_in_progress_iteration++;
- if (m->n_running_jobs > 1) {
+ if (m->n_running_jobs > 1)
if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
job_of_n = NULL;
- }
- format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
- if (job_get_timeout(j, &x) > 0)
- format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
+ bool have_timeout = job_get_timeout(j, &x) > 0;
/* We want to use enough information for the user to identify previous lines talking about the same
* unit, but keep the message as short as possible. So if 'Starting foo.service' or 'Starting
strempty(job_of_n),
job_type_to_string(j->type),
ident,
- time, limit);
+ FORMAT_TIMESPAN(now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC),
+ have_timeout ? FORMAT_TIMESPAN(x - j->begin_usec, 1*USEC_PER_SEC) : "no limit");
}
static int have_ask_password(void) {
}
static void manager_notify_finished(Manager *m) {
- char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
if (MANAGER_IS_TEST_RUN(m))
return;
if (MANAGER_IS_SYSTEM(m) && detect_container() <= 0) {
- char ts[FORMAT_TIMESPAN_MAX];
char buf[FORMAT_TIMESPAN_MAX + STRLEN(" (firmware) + ") + FORMAT_TIMESPAN_MAX + STRLEN(" (loader) + ")]
= {};
char *p = buf;
total_usec = m->timestamps[MANAGER_TIMESTAMP_FIRMWARE].monotonic + m->timestamps[MANAGER_TIMESTAMP_FINISH].monotonic;
if (firmware_usec > 0)
- size = strpcpyf(&p, size, "%s (firmware) + ", format_timespan(ts, sizeof(ts), firmware_usec, USEC_PER_MSEC));
+ size = strpcpyf(&p, size, "%s (firmware) + ", FORMAT_TIMESPAN(firmware_usec, USEC_PER_MSEC));
if (loader_usec > 0)
- size = strpcpyf(&p, size, "%s (loader) + ", format_timespan(ts, sizeof(ts), loader_usec, USEC_PER_MSEC));
+ size = strpcpyf(&p, size, "%s (loader) + ", FORMAT_TIMESPAN(loader_usec, USEC_PER_MSEC));
if (dual_timestamp_is_set(&m->timestamps[MANAGER_TIMESTAMP_INITRD])) {
"USERSPACE_USEC="USEC_FMT, userspace_usec,
LOG_MESSAGE("Startup finished in %s%s (kernel) + %s (initrd) + %s (userspace) = %s.",
buf,
- format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
- format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
- format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
- format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)));
+ FORMAT_TIMESPAN(kernel_usec, USEC_PER_MSEC),
+ FORMAT_TIMESPAN(initrd_usec, USEC_PER_MSEC),
+ FORMAT_TIMESPAN(userspace_usec, USEC_PER_MSEC),
+ FORMAT_TIMESPAN(total_usec, USEC_PER_MSEC)));
} else {
/* The initrd-less case on bare-metal */
"USERSPACE_USEC="USEC_FMT, userspace_usec,
LOG_MESSAGE("Startup finished in %s%s (kernel) + %s (userspace) = %s.",
buf,
- format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
- format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
- format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)));
+ FORMAT_TIMESPAN(kernel_usec, USEC_PER_MSEC),
+ FORMAT_TIMESPAN(userspace_usec, USEC_PER_MSEC),
+ FORMAT_TIMESPAN(total_usec, USEC_PER_MSEC)));
}
} else {
/* The container and --user case */
"MESSAGE_ID=" SD_MESSAGE_USER_STARTUP_FINISHED_STR,
"USERSPACE_USEC="USEC_FMT, userspace_usec,
LOG_MESSAGE("Startup finished in %s.",
- format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)));
+ FORMAT_TIMESPAN(total_usec, USEC_PER_MSEC)));
}
bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
m->ready_sent ? "STATUS=Startup finished in %s."
: "READY=1\n"
"STATUS=Startup finished in %s.",
- format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
+ FORMAT_TIMESPAN(total_usec, USEC_PER_MSEC));
m->ready_sent = true;
log_taint_string(m);
}
static void mount_dump(Unit *u, FILE *f, const char *prefix) {
- char buf[FORMAT_TIMESPAN_MAX];
Mount *m = MOUNT(u);
MountParameters *p;
prefix, yes_no(m->lazy_unmount),
prefix, yes_no(m->force_unmount),
prefix, yes_no(m->read_write_only),
- prefix, format_timespan(buf, sizeof(buf), m->timeout_usec, USEC_PER_SEC));
+ prefix, FORMAT_TIMESPAN(m->timeout_usec, USEC_PER_SEC));
if (m->control_pid > 0)
fprintf(f,
static void scope_dump(Unit *u, FILE *f, const char *prefix) {
Scope *s = SCOPE(u);
- char buf_runtime[FORMAT_TIMESPAN_MAX];
assert(s);
assert(f);
"%sRuntimeMaxSec: %s\n",
prefix, scope_state_to_string(s->state),
prefix, scope_result_to_string(s->result),
- prefix, format_timespan(buf_runtime, sizeof(buf_runtime), s->runtime_max_usec, USEC_PER_SEC));
+ prefix, FORMAT_TIMESPAN(s->runtime_max_usec, USEC_PER_SEC));
cgroup_context_dump(UNIT(s), f, prefix);
kill_context_dump(&s->kill_context, f, prefix);
r = selinux_init_load_policy(&enforce);
if (r == 0) {
_cleanup_(mac_selinux_freep) char *label = NULL;
- char timespan[FORMAT_TIMESPAN_MAX];
mac_selinux_retest();
after_load = now(CLOCK_MONOTONIC);
log_info("Successfully loaded SELinux policy in %s.",
- format_timespan(timespan, sizeof(timespan), after_load - before_load, 0));
+ FORMAT_TIMESPAN(after_load - before_load, 0));
*loaded_policy = true;
}
static void service_dump(Unit *u, FILE *f, const char *prefix) {
- char buf_restart[FORMAT_TIMESPAN_MAX], buf_start[FORMAT_TIMESPAN_MAX], buf_stop[FORMAT_TIMESPAN_MAX],
- buf_runtime[FORMAT_TIMESPAN_MAX], buf_watchdog[FORMAT_TIMESPAN_MAX], buf_abort[FORMAT_TIMESPAN_MAX];
ServiceExecCommand c;
Service *s = SERVICE(u);
const char *prefix2;
"%sTimeoutStopSec: %s\n"
"%sTimeoutStartFailureMode: %s\n"
"%sTimeoutStopFailureMode: %s\n",
- prefix, format_timespan(buf_restart, sizeof(buf_restart), s->restart_usec, USEC_PER_SEC),
- prefix, format_timespan(buf_start, sizeof(buf_start), s->timeout_start_usec, USEC_PER_SEC),
- prefix, format_timespan(buf_stop, sizeof(buf_stop), s->timeout_stop_usec, USEC_PER_SEC),
+ prefix, FORMAT_TIMESPAN(s->restart_usec, USEC_PER_SEC),
+ prefix, FORMAT_TIMESPAN(s->timeout_start_usec, USEC_PER_SEC),
+ prefix, FORMAT_TIMESPAN(s->timeout_stop_usec, USEC_PER_SEC),
prefix, service_timeout_failure_mode_to_string(s->timeout_start_failure_mode),
prefix, service_timeout_failure_mode_to_string(s->timeout_stop_failure_mode));
if (s->timeout_abort_set)
fprintf(f,
"%sTimeoutAbortSec: %s\n",
- prefix, format_timespan(buf_abort, sizeof(buf_abort), s->timeout_abort_usec, USEC_PER_SEC));
+ prefix, FORMAT_TIMESPAN(s->timeout_abort_usec, USEC_PER_SEC));
fprintf(f,
"%sRuntimeMaxSec: %s\n"
"%sWatchdogSec: %s\n",
- prefix, format_timespan(buf_runtime, sizeof(buf_runtime), s->runtime_max_usec, USEC_PER_SEC),
- prefix, format_timespan(buf_watchdog, sizeof(buf_watchdog), s->watchdog_usec, USEC_PER_SEC));
+ prefix, FORMAT_TIMESPAN(s->runtime_max_usec, USEC_PER_SEC),
+ prefix, FORMAT_TIMESPAN(s->watchdog_usec, USEC_PER_SEC));
kill_context_dump(&s->kill_context, f, prefix);
exec_context_dump(&s->exec_context, f, prefix);
break;
case SERVICE_AUTO_RESTART:
- if (s->restart_usec > 0) {
- char buf_restart[FORMAT_TIMESPAN_MAX];
+ if (s->restart_usec > 0)
log_unit_debug(UNIT(s),
"Service RestartSec=%s expired, scheduling restart.",
- format_timespan(buf_restart, sizeof buf_restart, s->restart_usec, USEC_PER_SEC));
- } else
+ FORMAT_TIMESPAN(s->restart_usec, USEC_PER_SEC));
+ else
log_unit_debug(UNIT(s),
"Service has no hold-off time (RestartSec=0), scheduling restart.");
static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata) {
Service *s = SERVICE(userdata);
- char t[FORMAT_TIMESPAN_MAX];
usec_t watchdog_usec;
assert(s);
if (UNIT(s)->manager->service_watchdogs) {
log_unit_error(UNIT(s), "Watchdog timeout (limit %s)!",
- format_timespan(t, sizeof(t), watchdog_usec, 1));
+ FORMAT_TIMESPAN(watchdog_usec, 1));
service_enter_signal(s, SERVICE_STOP_WATCHDOG, SERVICE_FAILURE_WATCHDOG);
} else
log_unit_warning(UNIT(s), "Watchdog disabled! Ignoring watchdog timeout (limit %s)!",
- format_timespan(t, sizeof(t), watchdog_usec, 1));
+ FORMAT_TIMESPAN(watchdog_usec, 1));
return 0;
}
}
static void socket_dump(Unit *u, FILE *f, const char *prefix) {
- char time_string[FORMAT_TIMESPAN_MAX];
SocketExecCommand c;
Socket *s = SOCKET(u);
SocketPort *p;
if (s->keep_alive_time > 0)
fprintf(f,
"%sKeepAliveTimeSec: %s\n",
- prefix, format_timespan(time_string, FORMAT_TIMESPAN_MAX, s->keep_alive_time, USEC_PER_SEC));
+ prefix, FORMAT_TIMESPAN(s->keep_alive_time, USEC_PER_SEC));
if (s->keep_alive_interval > 0)
fprintf(f,
"%sKeepAliveIntervalSec: %s\n",
- prefix, format_timespan(time_string, FORMAT_TIMESPAN_MAX, s->keep_alive_interval, USEC_PER_SEC));
+ prefix, FORMAT_TIMESPAN(s->keep_alive_interval, USEC_PER_SEC));
if (s->keep_alive_cnt > 0)
fprintf(f,
if (s->defer_accept > 0)
fprintf(f,
"%sDeferAcceptSec: %s\n",
- prefix, format_timespan(time_string, FORMAT_TIMESPAN_MAX, s->defer_accept, USEC_PER_SEC));
+ prefix, FORMAT_TIMESPAN(s->defer_accept, USEC_PER_SEC));
LIST_FOREACH(port, p, s->ports) {
fprintf(f,
"%sTriggerLimitIntervalSec: %s\n"
"%sTriggerLimitBurst: %u\n",
- prefix, format_timespan(time_string, FORMAT_TIMESPAN_MAX, s->trigger_limit.interval, USEC_PER_SEC),
+ prefix, FORMAT_TIMESPAN(s->trigger_limit.interval, USEC_PER_SEC),
prefix, s->trigger_limit.burst);
str = ip_protocol_to_name(s->socket_protocol);
fprintf(f,
"%sTimeoutSec: %s\n",
- prefix, format_timespan(time_string, FORMAT_TIMESPAN_MAX, s->timeout_usec, USEC_PER_SEC));
+ prefix, FORMAT_TIMESPAN(s->timeout_usec, USEC_PER_SEC));
exec_context_dump(&s->exec_context, f, prefix);
kill_context_dump(&s->kill_context, f, prefix);
}
static void swap_dump(Unit *u, FILE *f, const char *prefix) {
- char buf[FORMAT_TIMESPAN_MAX];
Swap *s = SWAP(u);
SwapParameters *p;
fprintf(f,
"%sTimeoutSec: %s\n",
- prefix, format_timespan(buf, sizeof(buf), s->timeout_usec, USEC_PER_SEC));
+ prefix, FORMAT_TIMESPAN(s->timeout_usec, USEC_PER_SEC));
if (s->control_pid > 0)
fprintf(f,
}
static void timer_dump(Unit *u, FILE *f, const char *prefix) {
- char buf[FORMAT_TIMESPAN_MAX];
Timer *t = TIMER(u);
Unit *trigger;
TimerValue *v;
prefix, trigger ? trigger->id : "n/a",
prefix, yes_no(t->persistent),
prefix, yes_no(t->wake_system),
- prefix, format_timespan(buf, sizeof(buf), t->accuracy_usec, 1),
+ prefix, FORMAT_TIMESPAN(t->accuracy_usec, 1),
prefix, yes_no(t->remain_after_elapse),
prefix, yes_no(t->fixed_random_delay),
prefix, yes_no(t->on_clock_change),
prefix,
timer_base_to_string(v->base),
strna(p));
- } else {
- char timespan1[FORMAT_TIMESPAN_MAX];
-
+ } else
fprintf(f,
"%s%s: %s\n",
prefix,
timer_base_to_string(v->base),
- format_timespan(timespan1, sizeof(timespan1), v->value, 0));
- }
+ FORMAT_TIMESPAN(v->value, 0));
}
static void timer_set_state(Timer *t, TimerState state) {
}
static void add_random(Timer *t, usec_t *v) {
- char s[FORMAT_TIMESPAN_MAX];
usec_t add;
assert(t);
else
*v += add;
- log_unit_debug(UNIT(t), "Adding %s random time.", format_timespan(s, sizeof(s), add, 0));
+ log_unit_debug(UNIT(t), "Adding %s random time.", FORMAT_TIMESPAN(add, 0));
}
static void timer_enter_waiting(Timer *t, bool time_change) {
}
if (found_monotonic) {
- char buf[FORMAT_TIMESPAN_MAX];
usec_t left;
add_random(t, &t->next_elapse_monotonic_or_boottime);
left = usec_sub_unsigned(t->next_elapse_monotonic_or_boottime, triple_timestamp_by_clock(&ts, TIMER_MONOTONIC_CLOCK(t)));
- log_unit_debug(UNIT(t), "Monotonic timer elapses in %s.", format_timespan(buf, sizeof(buf), left, 0));
+ log_unit_debug(UNIT(t), "Monotonic timer elapses in %s.", FORMAT_TIMESPAN(left, 0));
if (t->monotonic_event_source) {
r = sd_event_source_set_time(t->monotonic_event_source, t->next_elapse_monotonic_or_boottime);
void unit_dump(Unit *u, FILE *f, const char *prefix) {
char *t, **j;
const char *prefix2;
- char timespan[FORMAT_TIMESPAN_MAX];
Unit *following;
_cleanup_set_free_ Set *following_set = NULL;
CGroupMask m;
fprintf(f, "%s\tSuccess Action Exit Status: %i\n", prefix, u->success_action_exit_status);
if (u->job_timeout != USEC_INFINITY)
- fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
+ fprintf(f, "%s\tJob Timeout: %s\n", prefix, FORMAT_TIMESPAN(u->job_timeout, 0));
if (u->job_timeout_action != EMERGENCY_ACTION_NONE)
fprintf(f, "%s\tJob Timeout Action: %s\n", prefix, emergency_action_to_string(u->job_timeout_action));
(void) unit_get_cpu_usage(u, &nsec);
if (nsec != NSEC_INFINITY) {
- char buf[FORMAT_TIMESPAN_MAX] = "";
-
/* Format the CPU time for inclusion in the structured log message */
if (asprintf(&t, "CPU_USAGE_NSEC=%" PRIu64, nsec) < 0) {
r = log_oom();
iovec[n_iovec++] = IOVEC_MAKE_STRING(t);
/* Format the CPU time for inclusion in the human language message string */
- format_timespan(buf, sizeof(buf), nsec / NSEC_PER_USEC, USEC_PER_MSEC);
- t = strjoin("consumed ", buf, " CPU time");
+ t = strjoin("consumed ", FORMAT_TIMESPAN(nsec / NSEC_PER_USEC, USEC_PER_MSEC), " CPU time");
if (!t) {
r = log_oom();
goto finish;
const char *variable) {
_cleanup_free_ char *timeout = NULL;
- char timespan[FORMAT_TIMESPAN_MAX];
usec_t u;
int r;
return 0;
}
- fprintf(f, "%s=%s\n", variable, format_timespan(timespan, sizeof(timespan), u, 0));
+ fprintf(f, "%s=%s\n", variable, FORMAT_TIMESPAN(u, 0));
return 0;
}
}
if (ret == 0) {
- char buf[FORMAT_TIMESPAN_MAX];
usec_t t, n;
n = now(CLOCK_REALTIME);
t = user_record_ratelimit_next_try(h->record);
if (t != USEC_INFINITY && t > n)
- return sd_bus_error_setf(error, BUS_ERROR_AUTHENTICATION_LIMIT_HIT, "Too many login attempts, please try again in %s!",
- format_timespan(buf, sizeof(buf), t - n, USEC_PER_SEC));
+ return sd_bus_error_setf(error, BUS_ERROR_AUTHENTICATION_LIMIT_HIT,
+ "Too many login attempts, please try again in %s!",
+ FORMAT_TIMESPAN(t - n, USEC_PER_SEC));
return sd_bus_error_set(error, BUS_ERROR_AUTHENTICATION_LIMIT_HIT, "Too many login attempts, please try again later.");
}
usec_t n = now(CLOCK_REALTIME);
if (t > n) {
- char buf[FORMAT_TIMESPAN_MAX];
(void) pam_prompt(handle, PAM_ERROR_MSG, NULL, "Too many logins, try again in %s.",
- format_timespan(buf, sizeof(buf), t - n, USEC_PER_SEC));
+ FORMAT_TIMESPAN(t - n, USEC_PER_SEC));
return PAM_MAXTRIES;
}
if (n > j->last_status_usec + USEC_PER_SEC &&
percent != j->progress_percent &&
dlnow < dltotal) {
- char buf[FORMAT_TIMESPAN_MAX];
if (n - j->start_usec > USEC_PER_SEC && dlnow > 0) {
char y[FORMAT_BYTES_MAX];
log_info("Got %u%% of %s. %s left at %s/s.",
percent,
j->url,
- format_timespan(buf, sizeof(buf), left, USEC_PER_SEC),
+ FORMAT_TIMESPAN(left, USEC_PER_SEC),
format_bytes(y, sizeof(y), (uint64_t) ((double) dlnow / ((double) done / (double) USEC_PER_SEC))));
} else
log_info("Got %u%% of %s.", percent, j->url);
if (hn)
hostname_cleanup(hn);
- char tsb[FORMAT_TIMESPAN_MAX];
fprintf(stderr,
"\nNew keys have been generated for host %s%s" SD_ID128_FORMAT_STR ".\n"
"\n"
SD_ID128_FORMAT_VAL(machine),
ansi_highlight(), ansi_normal(),
p,
- format_timespan(tsb, sizeof(tsb), arg_interval, 0),
+ FORMAT_TIMESPAN(arg_interval, 0),
ansi_highlight(), ansi_normal(),
ansi_highlight_red());
fflush(stderr);
else if (k < 0)
r = log_warning_errno(k, "FAIL: %s (%m)", f->path);
else {
- char a[FORMAT_TIMESTAMP_MAX], b[FORMAT_TIMESTAMP_MAX], c[FORMAT_TIMESPAN_MAX];
+ char a[FORMAT_TIMESTAMP_MAX], b[FORMAT_TIMESTAMP_MAX];
log_info("PASS: %s", f->path);
if (arg_verify_key && JOURNAL_HEADER_SEALED(f->header)) {
log_info("=> Validated from %s to %s, final %s entries not sealed.",
format_timestamp_maybe_utc(a, sizeof(a), first),
format_timestamp_maybe_utc(b, sizeof(b), validated),
- format_timespan(c, sizeof(c), last > validated ? last - validated : 0, 0));
+ FORMAT_TIMESPAN(last > validated ? last - validated : 0, 0));
} else if (last > 0)
log_info("=> No sealing yet, %s of entries not sealed.",
- format_timespan(c, sizeof(c), last - first, 0));
+ FORMAT_TIMESPAN(last - first, 0));
else
log_info("=> No sealing yet, no entries in file.");
}
}
int server_flush_to_var(Server *s, bool require_flag_file) {
- char ts[FORMAT_TIMESPAN_MAX];
sd_journal *j = NULL;
const char *fn;
unsigned n = 0;
server_driver_message(s, 0, NULL,
LOG_MESSAGE("Time spent on flushing to %s is %s for %u entries.",
s->system_storage.path,
- format_timespan(ts, sizeof(ts), usec_sub_unsigned(now(CLOCK_MONOTONIC), start), 0),
+ FORMAT_TIMESPAN(usec_sub_unsigned(now(CLOCK_MONOTONIC), start), 0),
n),
NULL);
static int client_set_lease_timeouts(sd_dhcp_client *client) {
usec_t time_now;
- char time_string[FORMAT_TIMESPAN_MAX];
int r;
assert(client);
return 0;
log_dhcp_client(client, "lease expires in %s",
- format_timespan(time_string, FORMAT_TIMESPAN_MAX, client->expire_time - time_now, USEC_PER_SEC));
+ FORMAT_TIMESPAN(client->expire_time - time_now, USEC_PER_SEC));
/* arm T2 timeout */
r = event_reset_time(client->event, &client->timeout_t2,
return 0;
log_dhcp_client(client, "T2 expires in %s",
- format_timespan(time_string, FORMAT_TIMESPAN_MAX, client->t2_time - time_now, USEC_PER_SEC));
+ FORMAT_TIMESPAN(client->t2_time - time_now, USEC_PER_SEC));
/* arm T1 timeout */
r = event_reset_time(client->event, &client->timeout_t1,
if (client->t1_time > time_now)
log_dhcp_client(client, "T1 expires in %s",
- format_timespan(time_string, FORMAT_TIMESPAN_MAX, client->t1_time - time_now, USEC_PER_SEC));
+ FORMAT_TIMESPAN(client->t1_time - time_now, USEC_PER_SEC));
return 0;
}
static int client_handle_message(sd_dhcp_client *client, DHCPMessage *message, int len) {
DHCP_CLIENT_DONT_DESTROY(client);
- char time_string[FORMAT_TIMESPAN_MAX];
int r, notify_event;
assert(client);
if (r < 0)
goto error;
- log_dhcp_client(client, "REBOOT in %s", format_timespan(time_string, FORMAT_TIMESPAN_MAX,
- client->start_delay, USEC_PER_SEC));
+ log_dhcp_client(client, "REBOOT in %s", FORMAT_TIMESPAN(client->start_delay, USEC_PER_SEC));
client->start_delay = CLAMP(client->start_delay * 2,
RESTART_AFTER_NAK_MIN_USEC, RESTART_AFTER_NAK_MAX_USEC);
usec_t time_now, init_retransmit_time = 0, max_retransmit_time = 0;
usec_t max_retransmit_duration = 0;
uint8_t max_retransmit_count = 0;
- char time_string[FORMAT_TIMESPAN_MAX];
assert(s);
assert(client);
}
log_dhcp6_client(client, "Next retransmission in %s",
- format_timespan(time_string, FORMAT_TIMESPAN_MAX, client->retransmit_time, USEC_PER_SEC));
+ FORMAT_TIMESPAN(client->retransmit_time, USEC_PER_SEC));
r = event_reset_time(client->event, &client->timeout_resend,
clock_boottime_or_monotonic(),
static int client_start(sd_dhcp6_client *client, enum DHCP6State state) {
int r;
usec_t timeout, time_now;
- char time_string[FORMAT_TIMESPAN_MAX];
uint32_t lifetime_t1, lifetime_t2;
assert_return(client, -EINVAL);
timeout = client_timeout_compute_random(lifetime_t1 * USEC_PER_SEC);
- log_dhcp6_client(client, "T1 expires in %s",
- format_timespan(time_string, FORMAT_TIMESPAN_MAX, timeout, USEC_PER_SEC));
+ log_dhcp6_client(client, "T1 expires in %s", FORMAT_TIMESPAN(timeout, USEC_PER_SEC));
r = event_reset_time(client->event, &client->timeout_t1,
clock_boottime_or_monotonic(),
timeout = client_timeout_compute_random(lifetime_t2 * USEC_PER_SEC);
- log_dhcp6_client(client, "T2 expires in %s",
- format_timespan(time_string, FORMAT_TIMESPAN_MAX, timeout, USEC_PER_SEC));
+ log_dhcp6_client(client, "T2 expires in %s", FORMAT_TIMESPAN(timeout, USEC_PER_SEC));
r = event_reset_time(client->event, &client->timeout_t2,
clock_boottime_or_monotonic(),
ipv4acd_set_state(acd, IPV4ACD_STATE_WAITING_PROBE, true);
if (acd->n_conflict >= MAX_CONFLICTS) {
- char ts[FORMAT_TIMESPAN_MAX];
-
log_ipv4acd(acd, "Max conflicts reached, delaying by %s",
- format_timespan(ts, sizeof(ts), RATE_LIMIT_INTERVAL_USEC, 0));
+ FORMAT_TIMESPAN(RATE_LIMIT_INTERVAL_USEC, 0));
r = ipv4acd_set_next_wakeup(acd, RATE_LIMIT_INTERVAL_USEC, PROBE_WAIT_USEC);
} else
r = ipv4acd_set_next_wakeup(acd, 0, PROBE_WAIT_USEC);
}
static int ndisc_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
- char time_string[FORMAT_TIMESPAN_MAX];
sd_ndisc *nd = userdata;
usec_t time_now;
int r;
}
log_ndisc(nd, "Sent Router Solicitation, next solicitation in %s",
- format_timespan(time_string, FORMAT_TIMESPAN_MAX,
- nd->retransmit_time, USEC_PER_SEC));
+ FORMAT_TIMESPAN(nd->retransmit_time, USEC_PER_SEC));
return 0;
usec_t min_timeout = SD_RADV_DEFAULT_MIN_TIMEOUT_USEC;
usec_t max_timeout = SD_RADV_DEFAULT_MAX_TIMEOUT_USEC;
usec_t time_now, timeout;
- char time_string[FORMAT_TIMESPAN_MAX];
assert(s);
assert(ra);
}
timeout = radv_compute_timeout(min_timeout, max_timeout);
-
- log_radv(ra, "Next Router Advertisement in %s",
- format_timespan(time_string, FORMAT_TIMESPAN_MAX,
- timeout, USEC_PER_SEC));
+ log_radv(ra, "Next Router Advertisement in %s", FORMAT_TIMESPAN(timeout, USEC_PER_SEC));
r = event_reset_time(ra->event, &ra->timeout_event_source,
clock_boottime_or_monotonic(),
sd_radv_prefix *cur;
int r;
_cleanup_free_ char *addr_p = NULL;
- char time_string_preferred[FORMAT_TIMESPAN_MAX];
- char time_string_valid[FORMAT_TIMESPAN_MAX];
usec_t time_now, valid, preferred, valid_until, preferred_until;
assert_return(ra, -EINVAL);
log_radv(ra, "Updated prefix %s preferred %s valid %s",
strna(addr_p),
- format_timespan(time_string_preferred, FORMAT_TIMESPAN_MAX,
- preferred, USEC_PER_SEC),
- format_timespan(time_string_valid, FORMAT_TIMESPAN_MAX,
- valid, USEC_PER_SEC));
+ FORMAT_TIMESPAN(preferred, USEC_PER_SEC),
+ FORMAT_TIMESPAN(valid, USEC_PER_SEC));
return 0;
}
}
_public_ int sd_radv_add_route_prefix(sd_radv *ra, sd_radv_route_prefix *p, int dynamic) {
- char time_string_valid[FORMAT_TIMESPAN_MAX];
usec_t time_now, valid, valid_until;
_cleanup_free_ char *pretty = NULL;
sd_radv_route_prefix *cur;
log_radv(ra, "Updated route prefix %s valid %s",
strna(pretty),
- format_timespan(time_string_valid, FORMAT_TIMESPAN_MAX, valid, USEC_PER_SEC));
+ FORMAT_TIMESPAN(valid, USEC_PER_SEC));
return 0;
}
static usec_t last = 0;
sd_ndisc *nd = test_timeout_nd;
usec_t min, max;
- char time_string_min[FORMAT_TIMESPAN_MAX];
- char time_string_nd[FORMAT_TIMESPAN_MAX];
- char time_string_max[FORMAT_TIMESPAN_MAX];
assert_se(nd);
assert_se(nd->event);
NDISC_MAX_ROUTER_SOLICITATION_INTERVAL / 10;
}
- format_timespan(time_string_min, FORMAT_TIMESPAN_MAX,
- min, USEC_PER_MSEC);
- format_timespan(time_string_nd, FORMAT_TIMESPAN_MAX,
- nd->retransmit_time, USEC_PER_MSEC);
- format_timespan(time_string_max, FORMAT_TIMESPAN_MAX,
- max, USEC_PER_MSEC);
-
log_info("backoff timeout interval %2d %s%s <= %s <= %s",
count,
- (last * 2 > NDISC_MAX_ROUTER_SOLICITATION_INTERVAL)? "(max) ": "",
- time_string_min, time_string_nd, time_string_max);
+ last * 2 > NDISC_MAX_ROUTER_SOLICITATION_INTERVAL ? "(max) ": "",
+ FORMAT_TIMESPAN(min, USEC_PER_MSEC),
+ FORMAT_TIMESPAN(nd->retransmit_time, USEC_PER_MSEC),
+ FORMAT_TIMESPAN(max, USEC_PER_MSEC));
assert_se(min <= nd->retransmit_time);
assert_se(max >= nd->retransmit_time);
void journal_file_print_header(JournalFile *f) {
char a[SD_ID128_STRING_MAX], b[SD_ID128_STRING_MAX], c[SD_ID128_STRING_MAX], d[SD_ID128_STRING_MAX];
- char z[FORMAT_TIMESPAN_MAX];
struct stat st;
char bytes[FORMAT_BYTES_MAX];
le64toh(f->header->tail_entry_seqnum), le64toh(f->header->tail_entry_seqnum),
FORMAT_TIMESTAMP_SAFE(le64toh(f->header->head_entry_realtime)), le64toh(f->header->head_entry_realtime),
FORMAT_TIMESTAMP_SAFE(le64toh(f->header->tail_entry_realtime)), le64toh(f->header->tail_entry_realtime),
- format_timespan(z, sizeof(z), le64toh(f->header->tail_entry_monotonic), USEC_PER_MSEC), le64toh(f->header->tail_entry_monotonic),
+ FORMAT_TIMESPAN(le64toh(f->header->tail_entry_monotonic), USEC_PER_MSEC), le64toh(f->header->tail_entry_monotonic),
le64toh(f->header->n_objects),
le64toh(f->header->n_entries));
JournalFile *f;
const char *verification_key = argv[1];
usec_t from = 0, to = 0, total = 0;
- char c[FORMAT_TIMESPAN_MAX];
struct stat st;
uint64_t p;
log_info("=> Validated from %s to %s, %s missing",
FORMAT_TIMESTAMP(from),
FORMAT_TIMESTAMP(to),
- format_timespan(c, sizeof(c), total > to ? total - to : 0, 0));
+ FORMAT_TIMESPAN(total > to ? total - to : 0, 0));
(void) journal_file_close(f);
if (r < 0)
log_warning_errno(r, "Failed to enqueue user stop event source, ignoring: %m");
- if (DEBUG_LOGGING) {
- char s[FORMAT_TIMESPAN_MAX];
-
+ if (DEBUG_LOGGING)
log_debug("Last session of user '%s' logged out, terminating user context in %s.",
u->user_record->user_name,
- format_timespan(s, sizeof(s), user_stop_delay, USEC_PER_MSEC));
- }
+ FORMAT_TIMESPAN(user_stop_delay, USEC_PER_MSEC));
}
static const char* const user_state_table[_USER_STATE_MAX] = {
static void log_address_debug(const Address *address, const char *str, const Link *link) {
_cleanup_free_ char *addr = NULL, *peer = NULL, *flags_str = NULL;
- char valid_buf[FORMAT_TIMESPAN_MAX], preferred_buf[FORMAT_TIMESPAN_MAX];
const char *valid_str = NULL, *preferred_str = NULL;
bool has_peer;
(void) in_addr_to_string(address->family, &address->in_addr_peer, &peer);
if (address->cinfo.ifa_valid != CACHE_INFO_INFINITY_LIFE_TIME)
- valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
- address->cinfo.ifa_valid * USEC_PER_SEC,
- USEC_PER_SEC);
+ valid_str = FORMAT_TIMESPAN(address->cinfo.ifa_valid * USEC_PER_SEC, USEC_PER_SEC);
if (address->cinfo.ifa_prefered != CACHE_INFO_INFINITY_LIFE_TIME)
- preferred_str = format_timespan(preferred_buf, FORMAT_TIMESPAN_MAX,
- address->cinfo.ifa_prefered * USEC_PER_SEC,
- USEC_PER_SEC);
+ preferred_str = FORMAT_TIMESPAN(address->cinfo.ifa_prefered * USEC_PER_SEC, USEC_PER_SEC);
(void) address_flags_to_string_alloc(address->flags, address->family, &flags_str);
}
if (link->network->can_restart_us > 0) {
- char time_string[FORMAT_TIMESPAN_MAX];
uint64_t restart_ms;
if (link->network->can_restart_us == USEC_INFINITY)
else
restart_ms = DIV_ROUND_UP(link->network->can_restart_us, USEC_PER_MSEC);
- format_timespan(time_string, FORMAT_TIMESPAN_MAX, restart_ms * 1000, MSEC_PER_SEC);
-
if (restart_ms > UINT32_MAX)
- return log_link_debug_errno(link, SYNTHETIC_ERRNO(ERANGE), "restart timeout (%s) too big.", time_string);
+ return log_link_debug_errno(link, SYNTHETIC_ERRNO(ERANGE), "restart timeout (%s) too big.",
+ FORMAT_TIMESPAN(restart_ms * 1000, MSEC_PER_SEC));
- log_link_debug(link, "Setting restart = %s", time_string);
+ log_link_debug(link, "Setting restart = %s", FORMAT_TIMESPAN(restart_ms * 1000, MSEC_PER_SEC));
r = sd_netlink_message_append_u32(m, IFLA_CAN_RESTART_MS, restart_ms);
if (r < 0)
return r;
if (m->use_speed_meter && m->speed_meter_interval_usec < SPEED_METER_MINIMUM_TIME_INTERVAL) {
- char buf[FORMAT_TIMESPAN_MAX];
-
log_warning("SpeedMeterIntervalSec= is too small, using %s.",
- format_timespan(buf, sizeof buf, SPEED_METER_MINIMUM_TIME_INTERVAL, USEC_PER_SEC));
+ FORMAT_TIMESPAN(SPEED_METER_MINIMUM_TIME_INTERVAL, USEC_PER_SEC));
m->speed_meter_interval_usec = SPEED_METER_MINIMUM_TIME_INTERVAL;
}
}
static void log_dhcp6_pd_address(Link *link, const Address *address) {
- char valid_buf[FORMAT_TIMESPAN_MAX], preferred_buf[FORMAT_TIMESPAN_MAX];
const char *valid_str = NULL, *preferred_str = NULL;
_cleanup_free_ char *buffer = NULL;
int log_level;
(void) in6_addr_prefix_to_string(&address->in_addr.in6, address->prefixlen, &buffer);
if (address->cinfo.ifa_valid != CACHE_INFO_INFINITY_LIFE_TIME)
- valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
- address->cinfo.ifa_valid * USEC_PER_SEC,
- USEC_PER_SEC);
+ valid_str = FORMAT_TIMESPAN(address->cinfo.ifa_valid * USEC_PER_SEC, USEC_PER_SEC);
if (address->cinfo.ifa_prefered != CACHE_INFO_INFINITY_LIFE_TIME)
- preferred_str = format_timespan(preferred_buf, FORMAT_TIMESPAN_MAX,
- address->cinfo.ifa_prefered * USEC_PER_SEC,
- USEC_PER_SEC);
+ preferred_str = FORMAT_TIMESPAN(address->cinfo.ifa_prefered * USEC_PER_SEC, USEC_PER_SEC);
log_link_full(link, log_level, "DHCPv6-PD address %s (valid %s%s, preferred %s%s)",
strna(buffer),
}
static void log_dhcp6_address(Link *link, const Address *address, char **ret) {
- char valid_buf[FORMAT_TIMESPAN_MAX], preferred_buf[FORMAT_TIMESPAN_MAX];
- const char *valid_str = NULL, *preferred_str = NULL;
_cleanup_free_ char *buffer = NULL;
bool by_ndisc = false;
Address *existing;
assert(address->family == AF_INET6);
(void) in6_addr_prefix_to_string(&address->in_addr.in6, address->prefixlen, &buffer);
- if (address->cinfo.ifa_valid != CACHE_INFO_INFINITY_LIFE_TIME)
- valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
- address->cinfo.ifa_valid * USEC_PER_SEC,
- USEC_PER_SEC);
- if (address->cinfo.ifa_prefered != CACHE_INFO_INFINITY_LIFE_TIME)
- preferred_str = format_timespan(preferred_buf, FORMAT_TIMESPAN_MAX,
- address->cinfo.ifa_prefered * USEC_PER_SEC,
- USEC_PER_SEC);
+
+ const char *valid_str = address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME ? NULL :
+ FORMAT_TIMESPAN(address->cinfo.ifa_valid * USEC_PER_SEC, USEC_PER_SEC);
+ const char *preferred_str = address->cinfo.ifa_prefered == CACHE_INFO_INFINITY_LIFE_TIME ? NULL :
+ FORMAT_TIMESPAN(address->cinfo.ifa_prefered * USEC_PER_SEC, USEC_PER_SEC);
r = address_get(link, address, &existing);
if (r < 0) {
OomdCGroupContext *t;
SET_FOREACH(t, targets) {
_cleanup_free_ char *selected = NULL;
- char ts[FORMAT_TIMESPAN_MAX];
/* Check if there was reclaim activity in the given interval. The concern is the following case:
* Pressure climbed, a lot of high-frequency pages were reclaimed, and we killed the offending
t->path,
LOAD_INT(t->memory_pressure.avg10), LOAD_FRAC(t->memory_pressure.avg10),
LOAD_INT(t->mem_pressure_limit), LOAD_FRAC(t->mem_pressure_limit),
- format_timespan(ts, sizeof ts,
- m->default_mem_pressure_duration_usec,
- USEC_PER_SEC));
+ FORMAT_TIMESPAN(m->default_mem_pressure_duration_usec, USEC_PER_SEC));
r = update_monitored_cgroup_contexts_candidates(
m->monitored_mem_pressure_cgroup_contexts, &m->monitored_mem_pressure_cgroup_contexts_candidates);
selected, t->path,
LOAD_INT(t->memory_pressure.avg10), LOAD_FRAC(t->memory_pressure.avg10),
LOAD_INT(t->mem_pressure_limit), LOAD_FRAC(t->mem_pressure_limit),
- format_timespan(ts, sizeof ts,
- m->default_mem_pressure_duration_usec,
- USEC_PER_SEC));
+ FORMAT_TIMESPAN(m->default_mem_pressure_duration_usec, USEC_PER_SEC));
return 0;
}
}
int manager_get_dump_string(Manager *m, char **ret) {
_cleanup_free_ char *dump = NULL;
_cleanup_fclose_ FILE *f = NULL;
- char buf[FORMAT_TIMESPAN_MAX];
OomdCGroupContext *c;
size_t size;
char *key;
yes_no(m->dry_run),
PERMYRIAD_AS_PERCENT_FORMAT_VAL(m->swap_used_limit_permyriad),
LOAD_INT(m->default_mem_pressure_limit), LOAD_FRAC(m->default_mem_pressure_limit),
- format_timespan(buf, sizeof(buf), m->default_mem_pressure_duration_usec, USEC_PER_SEC));
+ FORMAT_TIMESPAN(m->default_mem_pressure_duration_usec, USEC_PER_SEC));
oomd_dump_system_context(&m->system_context, f, "\t");
fprintf(f, "Swap Monitored CGroups:\n");
}
void oomd_dump_memory_pressure_cgroup_context(const OomdCGroupContext *ctx, FILE *f, const char *prefix) {
- char tbuf[FORMAT_TIMESPAN_MAX], mem_use[FORMAT_BYTES_MAX];
- char mem_min[FORMAT_BYTES_MAX], mem_low[FORMAT_BYTES_MAX];
+ char mem_use[FORMAT_BYTES_MAX], mem_min[FORMAT_BYTES_MAX], mem_low[FORMAT_BYTES_MAX];
assert(ctx);
assert(f);
LOAD_INT(ctx->memory_pressure.avg10), LOAD_FRAC(ctx->memory_pressure.avg10),
LOAD_INT(ctx->memory_pressure.avg60), LOAD_FRAC(ctx->memory_pressure.avg60),
LOAD_INT(ctx->memory_pressure.avg300), LOAD_FRAC(ctx->memory_pressure.avg300),
- format_timespan(tbuf, sizeof(tbuf), ctx->memory_pressure.total, USEC_PER_SEC),
+ FORMAT_TIMESPAN(ctx->memory_pressure.total, USEC_PER_SEC),
strempty(prefix), format_bytes(mem_use, sizeof(mem_use), ctx->current_memory_usage));
if (!empty_or_root(ctx->path))
}
static void print_source(uint64_t flags, usec_t rtt) {
- char rtt_str[FORMAT_TIMESTAMP_MAX];
-
if (!arg_legend)
return;
flags & SD_RESOLVED_MDNS_IPV4 ? " mDNS/IPv4" : "",
flags & SD_RESOLVED_MDNS_IPV6 ? " mDNS/IPv6" : "");
- assert_se(format_timespan(rtt_str, sizeof(rtt_str), rtt, 100));
-
printf(" in %s.%s\n"
"%s-- Data is authenticated: %s; Data was acquired via local or encrypted transport: %s%s\n",
- rtt_str, ansi_normal(),
+ FORMAT_TIMESPAN(rtt, 100),
+ ansi_normal(),
ansi_grey(),
yes_no(flags & SD_RESOLVED_AUTHENTICATED),
yes_no(flags & SD_RESOLVED_CONFIDENTIAL),
if (timestamp_is_set(c.inactive_enter_usec) &&
timestamp_is_set(c.inactive_exit_usec) &&
- c.inactive_enter_usec > c.inactive_exit_usec) {
- char ts[FORMAT_TIMESPAN_MAX];
+ c.inactive_enter_usec > c.inactive_exit_usec)
log_info("Service runtime: %s",
- format_timespan(ts, sizeof ts, c.inactive_enter_usec - c.inactive_exit_usec, USEC_PER_MSEC));
- }
+ FORMAT_TIMESPAN(c.inactive_enter_usec - c.inactive_exit_usec, USEC_PER_MSEC));
- if (c.cpu_usage_nsec != NSEC_INFINITY) {
- char ts[FORMAT_TIMESPAN_MAX];
+ if (c.cpu_usage_nsec != NSEC_INFINITY)
log_info("CPU time consumed: %s",
- format_timespan(ts, sizeof ts, DIV_ROUND_UP(c.cpu_usage_nsec, NSEC_PER_USEC), USEC_PER_MSEC));
- }
+ FORMAT_TIMESPAN(DIV_ROUND_UP(c.cpu_usage_nsec, NSEC_PER_USEC), USEC_PER_MSEC));
if (c.ip_ingress_bytes != UINT64_MAX) {
char bytes[FORMAT_BYTES_MAX];
bus_print_property_value(name, expected_value, flags, FORMAT_TIMESTAMP(u));
- else if (strstr(name, "USec")) {
- char timespan[FORMAT_TIMESPAN_MAX];
+ else if (strstr(name, "USec"))
+ bus_print_property_value(name, expected_value, flags, FORMAT_TIMESPAN(u, 0));
- (void) format_timespan(timespan, sizeof(timespan), u, 0);
- bus_print_property_value(name, expected_value, flags, timespan);
-
- } else if (streq(name, "CoredumpFilter"))
+ else if (streq(name, "CoredumpFilter"))
bus_print_property_valuef(name, expected_value, flags, "0x%"PRIx64, u);
else if (streq(name, "RestrictNamespaces")) {
left = usec_sub_unsigned(deadline, start);
if (DEBUG_LOGGING) {
- char buf[FORMAT_TIMESPAN_MAX];
const char *sn = NULL;
(void) sd_device_get_sysname(device, &sn);
log_device_debug(device,
- "Waiting for device '%s' to initialize for %s.", strna(sn), format_timespan(buf, sizeof(buf), left, 0));
+ "Waiting for device '%s' to initialize for %s.", strna(sn), FORMAT_TIMESPAN(left, 0));
}
if (left != USEC_INFINITY)
r = device_wait_for_initialization(device, subsystem, local_deadline, ret);
if (r >= 0 && DEBUG_LOGGING) {
- char buf[FORMAT_TIMESPAN_MAX];
const char *sn = NULL;
(void) sd_device_get_sysname(device, &sn);
log_device_debug(device,
"Successfully waited for device '%s' to initialize for %s.",
strna(sn),
- format_timespan(buf, sizeof(buf), usec_sub_unsigned(now(CLOCK_MONOTONIC), start), 0));
+ FORMAT_TIMESPAN(usec_sub_unsigned(now(CLOCK_MONOTONIC), start), 0));
}
if (r != -ETIMEDOUT || last_try)
return r;
- if (DEBUG_LOGGING) {
- char buf[FORMAT_TIMESPAN_MAX];
-
+ if (DEBUG_LOGGING)
log_device_debug(device,
"Device didn't initialize within %s, assuming lost event. Retriggering device.",
- format_timespan(buf, sizeof(buf), usec_sub_unsigned(now(CLOCK_MONOTONIC), start), 0));
- }
+ FORMAT_TIMESPAN(usec_sub_unsigned(now(CLOCK_MONOTONIC), start), 0));
r = sd_device_trigger(device, SD_DEVICE_CHANGE);
if (r < 0)
* use the same label for all their files. */
if (loaded_policy) {
usec_t before_relabel, after_relabel;
- char timespan[FORMAT_TIMESPAN_MAX];
const char *i;
int n_extra;
log_info("Relabelled /dev, /dev/shm, /run, /sys/fs/cgroup%s in %s.",
n_extra > 0 ? ", additional files" : "",
- format_timespan(timespan, sizeof(timespan), after_relabel - before_relabel, 0));
+ FORMAT_TIMESPAN(after_relabel - before_relabel, 0));
}
#endif
static int open_label_db(void) {
struct selabel_handle *hnd;
usec_t before_timestamp, after_timestamp;
- char timespan[FORMAT_TIMESPAN_MAX];
# if HAVE_GENERIC_MALLINFO
generic_mallinfo before_mallinfo = generic_mallinfo_get();
generic_mallinfo after_mallinfo = generic_mallinfo_get();
size_t l = LESS_BY((size_t) after_mallinfo.uordblks, (size_t) before_mallinfo.uordblks);
log_debug("Successfully loaded SELinux database in %s, size on heap is %zuK.",
- format_timespan(timespan, sizeof(timespan), after_timestamp - before_timestamp, 0),
+ FORMAT_TIMESPAN(after_timestamp - before_timestamp, 0),
DIV_ROUND_UP(l, 1024));
# else
log_debug("Successfully loaded SELinux database in %s.",
- format_timespan(timespan, sizeof(timespan), after_timestamp - before_timestamp, 0));
+ FORMAT_TIMESPAN(after_timestamp - before_timestamp, 0));
# endif
/* release memory after measurement */
if (!hash)
return log_oom();
- if (DEBUG_LOGGING) {
- char buf[FORMAT_TIMESPAN_MAX];
- log_debug("Completed TPM2 key sealing in %s.", format_timespan(buf, sizeof(buf), now(CLOCK_MONOTONIC) - start, 1));
- }
+ if (DEBUG_LOGGING)
+ log_debug("Completed TPM2 key sealing in %s.", FORMAT_TIMESPAN(now(CLOCK_MONOTONIC) - start, 1));
*ret_secret = TAKE_PTR(secret);
*ret_secret_size = hmac_sensitive.sensitive.data.size;
goto finish;
}
- if (DEBUG_LOGGING) {
- char buf[FORMAT_TIMESPAN_MAX];
- log_debug("Completed TPM2 key unsealing in %s.", format_timespan(buf, sizeof(buf), now(CLOCK_MONOTONIC) - start, 1));
- }
+ if (DEBUG_LOGGING)
+ log_debug("Completed TPM2 key unsealing in %s.", FORMAT_TIMESPAN(now(CLOCK_MONOTONIC) - start, 1));
*ret_secret = TAKE_PTR(secret);
*ret_secret_size = unsealed->size;
printf(" PBKDF Type: %s\n", hr->luks_pbkdf_type);
if (hr->luks_pbkdf_hash_algorithm)
printf(" PBKDF Hash: %s\n", hr->luks_pbkdf_hash_algorithm);
- if (hr->luks_pbkdf_time_cost_usec != UINT64_MAX) {
- char buf[FORMAT_TIMESPAN_MAX];
- printf(" PBKDF Time: %s\n", format_timespan(buf, sizeof(buf), hr->luks_pbkdf_time_cost_usec, 0));
- }
+ if (hr->luks_pbkdf_time_cost_usec != UINT64_MAX)
+ printf(" PBKDF Time: %s\n", FORMAT_TIMESPAN(hr->luks_pbkdf_time_cost_usec, 0));
if (hr->luks_pbkdf_memory_cost != UINT64_MAX) {
char buf[FORMAT_BYTES_MAX];
printf(" PBKDF Bytes: %s\n", format_bytes(buf, sizeof(buf), hr->luks_pbkdf_memory_cost));
if (t <= n)
printf(" Next Try: anytime\n");
- else {
- char buf[FORMAT_TIMESPAN_MAX];
+ else
printf(" Next Try: %sin %s%s\n",
ansi_highlight_red(),
- format_timespan(buf, sizeof(buf), t - n, USEC_PER_SEC),
+ FORMAT_TIMESPAN(t - n, USEC_PER_SEC),
ansi_normal());
- }
}
- if (storage != USER_CLASSIC) {
- char buf[FORMAT_TIMESPAN_MAX];
+ if (storage != USER_CLASSIC)
printf(" Auth. Limit: %" PRIu64 " attempts per %s\n", user_record_ratelimit_burst(hr),
- format_timespan(buf, sizeof(buf), user_record_ratelimit_interval_usec(hr), 0));
- }
+ FORMAT_TIMESPAN(user_record_ratelimit_interval_usec(hr), 0));
if (hr->enforce_password_policy >= 0)
printf(" Passwd Pol.: %s\n", yes_no(hr->enforce_password_policy));
hr->password_change_warn_usec != UINT64_MAX ||
hr->password_change_inactive_usec != UINT64_MAX) {
- char buf[FORMAT_TIMESPAN_MAX];
printf(" Passwd Chg.:");
if (hr->password_change_min_usec != UINT64_MAX) {
- printf(" min %s", format_timespan(buf, sizeof(buf), hr->password_change_min_usec, 0));
+ printf(" min %s", FORMAT_TIMESPAN(hr->password_change_min_usec, 0));
if (hr->password_change_max_usec != UINT64_MAX)
printf(" …");
}
if (hr->password_change_max_usec != UINT64_MAX)
- printf(" max %s", format_timespan(buf, sizeof(buf), hr->password_change_max_usec, 0));
+ printf(" max %s", FORMAT_TIMESPAN(hr->password_change_max_usec, 0));
if (hr->password_change_warn_usec != UINT64_MAX)
- printf("/warn %s", format_timespan(buf, sizeof(buf), hr->password_change_warn_usec, 0));
+ printf("/warn %s", FORMAT_TIMESPAN(hr->password_change_warn_usec, 0));
if (hr->password_change_inactive_usec != UINT64_MAX)
- printf("/inactive %s", format_timespan(buf, sizeof(buf), hr->password_change_inactive_usec, 0));
+ printf("/inactive %s", FORMAT_TIMESPAN(hr->password_change_inactive_usec, 0));
printf("\n");
}
if (hr->signed_locally >= 0)
printf(" Local Sig.: %s\n", yes_no(hr->signed_locally));
- if (hr->stop_delay_usec != UINT64_MAX) {
- char buf[FORMAT_TIMESPAN_MAX];
- printf(" Stop Delay: %s\n", format_timespan(buf, sizeof(buf), hr->stop_delay_usec, 0));
- }
+ if (hr->stop_delay_usec != UINT64_MAX)
+ printf(" Stop Delay: %s\n", FORMAT_TIMESPAN(hr->stop_delay_usec, 0));
if (hr->auto_login >= 0)
printf("Autom. Login: %s\n", yes_no(hr->auto_login));
if (ioctl(watchdog_fd, WDIOC_SETOPTIONS, &flags) < 0)
return log_warning_errno(errno, "Failed to disable hardware watchdog: %m");
} else {
- char buf[FORMAT_TIMESPAN_MAX];
int sec, flags;
usec_t t;
if (ioctl(watchdog_fd, WDIOC_SETTIMEOUT, &sec) < 0)
return log_warning_errno(errno, "Failed to set timeout to %is: %m", sec);
- watchdog_timeout = (usec_t) sec * USEC_PER_SEC;
- log_info("Set hardware watchdog to %s.", format_timespan(buf, sizeof(buf), watchdog_timeout, 0));
+ log_info("Set hardware watchdog to %s.", FORMAT_TIMESPAN(sec * USEC_PER_SEC, 0));
flags = WDIOS_ENABLECARD;
if (ioctl(watchdog_fd, WDIOC_SETOPTIONS, &flags) < 0) {
static int execute_s2h(const SleepConfig *sleep_config) {
_cleanup_close_ int tfd = -1;
- char buf[FORMAT_TIMESPAN_MAX];
struct itimerspec ts = {};
int r;
return log_error_errno(errno, "Error creating timerfd: %m");
log_debug("Set timerfd wake alarm for %s",
- format_timespan(buf, sizeof(buf), sleep_config->hibernate_delay_sec, USEC_PER_SEC));
+ FORMAT_TIMESPAN(sleep_config->hibernate_delay_sec, USEC_PER_SEC));
timespec_store(&ts.it_value, sleep_config->hibernate_delay_sec);
/* If woken up after alarm time, hibernate */
log_debug("Attempting to hibernate after waking from %s timer",
- format_timespan(buf, sizeof(buf), sleep_config->hibernate_delay_sec, USEC_PER_SEC));
+ FORMAT_TIMESPAN(sleep_config->hibernate_delay_sec, USEC_PER_SEC));
r = execute(sleep_config, SLEEP_HIBERNATE, NULL);
if (r < 0) {
printf("\n");
}
- if (i->cpu_usage_nsec != UINT64_MAX) {
- char buf[FORMAT_TIMESPAN_MAX];
- printf(" CPU: %s\n", format_timespan(buf, sizeof(buf), i->cpu_usage_nsec / NSEC_PER_USEC, USEC_PER_MSEC));
- }
+ if (i->cpu_usage_nsec != UINT64_MAX)
+ printf(" CPU: %s\n", FORMAT_TIMESPAN(i->cpu_usage_nsec / NSEC_PER_USEC, USEC_PER_MSEC));
if (i->control_group) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
if (r < 0)
return bus_log_parse_error(r);
- while ((r = sd_bus_message_read(m, "(stt)", &base, &v, &next_elapse)) > 0) {
- char timespan1[FORMAT_TIMESPAN_MAX] = "n/a", timespan2[FORMAT_TIMESPAN_MAX] = "n/a";
-
- (void) format_timespan(timespan1, sizeof timespan1, v, 0);
- (void) format_timespan(timespan2, sizeof timespan2, next_elapse, 0);
-
+ while ((r = sd_bus_message_read(m, "(stt)", &base, &v, &next_elapse)) > 0)
bus_print_property_valuef(name, expected_value, flags,
- "{ %s=%s ; next_elapse=%s }", base, timespan1, timespan2);
- }
+ "{ %s=%s ; next_elapse=%s }",
+ base,
+ strna(FORMAT_TIMESPAN(v, 0)),
+ strna(FORMAT_TIMESPAN(next_elapse, 0)));
if (r < 0)
return bus_log_parse_error(r);
} else if (contents[0] == SD_BUS_TYPE_STRUCT_BEGIN &&
streq(name, "IODeviceLatencyTargetUSec")) {
- char ts[FORMAT_TIMESPAN_MAX];
const char *path;
uint64_t target;
while ((r = sd_bus_message_read(m, "(st)", &path, &target)) > 0)
bus_print_property_valuef(name, expected_value, flags, "%s %s", strna(path),
- format_timespan(ts, sizeof(ts), target, 1));
+ FORMAT_TIMESPAN(target, 1));
if (r < 0)
return bus_log_parse_error(r);
#include "util.h"
static int test_acpi_fpdt(void) {
- char ts_start[FORMAT_TIMESPAN_MAX], ts_exit[FORMAT_TIMESPAN_MAX], ts_span[FORMAT_TIMESPAN_MAX];
usec_t loader_start, loader_exit;
int r;
}
log_info("ACPI FPDT: loader start=%s exit=%s duration=%s",
- format_timespan(ts_start, sizeof(ts_start), loader_start, USEC_PER_MSEC),
- format_timespan(ts_exit, sizeof(ts_exit), loader_exit, USEC_PER_MSEC),
- format_timespan(ts_span, sizeof(ts_span), loader_exit - loader_start, USEC_PER_MSEC));
+ FORMAT_TIMESPAN(loader_start, USEC_PER_MSEC),
+ FORMAT_TIMESPAN(loader_exit, USEC_PER_MSEC),
+ FORMAT_TIMESPAN(loader_exit - loader_start, USEC_PER_MSEC));
return 1;
}
static int test_efi_loader(void) {
- char ts_start[FORMAT_TIMESPAN_MAX], ts_exit[FORMAT_TIMESPAN_MAX], ts_span[FORMAT_TIMESPAN_MAX];
usec_t loader_start, loader_exit;
int r;
}
log_info("EFI Loader: start=%s exit=%s duration=%s",
- format_timespan(ts_start, sizeof(ts_start), loader_start, USEC_PER_MSEC),
- format_timespan(ts_exit, sizeof(ts_exit), loader_exit, USEC_PER_MSEC),
- format_timespan(ts_span, sizeof(ts_span), loader_exit - loader_start, USEC_PER_MSEC));
+ FORMAT_TIMESPAN(loader_start, USEC_PER_MSEC),
+ FORMAT_TIMESPAN(loader_exit, USEC_PER_MSEC),
+ FORMAT_TIMESPAN(loader_exit - loader_start, USEC_PER_MSEC));
return 1;
}
static int test_boot_timestamps(void) {
- char s[FORMAT_TIMESPAN_MAX];
dual_timestamp fw, l, k;
int r;
return ok ? 0 : r;
}
- log_info("Firmware began %s before kernel.", format_timespan(s, sizeof(s), fw.monotonic, 0));
- log_info("Loader began %s before kernel.", format_timespan(s, sizeof(s), l.monotonic, 0));
+ log_info("Firmware began %s before kernel.", FORMAT_TIMESPAN(fw.monotonic, 0));
+ log_info("Loader began %s before kernel.", FORMAT_TIMESPAN(l.monotonic, 0));
log_info("Firmware began %s.", FORMAT_TIMESTAMP(fw.realtime));
log_info("Loader began %s.", FORMAT_TIMESTAMP(l.realtime));
log_info("Kernel began %s.", FORMAT_TIMESTAMP(k.realtime));
for (j = 0; j < ELEMENTSOF(tests); j++) {
usec_t ts = now(CLOCK_MONOTONIC), n;
- char b[FORMAT_TIMESPAN_MAX];
assert_se(h = hashmap_new(tests[j].ops));
hashmap_free(h);
n = now(CLOCK_MONOTONIC);
- log_info("test took %s", format_timespan(b, sizeof b, n - ts, 0));
+ log_info("test took %s", FORMAT_TIMESPAN(n - ts, 0));
}
}
Hashmap *h;
bool slow = slow_tests_enabled();
usec_t ts, n;
- char b[FORMAT_TIMESPAN_MAX];
unsigned n_entries = slow ? 1 << 20 : 240;
const struct {
hashmap_free(h);
n = now(CLOCK_MONOTONIC);
- log_info("%s test took %s", tests[j].title, format_timespan(b, sizeof b, n - ts, 0));
+ log_info("%s test took %s", tests[j].title, FORMAT_TIMESPAN(n - ts, 0));
assert_se(custom_counter == tests[j].expect_counter);
}
#include "tests.h"
int main(int argc, char *argv[]) {
- char buf[CONST_MAX(FORMAT_TIMESPAN_MAX, FORMAT_BYTES_MAX)];
+ char buf[FORMAT_BYTES_MAX];
nsec_t nsec;
uint64_t v;
int r;
log_open();
assert_se(procfs_cpu_get_usage(&nsec) >= 0);
- log_info("Current system CPU time: %s", format_timespan(buf, sizeof(buf), nsec/NSEC_PER_USEC, 1));
+ log_info("Current system CPU time: %s", FORMAT_TIMESPAN(nsec/NSEC_PER_USEC, 1));
assert_se(procfs_memory_get_used(&v) >= 0);
log_info("Current memory usage: %s", format_bytes(buf, sizeof(buf), v));
REENABLE_WARNING;
static int print_ntp_status_info(NTPStatusInfo *i) {
- char ts[FORMAT_TIMESPAN_MAX], jitter[FORMAT_TIMESPAN_MAX],
- tmin[FORMAT_TIMESPAN_MAX], tmax[FORMAT_TIMESPAN_MAX];
usec_t delay, t14, t23, offset, root_distance;
_cleanup_(table_unrefp) Table *table = NULL;
bool offset_sign;
return table_log_add_error(r);
r = table_add_cell_stringf(table, NULL, "%s (min: %s; max %s)",
- format_timespan(ts, sizeof(ts), i->poll_interval, 0),
- format_timespan(tmin, sizeof(tmin), i->poll_min, 0),
- format_timespan(tmax, sizeof(tmax), i->poll_max, 0));
+ FORMAT_TIMESPAN(i->poll_interval, 0),
+ FORMAT_TIMESPAN(i->poll_min, 0),
+ FORMAT_TIMESPAN(i->poll_max, 0));
if (r < 0)
return table_log_add_error(r);
return table_log_add_error(r);
r = table_add_cell_stringf(table, NULL, "%s (%" PRIi32 ")",
- format_timespan(ts, sizeof(ts), DIV_ROUND_UP((nsec_t) (exp2(i->precision) * NSEC_PER_SEC), NSEC_PER_USEC), 0),
+ FORMAT_TIMESPAN(DIV_ROUND_UP((nsec_t) (exp2(i->precision) * NSEC_PER_SEC), NSEC_PER_USEC), 0),
i->precision);
if (r < 0)
return table_log_add_error(r);
return table_log_add_error(r);
r = table_add_cell_stringf(table, NULL, "%s (max: %s)",
- format_timespan(ts, sizeof(ts), root_distance, 0),
- format_timespan(tmax, sizeof(tmax), i->root_distance_max, 0));
+ FORMAT_TIMESPAN(root_distance, 0),
+ FORMAT_TIMESPAN(i->root_distance_max, 0));
if (r < 0)
return table_log_add_error(r);
r = table_add_cell_stringf(table, NULL, "%s%s",
offset_sign ? "+" : "-",
- format_timespan(ts, sizeof(ts), offset, 0));
+ FORMAT_TIMESPAN(offset, 0));
if (r < 0)
return table_log_add_error(r);
r = table_add_many(table,
TABLE_STRING, "Delay:",
- TABLE_STRING, format_timespan(ts, sizeof(ts), delay, 0),
+ TABLE_STRING, FORMAT_TIMESPAN(delay, 0),
TABLE_STRING, "Jitter:",
- TABLE_STRING, format_timespan(jitter, sizeof(jitter), i->jitter, 0),
+ TABLE_STRING, FORMAT_TIMESPAN(i->jitter, 0),
TABLE_STRING, "Packet count:",
TABLE_UINT64, i->packet_count);
if (r < 0)
case SD_BUS_TYPE_STRUCT:
if (streq(name, "NTPMessage")) {
_cleanup_(ntp_status_info_clear) NTPStatusInfo i = {};
- char ts[FORMAT_TIMESPAN_MAX];
r = map_ntp_message(NULL, NULL, m, NULL, &i);
if (r < 0)
printf("{ Leap=%u, Version=%u, Mode=%u, Stratum=%u, Precision=%i,",
i.leap, i.version, i.mode, i.stratum, i.precision);
- printf(" RootDelay=%s,",
- format_timespan(ts, sizeof(ts), i.root_delay, 0));
- printf(" RootDispersion=%s,",
- format_timespan(ts, sizeof(ts), i.root_dispersion, 0));
+ printf(" RootDelay=%s,", FORMAT_TIMESPAN(i.root_delay, 0));
+ printf(" RootDispersion=%s,", FORMAT_TIMESPAN(i.root_dispersion, 0));
if (i.stratum == 1)
printf(" Reference=%s,", i.reference.str);
printf(" DestinationTimestamp=%s,", FORMAT_TIMESTAMP(i.dest));
printf(" Ignored=%s PacketCount=%" PRIu64 ",",
yes_no(i.spike), i.packet_count);
- printf(" Jitter=%s }\n",
- format_timespan(ts, sizeof(ts), i.jitter, 0));
+ printf(" Jitter=%s }\n", FORMAT_TIMESPAN(i.jitter, 0));
return 1;
static int on_spawn_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
Spawn *spawn = userdata;
- char timeout[FORMAT_TIMESPAN_MAX];
assert(spawn);
log_device_error(spawn->device, "Spawned process '%s' ["PID_FMT"] timed out after %s, killing",
spawn->cmd, spawn->pid,
- format_timespan(timeout, sizeof(timeout), spawn->timeout_usec, USEC_PER_SEC));
+ FORMAT_TIMESPAN(spawn->timeout_usec, USEC_PER_SEC));
return 1;
}
static int on_spawn_timeout_warning(sd_event_source *s, uint64_t usec, void *userdata) {
Spawn *spawn = userdata;
- char timeout[FORMAT_TIMESPAN_MAX];
assert(spawn);
log_device_warning(spawn->device, "Spawned process '%s' ["PID_FMT"] is taking longer than %s to complete",
spawn->cmd, spawn->pid,
- format_timespan(timeout, sizeof(timeout), spawn->timeout_warn_usec, USEC_PER_SEC));
+ FORMAT_TIMESPAN(spawn->timeout_warn_usec, USEC_PER_SEC));
return 1;
}
log_device_debug_errno(event->dev, r, "Failed to run built-in command \"%s\", ignoring: %m", command);
} else {
if (event->exec_delay_usec > 0) {
- char buf[FORMAT_TIMESPAN_MAX];
-
log_device_debug(event->dev, "Delaying execution of \"%s\" for %s.",
- command, format_timespan(buf, sizeof(buf), event->exec_delay_usec, USEC_PER_SEC));
+ command, FORMAT_TIMESPAN(event->exec_delay_usec, USEC_PER_SEC));
(void) usleep(event->exec_delay_usec);
}
n = now(CLOCK_MONOTONIC);
if (n >= usec_add(start_time, RUNTIME_MAX_USEC)) {
- char buf[FORMAT_TIMESPAN_MAX];
log_debug("Exiting worker, ran for %s, that's enough.",
- format_timespan(buf, sizeof(buf), usec_sub_unsigned(n, start_time), 0));
+ FORMAT_TIMESPAN(usec_sub_unsigned(n, start_time), 0));
break;
}
if (last_busy_usec == USEC_INFINITY)
last_busy_usec = n;
else if (listen_idle_usec != USEC_INFINITY && n >= usec_add(last_busy_usec, listen_idle_usec)) {
- char buf[FORMAT_TIMESPAN_MAX];
log_debug("Exiting worker, been idle for %s.",
- format_timespan(buf, sizeof(buf), usec_sub_unsigned(n, last_busy_usec), 0));
+ FORMAT_TIMESPAN(usec_sub_unsigned(n, last_busy_usec), 0));
break;
}
projects / thirdparty / systemd.git / commitdiff
