void do_settimeofday (struct timeval *tv) { write_lock_irq(&xtime_lock); { /* * This is revolting. We need to set "xtime" correctly. However, the value * in this location is the value at the most recent update of wall time. * Discover what correction gettimeofday would have done, and then undo * it! */ tv->tv_usec -= gettimeoffset(); while (tv->tv_usec < 0) { tv->tv_usec += 1000000; tv->tv_sec--; } xtime = *tv; time_adjust = 0; /* stop active adjtime() */ time_status |= STA_UNSYNC; time_maxerror = NTP_PHASE_LIMIT; time_esterror = NTP_PHASE_LIMIT; } write_unlock_irq(&xtime_lock); }
int do_settimeofday(struct timespec *tv) { time_t wtm_sec, sec = tv->tv_sec; long wtm_nsec, nsec = tv->tv_nsec; if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC) return -EINVAL; write_seqlock_irq(&xtime_lock); /* * This is revolting. We need to set the xtime.tv_usec * correctly. However, the value in this location is * is value at the last tick. * Discover what correction gettimeofday * would have done, and then undo it! */ nsec -= (gettimeoffset() * NSEC_PER_USEC); wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec); wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec); set_normalized_timespec(&xtime, sec, nsec); set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec); ntp_clear(); write_sequnlock_irq(&xtime_lock); clock_was_set(); return 0; }
void do_gettimeofday (struct timeval *tv) { unsigned long flags, usec, sec, old; read_lock_irqsave(&xtime_lock, flags); { usec = gettimeoffset(); /* * Ensure time never goes backwards, even when ITC on different CPUs are * not perfectly synchronized. */ do { old = last_time_offset; if (usec <= old) { usec = old; break; } } while (cmpxchg(&last_time_offset, old, usec) != old); sec = xtime.tv_sec; usec += xtime.tv_usec; } read_unlock_irqrestore(&xtime_lock, flags); while (usec >= 1000000) { usec -= 1000000; ++sec; } tv->tv_sec = sec; tv->tv_usec = usec; }
void do_gettimeofday(struct timeval *tv) { unsigned long flags; unsigned long lost, seq; unsigned long usec, sec; do { seq = read_seqbegin_irqsave(&xtime_lock, flags); usec = gettimeoffset(); lost = jiffies - wall_jiffies; if (lost) usec += lost * (1000000 / HZ); sec = xtime.tv_sec; usec += (xtime.tv_nsec / 1000); } while (read_seqretry_irqrestore(&xtime_lock, seq, flags)); while (usec >= 1000000) { usec -= 1000000; sec++; } tv->tv_sec = sec; tv->tv_usec = usec; }
void do_gettimeofday (struct timeval *tv) { unsigned long flags, seq, usec, sec; do { seq = read_seqbegin_irqsave(&xtime_lock, flags); usec = gettimeoffset(); sec = xtime.tv_sec; usec += (xtime.tv_nsec / 1000); } while (read_seqretry_irqrestore(&xtime_lock, seq, flags)); if (unlikely(usec > LONG_MAX)) { /* This can happen if the gettimeoffset adjustment is * negative and xtime.tv_nsec is smaller than the * adjustment */ printk(KERN_ERR "do_gettimeofday() spurious xtime.tv_nsec of %ld\n", usec); usec += USEC_PER_SEC; --sec; /* This should never happen, it means the negative * time adjustment was more than a second, so there's * something seriously wrong */ BUG_ON(usec > LONG_MAX); } while (usec >= USEC_PER_SEC) { usec -= USEC_PER_SEC; ++sec; } tv->tv_sec = sec; tv->tv_usec = usec; }
int do_settimeofday(struct timespec *tv) { time_t wtm_sec, sec = tv->tv_sec; long wtm_nsec, nsec = tv->tv_nsec; if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC) return -EINVAL; write_seqlock_irq(&xtime_lock); /* * This is revolting. We need to set the xtime.tv_usec * correctly. However, the value in this location is * is value at the last tick. * Discover what correction gettimeofday * would have done, and then undo it! */ nsec -= (gettimeoffset() * 1000); wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec); wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec); set_normalized_timespec(&xtime, sec, nsec); set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec); time_adjust = 0; /* stop active adjtime() */ time_status |= STA_UNSYNC; time_maxerror = NTP_PHASE_LIMIT; time_esterror = NTP_PHASE_LIMIT; write_sequnlock_irq(&xtime_lock); clock_was_set(); /* * rtc_set() busy-waits up to a second (the next tick of the RTC) * for completion of the write. * We release xtime_lock before updating the RTC so as not to * lock out the timer_interrupt() routine which also acquires * xtime_lock. Locking out timer_interrupt() loses ticks! */ #ifdef CONFIG_BFIN_HAVE_RTC rtc_set(sec); #endif return 0; }
void do_gettimeofday (struct timeval *tv) { unsigned long flags, seq, usec, sec; do { seq = read_seqbegin_irqsave(&xtime_lock, flags); usec = gettimeoffset(); sec = xtime.tv_sec; usec += (xtime.tv_nsec / 1000); } while (read_seqretry_irqrestore(&xtime_lock, seq, flags)); while (usec >= 1000000) { usec -= 1000000; ++sec; } tv->tv_sec = sec; tv->tv_usec = usec; }
void do_gettimeofday(struct timeval *tv) { unsigned long flags; unsigned long seq; unsigned long usec, sec; do { seq = read_seqbegin_irqsave(&xtime_lock, flags); usec = gettimeoffset(); sec = xtime.tv_sec; usec += (xtime.tv_nsec / NSEC_PER_USEC); } while (read_seqretry_irqrestore(&xtime_lock, seq, flags)); while (usec >= USEC_PER_SEC) { usec -= USEC_PER_SEC; sec++; } tv->tv_sec = sec; tv->tv_usec = usec; }
void do_gettimeofday (struct timeval *tv) { unsigned long flags, usec, sec; read_lock_irqsave(&xtime_lock, flags); { usec = gettimeoffset(); sec = xtime.tv_sec; usec += xtime.tv_usec; } read_unlock_irqrestore(&xtime_lock, flags); while (usec >= 1000000) { usec -= 1000000; ++sec; } tv->tv_sec = sec; tv->tv_usec = usec; }
static unsigned long do_gettimeoffset(void) { return gettimeoffset (); }