src/shared/hwclock.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010-2012 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <assert.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <errno.h>
  26 #include <stdlib.h>
  27 #include <signal.h>
  28 #include <stdio.h>
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31 #include <fcntl.h>
  32 #include <sys/ioctl.h>
  33 #include <stdarg.h>
  34 #include <ctype.h>
  35 #include <sys/prctl.h>
  36 #include <sys/time.h>
  37 #include <linux/rtc.h>
  38
  39 #include "macro.h"
  40 #include "util.h"
  41 #include "log.h"
  42 #include "strv.h"
  43 #include "hwclock.h"
  44
  45 static int rtc_open(int flags) {
  46         int fd;
  47         DIR *d;
  48
  49         /* First, we try to make use of the /dev/rtc symlink. If that
  50          * doesn't exist, we open the first RTC which has hctosys=1
  51          * set. If we don't find any we just take the first RTC that
  52          * exists at all. */
  53
  54         fd = open("/dev/rtc", flags);
  55         if (fd >= 0)
  56                 return fd;
  57
  58         d = opendir("/sys/class/rtc");
  59         if (!d)
  60                 goto fallback;
  61
  62         for (;;) {
  63                 char *p, *v;
  64                 struct dirent buf, *de;
  65                 int r;
  66
  67                 r = readdir_r(d, &buf, &de);
  68                 if (r != 0)
  69                         goto fallback;
  70
  71                 if (!de)
  72                         goto fallback;
  73
  74                 if (ignore_file(de->d_name))
  75                         continue;
  76
  77                 p = strjoin("/sys/class/rtc/", de->d_name, "/hctosys", NULL);
  78                 if (!p) {
  79                         closedir(d);
  80                         return -ENOMEM;
  81                 }
  82
  83                 r = read_one_line_file(p, &v);
  84                 free(p);
  85
  86                 if (r < 0)
  87                         continue;
  88
  89                 r = parse_boolean(v);
  90                 free(v);
  91
  92                 if (r <= 0)
  93                         continue;
  94
  95                 p = strappend("/dev/", de->d_name);
  96                 fd = open(p, flags);
  97                 free(p);
  98
  99                 if (fd >= 0) {
 100                         closedir(d);
 101                         return fd;
 102                 }
 103         }
 104
 105 fallback:
 106         if (d)
 107                 closedir(d);
 108
 109         fd = open("/dev/rtc0", flags);
 110         if (fd < 0)
 111                 return -errno;
 112
 113         return fd;
 114 }
 115
 116 int hwclock_get_time(struct tm *tm) {
 117         int fd;
 118         int err = 0;
 119
 120         assert(tm);
 121
 122         fd = rtc_open(O_RDONLY|O_CLOEXEC);
 123         if (fd < 0)
 124                 return -errno;
 125
 126         /* This leaves the timezone fields of struct tm
 127          * uninitialized! */
 128         if (ioctl(fd, RTC_RD_TIME, tm) < 0)
 129                 err = -errno;
 130
 131         /* We don't know daylight saving, so we reset this in order not
 132          * to confused mktime(). */
 133         tm->tm_isdst = -1;
 134
 135         close_nointr_nofail(fd);
 136
 137         return err;
 138 }
 139
 140 int hwclock_set_time(const struct tm *tm) {
 141         int fd;
 142         int err = 0;
 143
 144         assert(tm);
 145
 146         fd = rtc_open(O_RDONLY|O_CLOEXEC);
 147         if (fd < 0)
 148                 return -errno;
 149
 150         if (ioctl(fd, RTC_SET_TIME, tm) < 0)
 151                 err = -errno;
 152
 153         close_nointr_nofail(fd);
 154
 155         return err;
 156 }
 157
 158 int hwclock_is_localtime(void) {
 159         FILE *f;
 160         bool local = false;
 161
 162         /*
 163          * The third line of adjtime is "UTC" or "LOCAL" or nothing.
 164          *   # /etc/adjtime
 165          *   0.0 0 0
 166          *   0
 167          *   UTC
 168          */
 169         f = fopen("/etc/adjtime", "re");
 170         if (f) {
 171                 char line[LINE_MAX];
 172                 bool b;
 173
 174                 b = fgets(line, sizeof(line), f) &&
 175                         fgets(line, sizeof(line), f) &&
 176                         fgets(line, sizeof(line), f);
 177
 178                 fclose(f);
 179
 180                 if (!b)
 181                         return -EIO;
 182
 183                 truncate_nl(line);
 184                 local = streq(line, "LOCAL");
 185
 186         } else if (errno != -ENOENT)
 187                 return -errno;
 188
 189         return local;
 190 }
 191
 192 int hwclock_set_timezone(int *min) {
 193         const struct timeval *tv_null = NULL;
 194         struct timespec ts;
 195         struct tm *tm;
 196         int minuteswest;
 197         struct timezone tz;
 198
 199         assert_se(clock_gettime(CLOCK_REALTIME, &ts) == 0);
 200         assert_se(tm = localtime(&ts.tv_sec));
 201         minuteswest = tm->tm_gmtoff / 60;
 202
 203         tz.tz_minuteswest = -minuteswest;
 204         tz.tz_dsttime = 0; /* DST_NONE*/
 205
 206         /*
 207          * If the hardware clock does not run in UTC, but in local time:
 208          * The very first time we set the kernel's timezone, it will warp
 209          * the clock so that it runs in UTC instead of local time.
 210          */
 211         if (settimeofday(tv_null, &tz) < 0)
 212                 return -errno;
 213         if (min)
 214                 *min = minuteswest;
 215         return 0;
 216 }
 217
 218 int hwclock_reset_timezone(void) {
 219         const struct timeval *tv_null = NULL;
 220         struct timezone tz;
 221
 222         tz.tz_minuteswest = 0;
 223         tz.tz_dsttime = 0; /* DST_NONE*/
 224
 225         /*
 226          * The very first time we set the kernel's timezone, it will warp
 227          * the clock. Do a dummy call here, so the time warping is sealed
 228          * and we set only the time zone with next call.
 229          */
 230         if (settimeofday(tv_null, &tz) < 0)
 231                 return -errno;
 232
 233         return 0;
 234 }