sys-utils/hwclock-rtc.c

   1 /*
   2  * SPDX-License-Identifier: GPL-2.0-or-later
   3  *
   4  * rtc.c - Use /dev/rtc for clock access
   5  */
   6 #include <asm/ioctl.h>
   7 #include <errno.h>
   8 #include <fcntl.h>
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <sys/ioctl.h>
  12 #include <sys/select.h>
  13 #include <sys/time.h>
  14 #include <time.h>
  15 #include <unistd.h>
  16
  17 #include "monotonic.h"
  18 #include "nls.h"
  19
  20 #include "hwclock.h"
  21
  22 /*
  23  * Get defines for rtc stuff.
  24  *
  25  * Getting the rtc defines is nontrivial. The obvious way is by including
  26  * <linux/mc146818rtc.h> but that again includes <asm/io.h> which again
  27  * includes ... and on sparc and alpha this gives compilation errors for
  28  * many kernel versions. So, we give the defines ourselves here. Moreover,
  29  * some Sparc person decided to be incompatible, and used a struct rtc_time
  30  * different from that used in mc146818rtc.h.
  31  */
  32
  33 /*
  34  * On Sparcs, there is a <asm/rtc.h> that defines different ioctls (that are
  35  * required on my machine). However, this include file does not exist on
  36  * other architectures.
  37  */
  38 /* One might do:
  39 #ifdef __sparc__
  40 # include <asm/rtc.h>
  41 #endif
  42  */
  43 #ifdef __sparc__
  44 /* The following is roughly equivalent */
  45 struct sparc_rtc_time
  46 {
  47         int sec;        /* Seconds              0-59 */
  48         int min;        /* Minutes              0-59 */
  49         int hour;       /* Hour                 0-23 */
  50         int dow;        /* Day of the week      1-7  */
  51         int dom;        /* Day of the month     1-31 */
  52         int month;      /* Month of year        1-12 */
  53         int year;       /* Year                 0-99 */
  54 };
  55 #define RTCGET _IOR('p', 20, struct sparc_rtc_time)
  56 #define RTCSET _IOW('p', 21, struct sparc_rtc_time)
  57 #endif
  58
  59 /*
  60  * struct rtc_time is present since 1.3.99.
  61  * Earlier (since 1.3.89), a struct tm was used.
  62  */
  63 struct linux_rtc_time {
  64         int tm_sec;
  65         int tm_min;
  66         int tm_hour;
  67         int tm_mday;
  68         int tm_mon;
  69         int tm_year;
  70         int tm_wday;
  71         int tm_yday;
  72         int tm_isdst;
  73 };
  74
  75 /* RTC_RD_TIME etc have this definition since 1.99.9 (pre2.0-9) */
  76 #ifndef RTC_RD_TIME
  77 # define RTC_RD_TIME    _IOR('p', 0x09, struct linux_rtc_time)
  78 # define RTC_SET_TIME   _IOW('p', 0x0a, struct linux_rtc_time)
  79 # define RTC_UIE_ON     _IO('p', 0x03)  /* Update int. enable on */
  80 # define RTC_UIE_OFF    _IO('p', 0x04)  /* Update int. enable off */
  81 #endif
  82
  83 /* RTC_EPOCH_READ and RTC_EPOCH_SET are present since 2.0.34 and 2.1.89 */
  84 #ifndef RTC_EPOCH_READ
  85 # define RTC_EPOCH_READ _IOR('p', 0x0d, unsigned long)  /* Read epoch */
  86 # define RTC_EPOCH_SET  _IOW('p', 0x0e, unsigned long)  /* Set epoch */
  87 #endif
  88
  89 /*
  90  * /dev/rtc is conventionally chardev 10/135
  91  * ia64 uses /dev/efirtc, chardev 10/136
  92  * devfs (obsolete) used /dev/misc/... for miscdev
  93  * new RTC framework + udev uses dynamic major and /dev/rtc0.../dev/rtcN
  94  * ... so we need an overridable default
  95  */
  96
  97 /* default or user defined dev (by hwclock --rtc=<path>) */
  98 static const char *rtc_dev_name;
  99 static int rtc_dev_fd = -1;
 100
 101 static void close_rtc(void)
 102 {
 103         if (rtc_dev_fd != -1)
 104                 close(rtc_dev_fd);
 105         rtc_dev_fd = -1;
 106 }
 107
 108 static int open_rtc(const struct hwclock_control *ctl)
 109 {
 110         static const char *fls[] = {
 111 #ifdef __ia64__
 112                 "/dev/efirtc",
 113                 "/dev/misc/efirtc",
 114 #endif
 115                 "/dev/rtc0",
 116                 "/dev/rtc",
 117                 "/dev/misc/rtc"
 118         };
 119         size_t i;
 120
 121         if (rtc_dev_fd != -1)
 122                 return rtc_dev_fd;
 123
 124         /* --rtc option has been given */
 125         if (ctl->rtc_dev_name) {
 126                 rtc_dev_name = ctl->rtc_dev_name;
 127                 rtc_dev_fd = open(rtc_dev_name, O_RDONLY);
 128         } else {
 129                 for (i = 0; i < ARRAY_SIZE(fls); i++) {
 130                         if (ctl->verbose)
 131                                 printf(_("Trying to open: %s\n"), fls[i]);
 132                         rtc_dev_fd = open(fls[i], O_RDONLY);
 133
 134                         if (rtc_dev_fd < 0) {
 135                                 if (errno == ENOENT || errno == ENODEV)
 136                                         continue;
 137                                 if (ctl->verbose)
 138                                         warn(_("cannot open %s"), fls[i]);
 139                         }
 140                         rtc_dev_name = fls[i];
 141                         break;
 142                 }
 143                 if (rtc_dev_fd < 0)
 144                         rtc_dev_name = *fls;    /* default for error messages */
 145         }
 146         if (rtc_dev_fd != -1)
 147                 atexit(close_rtc);
 148         return rtc_dev_fd;
 149 }
 150
 151 static int open_rtc_or_exit(const struct hwclock_control *ctl)
 152 {
 153         int rtc_fd = open_rtc(ctl);
 154
 155         if (rtc_fd < 0) {
 156                 warn(_("cannot open rtc device"));
 157                 hwclock_exit(ctl, EXIT_FAILURE);
 158         }
 159         return rtc_fd;
 160 }
 161
 162 static int do_rtc_read_ioctl(int rtc_fd, struct tm *tm)
 163 {
 164         int rc = -1;
 165         char *ioctlname;
 166 #ifdef __sparc__
 167         /* some but not all sparcs use a different ioctl and struct */
 168         struct sparc_rtc_time stm;
 169 #endif
 170
 171         ioctlname = "RTC_RD_TIME";
 172         rc = ioctl(rtc_fd, RTC_RD_TIME, tm);
 173
 174 #ifdef __sparc__
 175         if (rc == -1) {         /* sparc sbus */
 176                 ioctlname = "RTCGET";
 177                 rc = ioctl(rtc_fd, RTCGET, &stm);
 178                 if (rc == 0) {
 179                         tm->tm_sec = stm.sec;
 180                         tm->tm_min = stm.min;
 181                         tm->tm_hour = stm.hour;
 182                         tm->tm_mday = stm.dom;
 183                         tm->tm_mon = stm.month - 1;
 184                         tm->tm_year = stm.year - 1900;
 185                         tm->tm_wday = stm.dow - 1;
 186                         tm->tm_yday = -1;       /* day in the year */
 187                 }
 188         }
 189 #endif
 190
 191         if (rc == -1) {
 192                 warn(_("ioctl(%s) to %s to read the time failed"),
 193                         ioctlname, rtc_dev_name);
 194                 return -1;
 195         }
 196
 197         tm->tm_isdst = -1;      /* don't know whether it's dst */
 198         return 0;
 199 }
 200
 201 /*
 202  * Wait for the top of a clock tick by reading /dev/rtc in a busy loop
 203  * until we see it. This function is used for rtc drivers without ioctl
 204  * interrupts. This is typical on an Alpha, where the Hardware Clock
 205  * interrupts are used by the kernel for the system clock, so aren't at
 206  * the user's disposal.
 207  */
 208 static int busywait_for_rtc_clock_tick(const struct hwclock_control *ctl,
 209                                        const int rtc_fd)
 210 {
 211         struct tm start_time;
 212         /* The time when we were called (and started waiting) */
 213         struct tm nowtime;
 214         int rc;
 215         struct timeval begin, now;
 216
 217         if (ctl->verbose) {
 218                 printf("ioctl(%d, RTC_UIE_ON, 0): %s\n",
 219                        rtc_fd, strerror(errno));
 220                 printf(_("Waiting in loop for time from %s to change\n"),
 221                        rtc_dev_name);
 222         }
 223
 224         if (do_rtc_read_ioctl(rtc_fd, &start_time))
 225                 return 1;
 226
 227         /*
 228          * Wait for change.  Should be within a second, but in case
 229          * something weird happens, we have a time limit (1.5s) on this loop
 230          * to reduce the impact of this failure.
 231          */
 232         gettime_monotonic(&begin);
 233         do {
 234                 rc = do_rtc_read_ioctl(rtc_fd, &nowtime);
 235                 if (rc || start_time.tm_sec != nowtime.tm_sec)
 236                         break;
 237                 gettime_monotonic(&now);
 238                 if (time_diff(now, begin) > 1.5) {
 239                         warnx(_("Timed out waiting for time change."));
 240                         return 1;
 241                 }
 242         } while (1);
 243
 244         if (rc)
 245                 return 1;
 246         return 0;
 247 }
 248
 249 /*
 250  * Same as synchronize_to_clock_tick(), but just for /dev/rtc.
 251  */
 252 static int synchronize_to_clock_tick_rtc(const struct hwclock_control *ctl)
 253 {
 254         int rtc_fd;             /* File descriptor of /dev/rtc */
 255         int ret = 1;
 256
 257         rtc_fd = open_rtc(ctl);
 258         if (rtc_fd == -1) {
 259                 warn(_("cannot open rtc device"));
 260                 return ret;
 261         } else {
 262                 /* Turn on update interrupts (one per second) */
 263                 int rc = ioctl(rtc_fd, RTC_UIE_ON, 0);
 264
 265                 if (rc != -1) {
 266                         /*
 267                          * Just reading rtc_fd fails on broken hardware: no
 268                          * update interrupt comes and a bootscript with a
 269                          * hwclock call hangs
 270                          */
 271                         fd_set rfds;
 272                         struct timeval tv;
 273
 274                         /*
 275                          * Wait up to ten seconds for the next update
 276                          * interrupt
 277                          */
 278                         FD_ZERO(&rfds);
 279                         FD_SET(rtc_fd, &rfds);
 280                         tv.tv_sec = 10;
 281                         tv.tv_usec = 0;
 282                         rc = select(rtc_fd + 1, &rfds, NULL, NULL, &tv);
 283                         if (0 < rc)
 284                                 ret = 0;
 285                         else if (rc == 0) {
 286                                 warnx(_("select() to %s to wait for clock tick timed out"),
 287                                       rtc_dev_name);
 288                         } else
 289                                 warn(_("select() to %s to wait for clock tick failed"),
 290                                      rtc_dev_name);
 291                         /* Turn off update interrupts */
 292                         rc = ioctl(rtc_fd, RTC_UIE_OFF, 0);
 293                         if (rc == -1)
 294                                 warn(_("ioctl() to %s to turn off update interrupts failed"),
 295                                      rtc_dev_name);
 296                 } else if (errno == ENOTTY || errno == EINVAL) {
 297                         /* rtc ioctl interrupts are unimplemented */
 298                         ret = busywait_for_rtc_clock_tick(ctl, rtc_fd);
 299                 } else
 300                         warn(_("ioctl(%d, RTC_UIE_ON, 0) to %s failed"),
 301                              rtc_fd, rtc_dev_name);
 302         }
 303         return ret;
 304 }
 305
 306 static int read_hardware_clock_rtc(const struct hwclock_control *ctl,
 307                                    struct tm *tm)
 308 {
 309         int rtc_fd, rc;
 310
 311         rtc_fd = open_rtc_or_exit(ctl);
 312
 313         /* Read the RTC time/date, return answer via tm */
 314         rc = do_rtc_read_ioctl(rtc_fd, tm);
 315
 316         return rc;
 317 }
 318
 319 /*
 320  * Set the Hardware Clock to the broken down time <new_broken_time>. Use
 321  * ioctls to "rtc" device /dev/rtc.
 322  */
 323 static int set_hardware_clock_rtc(const struct hwclock_control *ctl,
 324                                   const struct tm *new_broken_time)
 325 {
 326         int rc = -1;
 327         int rtc_fd;
 328         char *ioctlname;
 329
 330         rtc_fd = open_rtc_or_exit(ctl);
 331
 332         ioctlname = "RTC_SET_TIME";
 333         rc = ioctl(rtc_fd, RTC_SET_TIME, new_broken_time);
 334
 335 #ifdef __sparc__
 336         if (rc == -1) {         /* sparc sbus */
 337                 struct sparc_rtc_time stm;
 338
 339                 stm.sec = new_broken_time->tm_sec;
 340                 stm.min = new_broken_time->tm_min;
 341                 stm.hour = new_broken_time->tm_hour;
 342                 stm.dom = new_broken_time->tm_mday;
 343                 stm.month = new_broken_time->tm_mon + 1;
 344                 stm.year = new_broken_time->tm_year + 1900;
 345                 stm.dow = new_broken_time->tm_wday + 1;
 346
 347                 ioctlname = "RTCSET";
 348                 rc = ioctl(rtc_fd, RTCSET, &stm);
 349         }
 350 #endif
 351
 352         if (rc == -1) {
 353                 warn(_("ioctl(%s) to %s to set the time failed"),
 354                         ioctlname, rtc_dev_name);
 355                 hwclock_exit(ctl, EXIT_FAILURE);
 356         }
 357
 358         if (ctl->verbose)
 359                 printf(_("ioctl(%s) was successful.\n"), ioctlname);
 360
 361         return 0;
 362 }
 363
 364 static int get_permissions_rtc(void)
 365 {
 366         return 0;
 367 }
 368
 369 static const char *get_device_path(void)
 370 {
 371         return rtc_dev_name;
 372 }
 373
 374 static struct clock_ops rtc_interface = {
 375         N_("Using the rtc interface to the clock."),
 376         get_permissions_rtc,
 377         read_hardware_clock_rtc,
 378         set_hardware_clock_rtc,
 379         synchronize_to_clock_tick_rtc,
 380         get_device_path,
 381 };
 382
 383 /* return &rtc if /dev/rtc can be opened, NULL otherwise */
 384 struct clock_ops *probe_for_rtc_clock(const struct hwclock_control *ctl)
 385 {
 386         const int rtc_fd = open_rtc(ctl);
 387
 388         if (rtc_fd < 0)
 389                 return NULL;
 390         return &rtc_interface;
 391 }
 392
 393 #ifdef __alpha__
 394 /*
 395  * Get the Hardware Clock epoch setting from the kernel.
 396  */
 397 int get_epoch_rtc(const struct hwclock_control *ctl, unsigned long *epoch_p)
 398 {
 399         int rtc_fd;
 400
 401         rtc_fd = open_rtc(ctl);
 402         if (rtc_fd < 0) {
 403                 warn(_("cannot open %s"), rtc_dev_name);
 404                 return 1;
 405         }
 406
 407         if (ioctl(rtc_fd, RTC_EPOCH_READ, epoch_p) == -1) {
 408                 warn(_("ioctl(%d, RTC_EPOCH_READ, epoch_p) to %s failed"),
 409                      rtc_fd, rtc_dev_name);
 410                 return 1;
 411         }
 412
 413         if (ctl->verbose)
 414                 printf(_("ioctl(%d, RTC_EPOCH_READ, epoch_p) to %s succeeded.\n"),
 415                        rtc_fd, rtc_dev_name);
 416
 417         return 0;
 418 }
 419
 420 /*
 421  * Set the Hardware Clock epoch in the kernel.
 422  */
 423 int set_epoch_rtc(const struct hwclock_control *ctl)
 424 {
 425         int rtc_fd;
 426         unsigned long epoch;
 427
 428         epoch = strtoul(ctl->epoch_option, NULL, 10);
 429
 430         /* There were no RTC clocks before 1900. */
 431         if (epoch < 1900 || epoch == ULONG_MAX) {
 432                 warnx(_("invalid epoch '%s'."), ctl->epoch_option);
 433                 return 1;
 434         }
 435
 436         rtc_fd = open_rtc(ctl);
 437         if (rtc_fd < 0) {
 438                 warn(_("cannot open %s"), rtc_dev_name);
 439                 return 1;
 440         }
 441
 442         if (ioctl(rtc_fd, RTC_EPOCH_SET, epoch) == -1) {
 443                 warn(_("ioctl(%d, RTC_EPOCH_SET, %lu) to %s failed"),
 444                      rtc_fd, epoch, rtc_dev_name);
 445                 return 1;
 446         }
 447
 448         if (ctl->verbose)
 449                 printf(_("ioctl(%d, RTC_EPOCH_SET, %lu) to %s succeeded.\n"),
 450                        rtc_fd, epoch, rtc_dev_name);
 451
 452         return 0;
 453 }
 454 #endif  /* __alpha__ */