copy: adjust directory times after writing to the directory

[elogind.git] / src / basic / time-util.c

diff --git a/src/basic/time-util.c b/src/basic/time-util.c
index 7fb3745d6c317f1dc0109f070d13c85d5388ed55..2a3957d97ae2f1f2f596fac71f4979792a4faa60 100644 (file)
--- a/src/basic/time-util.c
+++ b/src/basic/time-util.c
@@ -1,5 +1,3 @@
-/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
-

 /***
   This file is part of systemd.
 
 /***
   This file is part of systemd.
 


@@ -19,19 +17,32 @@
   along with systemd; If not, see <http://www.gnu.org/licenses/>.
 ***/
 
   along with systemd; If not, see <http://www.gnu.org/licenses/>.
 ***/
 

+#include <errno.h>
+#include <limits.h>
+#include <stdlib.h>

 #include <string.h>
 #include <string.h>

+#include <sys/stat.h>
+#include <sys/time.h>

 #include <sys/timerfd.h>
 #include <sys/timex.h>
 #include <sys/timerfd.h>
 #include <sys/timex.h>

+#include <sys/types.h>
+#include <unistd.h>

 
 #include "alloc-util.h"
 #include "fd-util.h"
 #include "fileio.h"
 #include "fs-util.h"
 
 #include "alloc-util.h"
 #include "fd-util.h"
 #include "fileio.h"
 #include "fs-util.h"

+#include "log.h"
+#include "macro.h"
+#include "parse-util.h"

 #include "path-util.h"
 #include "string-util.h"
 #include "strv.h"
 #include "time-util.h"
 #include "path-util.h"
 #include "string-util.h"
 #include "strv.h"
 #include "time-util.h"

-#include "util.h"
+
+#if 0 /// UNNEEDED by elogind
+static nsec_t timespec_load_nsec(const struct timespec *ts);
+#endif // 0

 
 usec_t now(clockid_t clock_id) {
         struct timespec ts;
 
 usec_t now(clockid_t clock_id) {
         struct timespec ts;


@@ -41,8 +52,7 @@ usec_t now(clockid_t clock_id) {
         return timespec_load(&ts);
 }
 
         return timespec_load(&ts);
 }
 

-/// UNNEEDED by elogind
-#if 0
+#if 0 /// UNNEEDED by elogind

 nsec_t now_nsec(clockid_t clock_id) {
         struct timespec ts;
 
 nsec_t now_nsec(clockid_t clock_id) {
         struct timespec ts;
 


@@ -73,18 +83,12 @@ dual_timestamp* dual_timestamp_from_realtime(dual_timestamp *ts, usec_t u) {
         ts->realtime = u;
 
         delta = (int64_t) now(CLOCK_REALTIME) - (int64_t) u;
         ts->realtime = u;
 
         delta = (int64_t) now(CLOCK_REALTIME) - (int64_t) u;

-        ts->monotonic = now(CLOCK_MONOTONIC);
-
-        if ((int64_t) ts->monotonic > delta)
-                ts->monotonic -= delta;
-        else
-                ts->monotonic = 0;
+        ts->monotonic = usec_sub(now(CLOCK_MONOTONIC), delta);

 
         return ts;
 }
 
 
         return ts;
 }
 

-/// UNNEEDED by elogind
-#if 0
+#if 0 /// UNNEEDED by elogind

 dual_timestamp* dual_timestamp_from_monotonic(dual_timestamp *ts, usec_t u) {
         int64_t delta;
         assert(ts);
 dual_timestamp* dual_timestamp_from_monotonic(dual_timestamp *ts, usec_t u) {
         int64_t delta;
         assert(ts);


@@ -96,12 +100,7 @@ dual_timestamp* dual_timestamp_from_monotonic(dual_timestamp *ts, usec_t u) {
 
         ts->monotonic = u;
         delta = (int64_t) now(CLOCK_MONOTONIC) - (int64_t) u;
 
         ts->monotonic = u;
         delta = (int64_t) now(CLOCK_MONOTONIC) - (int64_t) u;

-
-        ts->realtime = now(CLOCK_REALTIME);
-        if ((int64_t) ts->realtime > delta)
-                ts->realtime -= delta;
-        else
-                ts->realtime = 0;
+        ts->realtime = usec_sub(now(CLOCK_REALTIME), delta);

 
         return ts;
 }
 
         return ts;
 }


@@ -113,20 +112,11 @@ dual_timestamp* dual_timestamp_from_boottime_or_monotonic(dual_timestamp *ts, us
                 ts->realtime = ts->monotonic = USEC_INFINITY;
                 return ts;
         }
                 ts->realtime = ts->monotonic = USEC_INFINITY;
                 return ts;
         }

-        ts->realtime = now(CLOCK_REALTIME);
-        ts->monotonic = now(CLOCK_MONOTONIC);

 
 

+        dual_timestamp_get(ts);

         delta = (int64_t) now(clock_boottime_or_monotonic()) - (int64_t) u;
         delta = (int64_t) now(clock_boottime_or_monotonic()) - (int64_t) u;

-
-        if ((int64_t) ts->realtime > delta)
-                ts->realtime -= delta;
-        else
-                ts->realtime = 0;
-
-        if ((int64_t) ts->monotonic > delta)
-                ts->monotonic -= delta;
-        else
-                ts->monotonic = 0;
+        ts->realtime = usec_sub(ts->realtime, delta);
+        ts->monotonic = usec_sub(ts->monotonic, delta);

 
         return ts;
 }
 
         return ts;
 }


