the OS.
@TRIMMED_BYTES@ of memory were returned to the OS, which took @TRIMMED_USEC@
-micro-seconds (µs).
+micro-seconds (μs).
<varlistentry>
<term><varname>systemd.clock-usec=</varname></term>
- <listitem><para>Takes a decimal, numeric timestamp in µs since January 1st 1970, 00:00am, to set the
+ <listitem><para>Takes a decimal, numeric timestamp in μs since January 1st 1970, 00:00am, to set the
system clock to. The system time is set to the specified timestamp early during boot. It is not
propagated to the hardware clock (RTC).</para></listitem>
</varlistentry>
unit and job objects or directly convert a unit name or job identifier to a bus path of the corresponding
D-Bus object.</para>
- <para>Properties exposing time values are usually encoded in microseconds (µs) on the bus, even if
+ <para>Properties exposing time values are usually encoded in microseconds (μs) on the bus, even if
their corresponding settings in the unit files are in seconds.</para>
<para>PID 1 uses <ulink url="https://www.freedesktop.org/software/polkit/docs/latest/">polkit</ulink> to
<constant>POLLIN</constant>, <constant>POLLOUT</constant>, … events, or negative on error.
</para>
- <para><function>sd_bus_get_timeout()</function> returns the <emphasis>absolute</emphasis> time-out in µs,
+ <para><function>sd_bus_get_timeout()</function> returns the <emphasis>absolute</emphasis> time-out in μs,
from which the relative time-out to pass to <function>poll()</function> (or a similar call) can be
derived, when waiting for events on the specified bus connection. The returned timeout may be zero, in
which case a subsequent I/O polling call should be invoked in non-blocking mode. The returned timeout may
indicating that no work is pending on the connection. Internally, this call invokes <citerefentry
project='man-pages'><refentrytitle>ppoll</refentrytitle><manvolnum>2</manvolnum></citerefentry>, to wait for I/O on
the bus connection. If the <parameter>timeout_usec</parameter> parameter is specified, the call will block at most
- for the specified amount of time in µs. Pass <constant>UINT64_MAX</constant> to permit it to sleep
+ for the specified amount of time in μs. Pass <constant>UINT64_MAX</constant> to permit it to sleep
indefinitely.</para>
<para>After each invocation of <function>sd_bus_wait()</function> the <function>sd_bus_process()</function> call
<constant>CLOCK_REALTIME_ALARM</constant>, or <constant>CLOCK_BOOTTIME_ALARM</constant>. See
<citerefentry><refentrytitle>timerfd_create</refentrytitle><manvolnum>2</manvolnum></citerefentry> for details
regarding the various types of clocks. The <parameter>usec</parameter> parameter specifies the earliest time, in
- microseconds (µs), relative to the clock's epoch, when the timer shall be triggered. If a time already in the past
+ microseconds (μs), relative to the clock's epoch, when the timer shall be triggered. If a time already in the past
is specified (including <constant>0</constant>), this timer source "fires" immediately and is ready to be
dispatched. If the parameter is specified as <constant>UINT64_MAX</constant> the timer event will never elapse,
which may be used as an alternative to explicitly disabling a timer event source with
<citerefentry><refentrytitle>sd_event_source_set_enabled</refentrytitle><manvolnum>3</manvolnum></citerefentry>. The
- <parameter>accuracy</parameter> parameter specifies an additional accuracy value in µs specifying how much the
- timer event may be delayed. Use <constant>0</constant> to select the default accuracy (250ms). Use 1µs for maximum
- accuracy. Consider specifying 60000000µs (1min) or larger for long-running events that may be delayed
+ <parameter>accuracy</parameter> parameter specifies an additional accuracy value in μs specifying how much the
+ timer event may be delayed. Use <constant>0</constant> to select the default accuracy (250ms). Use 1μs for maximum
+ accuracy. Consider specifying 60000000μs (1min) or larger for long-running events that may be delayed
substantially. Picking higher accuracy values allows the system to coalesce timer events more aggressively,
improving power efficiency.</para>
<para><function>sd_event_source_get_time()</function> retrieves the configured time value of an event
source created previously with <function>sd_event_add_time()</function> or
<function>sd_event_add_time_relative()</function>. It takes the event source object and a pointer to a
- variable to store the time in, relative to the selected clock's epoch, in µs. The returned value is
+ variable to store the time in, relative to the selected clock's epoch, in μs. The returned value is
relative to the epoch, even if the event source was created with a relative time via
<function>sd_event_add_time_relative()</function>.</para>
<para><function>sd_event_source_set_time()</function> changes the time of an event source created
previously with <function>sd_event_add_time()</function> or
<function>sd_event_add_time_relative()</function>. It takes the event source object and a time relative
- to the selected clock's epoch, in µs.</para>
+ to the selected clock's epoch, in μs.</para>
<para><function>sd_event_source_set_time_relative()</function> is similar to
<function>sd_event_source_set_time()</function>, but takes a time relative to the current time of the
retrieves the configured accuracy value of an event source
created previously with <function>sd_event_add_time()</function>. It
takes the event source object and a pointer to a variable to store
- the accuracy in. The accuracy is specified in µs.</para>
+ the accuracy in. The accuracy is specified in μs.</para>
<para><function>sd_event_source_set_time_accuracy()</function>
changes the configured accuracy of a timer event source created
previously with <function>sd_event_add_time()</function>. It takes
- the event source object and accuracy, in µs.</para>
+ the event source object and accuracy, in μs.</para>
<para><function>sd_event_source_get_time_clock()</function>
retrieves the configured clock of an event source created
<citerefentry project='man-pages'><refentrytitle>clock_gettime</refentrytitle><manvolnum>2</manvolnum></citerefentry>
for more information on the various clocks. The retrieved
timestamp is stored in the <parameter>usec</parameter> parameter,
- in µs since the clock's epoch. If this function is invoked before
+ in μs since the clock's epoch. If this function is invoked before
the first event loop iteration, the current time is returned, as
reported by <function>clock_gettime()</function>. To distinguish
this case from a regular invocation the return value will be
is no timeout to wait for this will fill in <constant>(uint64_t)
-1</constant> instead. Note that <function>poll()</function> takes
a relative timeout in milliseconds rather than an absolute timeout
- in microseconds. To convert the absolute 'µs' timeout into
+ in microseconds. To convert the absolute 'μs' timeout into
relative 'ms', use code like the following:</para>
<programlisting>uint64_t t;
<term>MONOTONIC_USEC=…</term>
<listitem><para>A field carrying the monotonic timestamp (as per
- <constant>CLOCK_MONOTONIC</constant>) formatted in decimal in µs, when the notification message was
+ <constant>CLOCK_MONOTONIC</constant>) formatted in decimal in μs, when the notification message was
generated by the client. This is typically used in combination with <literal>RELOADING=1</literal>,
to allow the service manager to properly synchronize reload cycles. See
<citerefentry><refentrytitle>systemd.service</refentrytitle><manvolnum>5</manvolnum></citerefentry>
<para>If the <parameter>usec</parameter> parameter is non-<constant>NULL</constant>,
<function>sd_watchdog_enabled()</function> will write the timeout
- in µs for the watchdog logic to it.</para>
+ in μs for the watchdog logic to it.</para>
<para>To enable service supervision with the watchdog logic, use
<varname>WatchdogSec=</varname> in service files. See
<listitem><para>Set by the system manager for supervised
process for which watchdog support is enabled, and contains
- the watchdog timeout in µs. See above for
+ the watchdog timeout in μs. See above for
details.</para></listitem>
</varlistentry>
</variablelist>
<variablelist>
<varlistentry>
<term><option>us</option></term>
- <term><option>µs</option></term>
+ <term><option>μs</option></term>
<listitem><para><literal>Day YYYY-MM-DD HH:MM:SS.UUUUUU TZ</literal></para></listitem>
</varlistentry>
</variablelist>
<variablelist>
<varlistentry>
<term><option>us+utc</option></term>
- <term><option>µs+utc</option></term>
+ <term><option>μs+utc</option></term>
<listitem><para><literal>Day YYYY-MM-DD HH:MM:SS.UUUUUU UTC</literal></para></listitem>
</varlistentry>
</variablelist>
<varlistentry>
<term><varname>COREDUMP_TIMESTAMP=</varname></term>
- <listitem><para>The time of the crash as reported by the kernel (in µs since the epoch).</para>
+ <listitem><para>The time of the crash as reported by the kernel (in μs since the epoch).</para>
</listitem>
</varlistentry>
<varname>DefaultMemoryPressureThresholdSec=</varname> setting in
<citerefentry><refentrytitle>systemd-system.conf</refentrytitle><manvolnum>5</manvolnum></citerefentry>
(which in turn defaults to 200ms). The specified value expects a time unit such as
- <literal>ms</literal> or <literal>µs</literal>, see
+ <literal>ms</literal> or <literal>μs</literal>, see
<citerefentry><refentrytitle>systemd.time</refentrytitle><manvolnum>7</manvolnum></citerefentry> for
details on the permitted syntax.</para></listitem>
</varlistentry>
<literal>MONOTONIC_USEC=</literal> set to the current monotonic time
(i.e. <constant>CLOCK_MONOTONIC</constant> in
<citerefentry><refentrytitle>clock_gettime</refentrytitle><manvolnum>2</manvolnum></citerefentry>)
- in µs, formatted as decimal string. Once reloading is complete another notification message must
+ in μs, formatted as decimal string. Once reloading is complete another notification message must
be sent, containing <literal>READY=1</literal>. Using this service type and implementing this
reload protocol is an efficient alternative to providing an <varname>ExecReload=</varname>
command for reloading of the service's configuration.</para></listitem>
<varlistentry>
<term><varname>Timestamping=</varname></term>
<listitem><para>Takes one of <literal>off</literal>, <literal>us</literal> (alias:
- <literal>usec</literal>, <literal>µs</literal>) or <literal>ns</literal> (alias:
+ <literal>usec</literal>, <literal>μs</literal>) or <literal>ns</literal> (alias:
<literal>nsec</literal>). This controls the <constant>SO_TIMESTAMP</constant> or
<constant>SO_TIMESTAMPNS</constant> socket options, and enables whether ingress network traffic shall
carry timestamping metadata. Defaults to <option>off</option>.</para></listitem>
understood:</para>
<itemizedlist>
- <listitem><para>usec, us, µs</para></listitem>
+ <listitem><para>usec, us, μs</para></listitem>
<listitem><para>msec, ms</para></listitem>
<listitem><para>seconds, second, sec, s</para></listitem>
<listitem><para>minutes, minute, min, m</para></listitem>
<row>
<entry><literal>@t</literal></entry>
<entry>File modification time</entry>
- <entry>Formatted decimal integer, µs since UNIX epoch Jan 1st 1970</entry>
+ <entry>Formatted decimal integer, μs since UNIX epoch Jan 1st 1970</entry>
<entry>Only relevant if target resource type chosen as <constant>regular-file</constant></entry>
</row>
(uint64_t) irq_ticks + (uint64_t) softirq_ticks +
(uint64_t) guest_ticks + (uint64_t) guest_nice_ticks;
- /* Let's reduce this fraction before we apply it to avoid overflows when converting this to µsec */
+ /* Let's reduce this fraction before we apply it to avoid overflows when converting this to μsec */
gcd = calc_gcd64(NSEC_PER_SEC, ticks_per_second);
a = (uint64_t) NSEC_PER_SEC / gcd;
if (l < (size_t) (1 + 1 + 1))
return NULL; /* not enough space for even the shortest of forms */
- return snprintf_ok(buf, l, "@" USEC_FMT, t / USEC_PER_SEC); /* round down µs → s */
+ return snprintf_ok(buf, l, "@" USEC_FMT, t / USEC_PER_SEC); /* round down μs → s */
}
utc = IN_SET(style, TIMESTAMP_UTC, TIMESTAMP_US_UTC, TIMESTAMP_DATE);
{ "y", USEC_PER_YEAR },
{ "usec", 1ULL },
{ "us", 1ULL },
- { "µs", 1ULL },
+ { "μs", 1ULL }, /* U+03bc (aka GREEK SMALL LETTER MU) */
+ { "µs", 1ULL }, /* U+b5 (aka MICRO SIGN) */
};
assert(p);
{ "y", NSEC_PER_YEAR },
{ "usec", NSEC_PER_USEC },
{ "us", NSEC_PER_USEC },
- { "µs", NSEC_PER_USEC },
+ { "μs", NSEC_PER_USEC }, /* U+03bc (aka GREEK LETTER MU) */
+ { "µs", NSEC_PER_USEC }, /* U+b5 (aka MICRO SIGN) */
{ "nsec", 1ULL },
{ "ns", 1ULL },
{ "", 1ULL }, /* default is nsec */
t = (TimestampStyle) string_table_lookup(timestamp_style_table, ELEMENTSOF(timestamp_style_table), s);
if (t >= 0)
return t;
- if (streq_ptr(s, "µs"))
+ if (STRPTR_IN_SET(s, "µs", "μs")) /* acccept both µ symbols in unicode, i.e. micro symbol + greek small letter mu. */
return TIMESTAMP_US;
- if (streq_ptr(s, "µs+utc"))
+ if (STRPTR_IN_SET(s, "µs+utc", "μs+utc"))
return TIMESTAMP_US_UTC;
return t;
}
* too. */
if (streq(p, "nsec"))
return SOCKET_TIMESTAMPING_NS;
- if (STR_IN_SET(p, "usec", "µs"))
+ if (STR_IN_SET(p, "usec", "µs", "μs")) /* Accept both small greek letter mu + micro sign unicode codepoints */
return SOCKET_TIMESTAMPING_US;
r = parse_boolean(p);
META_ARGV_UID, /* %u: as seen in the initial user namespace */
META_ARGV_GID, /* %g: as seen in the initial user namespace */
META_ARGV_SIGNAL, /* %s: number of signal causing dump */
- META_ARGV_TIMESTAMP, /* %t: time of dump, expressed as seconds since the Epoch (we expand this to µs granularity) */
+ META_ARGV_TIMESTAMP, /* %t: time of dump, expressed as seconds since the Epoch (we expand this to μs granularity) */
META_ARGV_RLIMIT, /* %c: core file size soft resource limit */
META_ARGV_HOSTNAME, /* %h: hostname */
_META_ARGV_MAX,
case META_ARGV_TIMESTAMP:
/* The journal fields contain the timestamp padded with six
* zeroes, so that the kernel-supplied 1s granularity timestamps
- * becomes 1µs granularity, i.e. the granularity systemd usually
+ * becomes 1μs granularity, i.e. the granularity systemd usually
* operates in. */
t = free_timestamp = strjoin(argv[i], "000000");
if (!t)
MHD_OPTION_ARRAY, opts,
MHD_OPTION_END);
if (!d->daemon) {
- log_error("Failed to start µhttp daemon");
+ log_error("Failed to start μhttp daemon");
r = -EINVAL;
goto error;
}
info = MHD_get_daemon_info(d->daemon, MHD_DAEMON_INFO_EPOLL_FD_LINUX_ONLY);
if (!info) {
- log_error("µhttp returned NULL daemon info");
+ log_error("μhttp returned NULL daemon info");
r = -EOPNOTSUPP;
goto error;
}
epoll_fd = info->listen_fd;
if (epoll_fd < 0) {
- log_error("µhttp epoll fd is invalid");
+ log_error("μhttp epoll fd is invalid");
r = -EUCLEAN;
goto error;
}
**********************************************************************
**********************************************************************/
-/* This should go away as soon as µhttpd allows state to be passed around. */
+/* This should go away as soon as μhttpd allows state to be passed around. */
RemoteServer *journal_remote_server_global;
static int dispatch_raw_source_event(sd_event_source *event,
* enum elements with the same name. Hence let's check for the *old* name,
* and define the new name by the value of the old name. */
-/* Renamed in µhttpd 0.9.51 */
+/* Renamed in μhttpd 0.9.51 */
#ifndef MHD_USE_PIPE_FOR_SHUTDOWN
# define MHD_USE_ITC MHD_USE_PIPE_FOR_SHUTDOWN
#endif
-/* Renamed in µhttpd 0.9.52 */
+/* Renamed in μhttpd 0.9.52 */
#ifndef MHD_USE_EPOLL_LINUX_ONLY
# define MHD_USE_EPOLL MHD_USE_EPOLL_LINUX_ONLY
#endif
-/* Renamed in µhttpd 0.9.52 */
+/* Renamed in μhttpd 0.9.52 */
#ifndef MHD_USE_SSL
# define MHD_USE_TLS MHD_USE_SSL
#endif
-/* Renamed in µhttpd 0.9.53 */
+/* Renamed in μhttpd 0.9.53 */
#ifndef MHD_USE_POLL_INTERNALLY
# define MHD_USE_POLL_INTERNAL_THREAD MHD_USE_POLL_INTERNALLY
#endif
# define MHD_HTTP_NOT_ACCEPTABLE MHD_HTTP_METHOD_NOT_ACCEPTABLE
#endif
-/* Renamed in µhttpd 0.9.74 (8c644fc1f4d498ea489add8d40a68f5d3e5899fa) */
+/* Renamed in μhttpd 0.9.74 (8c644fc1f4d498ea489add8d40a68f5d3e5899fa) */
#ifndef MHD_HTTP_CONTENT_TOO_LARGE
# ifdef MHD_HTTP_PAYLOAD_TOO_LARGE
# define MHD_HTTP_CONTENT_TOO_LARGE MHD_HTTP_PAYLOAD_TOO_LARGE /* 0.9.53 or newer */
* while the socket sticks around we might get confused by replies from earlier runs coming
* in late — which is pretty likely if we'd start our sequence numbers always from 1. Hence,
* let's start with a value based on the system clock. This should make collisions much less
- * likely (though still theoretically possible). We use a 32 bit µs counter starting at boot
+ * likely (though still theoretically possible). We use a 32 bit μs counter starting at boot
* for this (and explicitly exclude the zero, see above). This counter will wrap around after
* a bit more than 1h, but that's hopefully OK as the kernel shouldn't take that long to
* reply to our requests.
*
* We only pick the initial start value this way. For each message we simply increase the
- * sequence number by 1. This means we could enqueue 1 netlink message per µs without risking
+ * sequence number by 1. This means we could enqueue 1 netlink message per μs without risking
* collisions, which should be OK.
*
* Note this means the serials will be in the range 1…UINT32_MAX here.
} else {
char buf[DECIMAL_STR_MAX(uint64_t) + 1];
- xsprintf(buf, "%" PRIu64, x); /* µs granularity */
+ xsprintf(buf, "%" PRIu64, x); /* μs granularity */
r = write_string_file_atomic_label("/run/systemd/reboot-to-boot-loader-menu", buf);
if (r < 0)
if (repeat == 0)
return -ERANGE;
} else {
- /* If no repeat value is specified for the µs component, then let's explicitly refuse ranges
+ /* If no repeat value is specified for the μs component, then let's explicitly refuse ranges
* below 1s because our default repeat granularity is beyond that. */
/* Overflow check */
return -ERANGE;
cache_stat = new_stat;
- *ret = cache = sec * USEC_PER_SEC; /* return in µs */
+ *ret = cache = sec * USEC_PER_SEC; /* return in μs */
return 0;
}
/*
Returns > 0 if synchronization with systemd succeeded. Returns < 0
on error. Returns 0 if $NOTIFY_SOCKET was not set. Note that the
- timeout parameter of this function call takes the timeout in µs, and
+ timeout parameter of this function call takes the timeout in μs, and
will be passed to ppoll(2), hence the behaviour will be similar to
ppoll(2). This function can be called after sending a status message
to systemd, if one needs to synchronize against reception of the
Returns > 0 if the service manager expects watchdog keep-alive
events to be sent regularly via sd_notify(0, "WATCHDOG=1"). Returns
0 if it does not expect this. If the usec argument is non-NULL
- returns the watchdog timeout in µs after which the service manager
+ returns the watchdog timeout in μs after which the service manager
will act on a process that has not sent a watchdog keep alive
message. This function is useful to implement services that
recognize automatically if they are being run under supervision of
"e \\\n" \
"f \n" \
"g=g\\ \n" \
- "h= ąęół\\ śćńźżµ \n" \
+ "h= ąęół\\ śćńźżμ \n" \
"i=i\\"
#define env_file_2 \
assert_se(streq(data[1], "b=bc"));
assert_se(streq(data[2], "d=de f"));
assert_se(streq(data[3], "g=g "));
- assert_se(streq(data[4], "h=ąęół śćńźżµ"));
+ assert_se(streq(data[4], "h=ąęół śćńźżμ"));
assert_se(streq(data[5], "i=i"));
assert_se(data[6] == NULL);
}
q = now(CLOCK_MONOTONIC) - t;
- log_info("%lf µs each\n", (double) q / iterations);
+ log_info("%lf μs each\n", (double) q / iterations);
}
TEST(id128_at) {
(void) getpid();
q = now(CLOCK_MONOTONIC) - t;
- log_info(" glibc getpid(): %lf µs each\n", (double) q / iterations);
+ log_info(" glibc getpid(): %lf μs each\n", (double) q / iterations);
iterations *= 50; /* _cached() is about 50 times faster, so we need more iterations */
(void) getpid_cached();
q = now(CLOCK_MONOTONIC) - t;
- log_info("getpid_cached(): %lf µs each\n", (double) q / iterations);
+ log_info("getpid_cached(): %lf μs each\n", (double) q / iterations);
}
TEST(safe_fork) {
assert_se(u == 700 * USEC_PER_MSEC);
assert_se(parse_sec("23us", &u) >= 0);
assert_se(u == 23);
- assert_se(parse_sec("23µs", &u) >= 0);
+ assert_se(parse_sec("23μs", &u) >= 0); /* greek small letter mu */
+ assert_se(u == 23);
+ assert_se(parse_sec("23µs", &u) >= 0); /* micro symbol */
assert_se(u == 23);
assert_se(parse_sec("infinity", &u) >= 0);
assert_se(u == USEC_INFINITY);
* different timestamp accuracy: traditional fat has 2s granularity, and even ext2 and friends expose
* different granularity depending on selected inode size during formatting! Hence, to ensure the
* timestamp definitely is increased, here's what we'll do: we'll first try to increase the timestamp
- * by 1µs, write that and read it back. If it was updated, great. But if it was not, we'll instead
- * increase the timestamp by 10µs, and do the same, then 100µs, then 1ms, and so on, until it works,
+ * by 1μs, write that and read it back. If it was updated, great. But if it was not, we'll instead
+ * increase the timestamp by 10μs, and do the same, then 100μs, then 1ms, and so on, until it works,
* or we reach 10s. If it still didn't work then, the fs is just broken and we give up. */
usec_t target = MAX3(now(CLOCK_REALTIME),
TIME_EPOCH * USEC_PER_SEC,
timespec_load(&st->st_mtim));
- for (usec_t a = 1; a <= 10 * USEC_PER_SEC; a *= 10) { /* 1µs, 10µs, 100µs, 1ms, … 10s */
+ for (usec_t a = 1; a <= 10 * USEC_PER_SEC; a *= 10) { /* 1μs, 10μs, 100μs, 1ms, … 10s */
struct timespec ts[2];
struct stat new_st;
projects / thirdparty / systemd.git / commitdiff
