sys/kern/subr_rtc.c

   1 /*-
   2  * Copyright (c) 1988 University of Utah.
   3  * Copyright (c) 1982, 1990, 1993
   4  *      The Regents of the University of California.
   5  * Copyright (c) 2011 The FreeBSD Foundation
   6  * All rights reserved.
   7  *
   8  * This code is derived from software contributed to Berkeley by
   9  * the Systems Programming Group of the University of Utah Computer
  10  * Science Department.
  11  *
  12  * Portions of this software were developed by Julien Ridoux at the University
  13  * of Melbourne under sponsorship from the FreeBSD Foundation.
  14  *
  15  * Redistribution and use in source and binary forms, with or without
  16  * modification, are permitted provided that the following conditions
  17  * are met:
  18  * 1. Redistributions of source code must retain the above copyright
  19  *    notice, this list of conditions and the following disclaimer.
  20  * 2. Redistributions in binary form must reproduce the above copyright
  21  *    notice, this list of conditions and the following disclaimer in the
  22  *    documentation and/or other materials provided with the distribution.
  23  * 3. Neither the name of the University nor the names of its contributors
  24  *    may be used to endorse or promote products derived from this software
  25  *    without specific prior written permission.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  37  * SUCH DAMAGE.
  38  *
  39  *      from: Utah $Hdr: clock.c 1.18 91/01/21$
  40  *      from: @(#)clock.c       8.2 (Berkeley) 1/12/94
  41  *      from: NetBSD: clock_subr.c,v 1.6 2001/07/07 17:04:02 thorpej Exp
  42  *      and
  43  *      from: src/sys/i386/isa/clock.c,v 1.176 2001/09/04
  44  */
  45
  46 /*
  47  * Helpers for time-of-day clocks. This is useful for architectures that need
  48  * support multiple models of such clocks, and generally serves to make the
  49  * code more machine-independent.
  50  * If the clock in question can also be used as a time counter, the driver
  51  * needs to initiate this.
  52  * This code is not yet used by all architectures.
  53  */
  54
  55 #include <sys/cdefs.h>
  56 __FBSDID("$FreeBSD$");
  57
  58 #include "opt_ffclock.h"
  59
  60 #include <sys/param.h>
  61 #include <sys/systm.h>
  62 #include <sys/kernel.h>
  63 #include <sys/bus.h>
  64 #include <sys/clock.h>
  65 #include <sys/lock.h>
  66 #include <sys/malloc.h>
  67 #include <sys/sx.h>
  68 #include <sys/sysctl.h>
  69 #include <sys/taskqueue.h>
  70 #ifdef FFCLOCK
  71 #include <sys/timeffc.h>
  72 #endif
  73 #include <sys/timetc.h>
  74
  75 #include "clock_if.h"
  76
  77 /* XXX: should be kern. now, it's no longer machdep.  */
  78 static int disable_rtc_set;
  79 SYSCTL_INT(_machdep, OID_AUTO, disable_rtc_set, CTLFLAG_RW, &disable_rtc_set,
  80     0, "Disallow adjusting time-of-day clock");
  81
  82 /*
  83  * An instance of a realtime clock.  A list of these tracks all the registered
  84  * clocks in the system.
  85  *
  86  * The resadj member is used to apply a "resolution adjustment" equal to half
  87  * the clock's resolution, which is useful mainly on clocks with a whole-second
  88  * resolution.  Because the clock truncates the fractional part, adding half the
  89  * resolution performs 4/5 rounding.  The same adjustment is applied to the
  90  * times returned from clock_gettime(), because the fraction returned will
  91  * always be zero, but on average the actual fraction at the time of the call
  92  * should be about .5.
  93  */
  94 struct rtc_instance {
  95         device_t        clockdev;
  96         int             resolution;
  97         int             flags;
  98         u_int           schedns;
  99         struct timespec resadj;
 100         struct timeout_task
 101                         stask;
 102         LIST_ENTRY(rtc_instance)
 103                         rtc_entries;
 104 };
 105
 106 /*
 107  * Clocks are updated using a task running on taskqueue_thread.
 108  */
 109 static void settime_task_func(void *arg, int pending);
 110
 111 /*
 112  * Registered clocks are kept in a list which is sorted by resolution; the more
 113  * accurate clocks get the first shot at providing the time.
 114  */
 115 LIST_HEAD(rtc_listhead, rtc_instance);
 116 static struct rtc_listhead rtc_list = LIST_HEAD_INITIALIZER(rtc_list);
 117 static struct sx rtc_list_lock;
 118 SX_SYSINIT(rtc_list_lock_init, &rtc_list_lock, "rtc list");
 119
 120 /*
 121  * On the task thread, invoke the clock_settime() method of the clock.  Do so
 122  * holding no locks, so that clock drivers are free to do whatever kind of
 123  * locking or sleeping they need to.
 124  */
 125 static void
 126 settime_task_func(void *arg, int pending)
 127 {
 128         struct timespec ts;
 129         struct rtc_instance *rtc;
 130
 131         rtc = arg;
 132         if (!(rtc->flags & CLOCKF_SETTIME_NO_TS)) {
 133                 getnanotime(&ts);
 134                 if (!(rtc->flags & CLOCKF_SETTIME_NO_ADJ)) {
 135                         ts.tv_sec -= utc_offset();
 136                         timespecadd(&ts, &rtc->resadj);
 137                 }
 138         } else {
 139                 ts.tv_sec  = 0;
 140                 ts.tv_nsec = 0;
 141         }
 142         CLOCK_SETTIME(rtc->clockdev, &ts);
 143 }
 144
 145 void
 146 clock_register_flags(device_t clockdev, long resolution, int flags)
 147 {
 148         struct rtc_instance *rtc, *newrtc;
 149
 150         newrtc = malloc(sizeof(*newrtc), M_DEVBUF, M_WAITOK);
 151         newrtc->clockdev = clockdev;
 152         newrtc->resolution = (int)resolution;
 153         newrtc->flags = flags;
 154         newrtc->schedns = 0;
 155         newrtc->resadj.tv_sec  = newrtc->resolution / 2 / 1000000;
 156         newrtc->resadj.tv_nsec = newrtc->resolution / 2 % 1000000 * 1000;
 157         TIMEOUT_TASK_INIT(taskqueue_thread, &newrtc->stask, 0,
 158                     settime_task_func, newrtc);
 159
 160         sx_xlock(&rtc_list_lock);
 161         if (LIST_EMPTY(&rtc_list)) {
 162                 LIST_INSERT_HEAD(&rtc_list, newrtc, rtc_entries);
 163         } else {
 164                 LIST_FOREACH(rtc, &rtc_list, rtc_entries) {
 165                         if (rtc->resolution > newrtc->resolution) {
 166                                 LIST_INSERT_BEFORE(rtc, newrtc, rtc_entries);
 167                                 break;
 168                         } else if (LIST_NEXT(rtc, rtc_entries) == NULL) {
 169                                 LIST_INSERT_AFTER(rtc, newrtc, rtc_entries);
 170                                 break;
 171                         }
 172                 }
 173         }
 174         sx_xunlock(&rtc_list_lock);
 175
 176         device_printf(clockdev,
 177             "registered as a time-of-day clock, resolution %d.%6.6ds\n",
 178             newrtc->resolution / 1000000, newrtc->resolution % 1000000);
 179 }
 180
 181 void
 182 clock_register(device_t dev, long res)
 183 {
 184
 185         clock_register_flags(dev, res, 0);
 186 }
 187
 188 void
 189 clock_unregister(device_t clockdev)
 190 {
 191         struct rtc_instance *rtc, *tmp;
 192
 193         sx_xlock(&rtc_list_lock);
 194         LIST_FOREACH_SAFE(rtc, &rtc_list, rtc_entries, tmp) {
 195                 if (rtc->clockdev == clockdev) {
 196                         LIST_REMOVE(rtc, rtc_entries);
 197                         break;
 198                 }
 199         }
 200         sx_xunlock(&rtc_list_lock);
 201         if (rtc != NULL) {
 202                 taskqueue_cancel_timeout(taskqueue_thread, &rtc->stask, NULL);
 203                 taskqueue_drain_timeout(taskqueue_thread, &rtc->stask);
 204                 free(rtc, M_DEVBUF);
 205         }
 206 }
 207
 208 void
 209 clock_schedule(device_t clockdev, u_int offsetns)
 210 {
 211         struct rtc_instance *rtc;
 212
 213         sx_xlock(&rtc_list_lock);
 214         LIST_FOREACH(rtc, &rtc_list, rtc_entries) {
 215                 if (rtc->clockdev == clockdev) {
 216                         rtc->schedns = offsetns;
 217                         break;
 218                 }
 219         }
 220         sx_xunlock(&rtc_list_lock);
 221 }
 222
 223 /*
 224  * Initialize the system time.  Must be called from a context which does not
 225  * restrict any locking or sleeping that clock drivers may need to do.
 226  *
 227  * First attempt to get the time from a registered realtime clock.  The clocks
 228  * are queried in order of resolution until one provides the time.  If no clock
 229  * can provide the current time, use the 'base' time provided by the caller, if
 230  * non-zero.  The 'base' time is potentially highly inaccurate, such as the last
 231  * known good value of the system clock, or even a filesystem last-updated
 232  * timestamp.  It is used to prevent system time from appearing to move
 233  * backwards in logs.
 234  */
 235 void
 236 inittodr(time_t base)
 237 {
 238         struct timespec ts;
 239         struct rtc_instance *rtc;
 240         int error;
 241
 242         error = ENXIO;
 243         sx_xlock(&rtc_list_lock);
 244         LIST_FOREACH(rtc, &rtc_list, rtc_entries) {
 245                 if ((error = CLOCK_GETTIME(rtc->clockdev, &ts)) != 0)
 246                         continue;
 247                 if (ts.tv_sec < 0 || ts.tv_nsec < 0) {
 248                         error = EINVAL;
 249                         continue;
 250                 }
 251                 if (!(rtc->flags & CLOCKF_GETTIME_NO_ADJ)) {
 252                         timespecadd(&ts, &rtc->resadj);
 253                         ts.tv_sec += utc_offset();
 254                 }
 255                 if (bootverbose)
 256                         device_printf(rtc->clockdev,
 257                             "providing initial system time\n");
 258                 break;
 259         }
 260         sx_xunlock(&rtc_list_lock);
 261
 262         /*
 263          * Do not report errors from each clock; it is expected that some clocks
 264          * cannot provide results in some situations.  Only report problems when
 265          * no clocks could provide the time.
 266          */
 267         if (error != 0) {
 268                 switch (error) {
 269                 case ENXIO:
 270                         printf("Warning: no time-of-day clock registered, ");
 271                         break;
 272                 case EINVAL:
 273                         printf("Warning: bad time from time-of-day clock, ");
 274                         break;
 275                 default:
 276                         printf("Error reading time-of-day clock (%d), ", error);
 277                         break;
 278                 }
 279                 printf("system time will not be set accurately\n");
 280                 ts.tv_sec  = (base > 0) ? base : -1;
 281                 ts.tv_nsec = 0;
 282         }
 283
 284         if (ts.tv_sec >= 0) {
 285                 tc_setclock(&ts);
 286 #ifdef FFCLOCK
 287                 ffclock_reset_clock(&ts);
 288 #endif
 289         }
 290 }
 291
 292 /*
 293  * Write system time back to all registered clocks, unless disabled by admin.
 294  * This can be called from a context that restricts locking and/or sleeping; the
 295  * actual updating is done asynchronously on a task thread.
 296  */
 297 void
 298 resettodr(void)
 299 {
 300         struct timespec now;
 301         struct rtc_instance *rtc;
 302         sbintime_t sbt;
 303         long waitns;
 304
 305         if (disable_rtc_set)
 306                 return;
 307
 308         sx_xlock(&rtc_list_lock);
 309         LIST_FOREACH(rtc, &rtc_list, rtc_entries) {
 310                 if (rtc->schedns != 0) {
 311                         getnanotime(&now);
 312                         waitns = rtc->schedns - now.tv_nsec;
 313                         if (waitns < 0)
 314                                 waitns += 1000000000;
 315                         sbt = nstosbt(waitns);
 316                 } else
 317                         sbt = 0;
 318                 taskqueue_enqueue_timeout_sbt(taskqueue_thread,
 319                     &rtc->stask, -sbt, 0, C_PREL(31));
 320         }
 321         sx_xunlock(&rtc_list_lock);
 322 }