@@ -147,7 +137,8 @@ usec_t timespec_load(const struct timespec *ts) {
                 (usec_t) ts->tv_nsec / NSEC_PER_USEC;
 }
 
                 (usec_t) ts->tv_nsec / NSEC_PER_USEC;
 }
 

-nsec_t timespec_load_nsec(const struct timespec *ts) {
+#if 0 /// UNNEEDED by elogind
+static nsec_t timespec_load_nsec(const struct timespec *ts) {

         assert(ts);
 
         if (ts->tv_sec == (time_t) -1 &&
         assert(ts);
 
         if (ts->tv_sec == (time_t) -1 &&


@@ -158,6 +149,7 @@ nsec_t timespec_load_nsec(const struct timespec *ts) {
                 (nsec_t) ts->tv_sec * NSEC_PER_SEC +
                 (nsec_t) ts->tv_nsec;
 }
                 (nsec_t) ts->tv_sec * NSEC_PER_SEC +
                 (nsec_t) ts->tv_nsec;
 }

+#endif // 0

 
 struct timespec *timespec_store(struct timespec *ts, usec_t u)  {
         assert(ts);
 
 struct timespec *timespec_store(struct timespec *ts, usec_t u)  {
         assert(ts);


@@ -203,9 +195,11 @@ struct timeval *timeval_store(struct timeval *tv, usec_t u) {
         return tv;
 }
 
         return tv;
 }
 

-static char *format_timestamp_internal(char *buf, size_t l, usec_t t, bool utc) {
+static char *format_timestamp_internal(char *buf, size_t l, usec_t t,
+                                       bool utc, bool us) {

         struct tm tm;
         time_t sec;
         struct tm tm;
         time_t sec;

+        int k;

 
         assert(buf);
         assert(l > 0);
 
         assert(buf);
         assert(l > 0);


@@ -216,53 +210,39 @@ static char *format_timestamp_internal(char *buf, size_t l, usec_t t, bool utc)
         sec = (time_t) (t / USEC_PER_SEC);
         localtime_or_gmtime_r(&sec, &tm, utc);
 
         sec = (time_t) (t / USEC_PER_SEC);
         localtime_or_gmtime_r(&sec, &tm, utc);
 

-        if (strftime(buf, l, "%a %Y-%m-%d %H:%M:%S %Z", &tm) <= 0)
+        if (us)
+                k = strftime(buf, l, "%a %Y-%m-%d %H:%M:%S", &tm);
+        else
+                k = strftime(buf, l, "%a %Y-%m-%d %H:%M:%S %Z", &tm);
+
+        if (k <= 0)

                 return NULL;
                 return NULL;

+        if (us) {
+                snprintf(buf + strlen(buf), l - strlen(buf), ".%06llu", (unsigned long long) (t % USEC_PER_SEC));
+                if (strftime(buf + strlen(buf), l - strlen(buf), " %Z", &tm) <= 0)
+                        return NULL;
+        }

 
         return buf;
 }
 
 char *format_timestamp(char *buf, size_t l, usec_t t) {
 
         return buf;
 }
 
 char *format_timestamp(char *buf, size_t l, usec_t t) {

-        return format_timestamp_internal(buf, l, t, false);
+        return format_timestamp_internal(buf, l, t, false, false);

 }
 
 }
 

-/// UNNEEDED by elogind
-#if 0
+#if 0 /// UNNEEDED by elogind

 char *format_timestamp_utc(char *buf, size_t l, usec_t t) {
 char *format_timestamp_utc(char *buf, size_t l, usec_t t) {

-        return format_timestamp_internal(buf, l, t, true);
+        return format_timestamp_internal(buf, l, t, true, false);

 }
 #endif // 0
 
 }
 #endif // 0
 

-static char *format_timestamp_internal_us(char *buf, size_t l, usec_t t, bool utc) {
-        struct tm tm;
-        time_t sec;
-
-        assert(buf);
-        assert(l > 0);
-
-        if (t <= 0 || t == USEC_INFINITY)
-                return NULL;
-
-        sec = (time_t) (t / USEC_PER_SEC);
-        localtime_or_gmtime_r(&sec, &tm, utc);
-
-        if (strftime(buf, l, "%a %Y-%m-%d %H:%M:%S", &tm) <= 0)
-                return NULL;
-        snprintf(buf + strlen(buf), l - strlen(buf), ".%06llu", (unsigned long long) (t % USEC_PER_SEC));
-        if (strftime(buf + strlen(buf), l - strlen(buf), " %Z", &tm) <= 0)
-                return NULL;
-
-        return buf;
-}
-

 char *format_timestamp_us(char *buf, size_t l, usec_t t) {
 char *format_timestamp_us(char *buf, size_t l, usec_t t) {

-        return format_timestamp_internal_us(buf, l, t, false);
+        return format_timestamp_internal(buf, l, t, false, true);

 }
 
 }
 

-/// UNNEEDED by elogind
-#if 0
+#if 0 /// UNNEEDED by elogind

 char *format_timestamp_us_utc(char *buf, size_t l, usec_t t) {
 char *format_timestamp_us_utc(char *buf, size_t l, usec_t t) {

-        return format_timestamp_internal_us(buf, l, t, true);
+        return format_timestamp_internal(buf, l, t, true, true);

 }
 #endif // 0
 
 }
 #endif // 0
 


@@ -439,8 +419,7 @@ char *format_timespan(char *buf, size_t l, usec_t t, usec_t accuracy) {
         return buf;
 }
 
         return buf;
 }
 

-/// UNNEEDED by elogind
-#if 0
+#if 0 /// UNNEEDED by elogind

 void dual_timestamp_serialize(FILE *f, const char *name, dual_timestamp *t) {
 
         assert(f);
 void dual_timestamp_serialize(FILE *f, const char *name, dual_timestamp *t) {
 
         assert(f);


@@ -463,7 +442,7 @@ int dual_timestamp_deserialize(const char *value, dual_timestamp *t) {
         assert(t);
 
         if (sscanf(value, "%llu %llu", &a, &b) != 2) {
         assert(t);
 
         if (sscanf(value, "%llu %llu", &a, &b) != 2) {

-                log_debug("Failed to parse finish timestamp value %s.", value);
+                log_debug("Failed to parse dual timestamp value \"%s\": %m", value);

                 return -EINVAL;
         }
 
                 return -EINVAL;
         }
 


@@ -473,6 +452,18 @@ int dual_timestamp_deserialize(const char *value, dual_timestamp *t) {
         return 0;
 }
 
         return 0;
 }
 

+int timestamp_deserialize(const char *value, usec_t *timestamp) {
+        int r;
+
+        assert(value);
+
+        r = safe_atou64(value, timestamp);
+        if (r < 0)
+                return log_debug_errno(r, "Failed to parse timestamp value \"%s\": %m", value);
+
+        return r;
+}
+

 int parse_timestamp(const char *t, usec_t *usec) {
         static const struct {
                 const char *name;
 int parse_timestamp(const char *t, usec_t *usec) {
         static const struct {
                 const char *name;


@@ -579,12 +570,12 @@ int parse_timestamp(const char *t, usec_t *usec) {
                 goto from_tm;
 
         } else if (streq(t, "yesterday")) {
                 goto from_tm;
 
         } else if (streq(t, "yesterday")) {

-                tm.tm_mday --;
+                tm.tm_mday--;

                 tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
                 goto from_tm;
 
         } else if (streq(t, "tomorrow")) {
                 tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
                 goto from_tm;
 
         } else if (streq(t, "tomorrow")) {

-                tm.tm_mday ++;
+                tm.tm_mday++;

                 tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
                 goto from_tm;
         }
                 tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
                 goto from_tm;
         }


@@ -671,29 +662,18 @@ int parse_timestamp(const char *t, usec_t *usec) {
 
 parse_usec:
         {
 
 parse_usec:
         {

-                char *end;
-                unsigned long long val;
-                size_t l;
+                unsigned add;

 
                 k++;
 
                 k++;

-                if (*k < '0' || *k > '9')
+                r = parse_fractional_part_u(&k, 6, &add);
+                if (r < 0)

                         return -EINVAL;
 
                         return -EINVAL;
 

-                /* base 10 instead of base 0, .09 is not base 8 */
-                errno = 0;
-                val = strtoull(k, &end, 10);
-                if (*end || errno)
+                if (*k)

                         return -EINVAL;
 
                         return -EINVAL;
 

-                l = end-k;
+                x_usec = add;

 
 

-                /* val has l digits, make them 6 */
-                for (; l < 6; l++)
-                        val *= 10;
-                for (; l > 6; l--)
-                        val /= 10;
-
-                x_usec = val;

         }
 
 from_tm:
         }
 
 from_tm:


@@ -852,8 +832,7 @@ int parse_sec(const char *t, usec_t *usec) {
         return parse_time(t, usec, USEC_PER_SEC);
 }
 
         return parse_time(t, usec, USEC_PER_SEC);
 }
 

-/// UNNEEDED by elogind
-#if 0
+#if 0 /// UNNEEDED by elogind

 int parse_nsec(const char *t, nsec_t *nsec) {
         static const struct {
                 const char *suffix;
 int parse_nsec(const char *t, nsec_t *nsec) {
         static const struct {
                 const char *suffix;


@@ -1096,22 +1075,31 @@ bool timezone_is_valid(const char *name) {
         return true;
 }
 
         return true;
 }
 

-clockid_t clock_boottime_or_monotonic(void) {
-        static clockid_t clock = -1;
-        int fd;
-
-        if (clock != -1)
-                return clock;
-
-        fd = timerfd_create(CLOCK_BOOTTIME, TFD_NONBLOCK|TFD_CLOEXEC);
-        if (fd < 0)
-                clock = CLOCK_MONOTONIC;
-        else {
-                safe_close(fd);
-                clock = CLOCK_BOOTTIME;
+bool clock_boottime_supported(void) {
+        static int supported = -1;
+
+        /* Note that this checks whether CLOCK_BOOTTIME is available in general as well as available for timerfds()! */
+
+        if (supported < 0) {
+                int fd;
+
+                fd = timerfd_create(CLOCK_BOOTTIME, TFD_NONBLOCK|TFD_CLOEXEC);
+                if (fd < 0)
+                        supported = false;
+                else {
+                        safe_close(fd);
+                        supported = true;
+                }

         }
 
         }
 

-        return clock;
+        return supported;
+}
+
+clockid_t clock_boottime_or_monotonic(void) {
+        if (clock_boottime_supported())
+                return CLOCK_BOOTTIME;
+        else
+                return CLOCK_MONOTONIC;

 }
 
 int get_timezone(char **tz) {
 }
 
 int get_timezone(char **tz) {


@@ -1150,8 +1138,7 @@ struct tm *localtime_or_gmtime_r(const time_t *t, struct tm *tm, bool utc) {
         return utc ? gmtime_r(t, tm) : localtime_r(t, tm);
 }
 
         return utc ? gmtime_r(t, tm) : localtime_r(t, tm);
 }
 

-/// UNNEEDED by elogind
-#if 0
+#if 0 /// UNNEEDED by elogind

 unsigned long usec_to_jiffies(usec_t u) {
         static thread_local unsigned long hz = 0;
         long r;
 unsigned long usec_to_jiffies(usec_t u) {
         static thread_local unsigned long hz = 0;
         long r;