void do_gettimeofday(struct timeval *tv) { unsigned long flags; unsigned long seq; unsigned long usec, sec; do { /* * Turn off IRQs when grabbing xtime_lock, so that * the sys_timer get_offset code doesn't have to handle it. */ seq = read_seqbegin_irqsave(&xtime_lock, flags); usec = get_timer_offset(); sec = xtime.tv_sec; usec += xtime.tv_nsec / NSEC_PER_USEC; } while (read_seqretry_irqrestore(&xtime_lock, seq, flags)); while (usec >= 1000000) { usec -= 1000000; sec++; } tv->tv_sec = sec; tv->tv_usec = usec; }
/* * This version of gettimeofday has near microsecond resolution. */ void do_gettimeofday (struct timeval *tv) { #if 0 /* DAVIDM later if possible */ extern volatile unsigned long lost_ticks; unsigned long lost; #endif unsigned long flags; unsigned long usec, sec; unsigned long seq; do { seq = read_seqbegin_irqsave(&xtime_lock, flags); #if 0 usec = mach_gettimeoffset ? mach_gettimeoffset () : 0; #else usec = 0; #endif #if 0 /* DAVIDM later if possible */ lost = lost_ticks; if (lost) usec += lost * (1000000/HZ); #endif 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; }
/* * This version of gettimeofday has microsecond resolution. */ void do_gettimeofday(struct timeval *tv) { unsigned long flags; unsigned long seq; unsigned delta, lost_ticks, usec, sec; do { seq = read_seqbegin_irqsave(&xtime_lock, flags); sec = xtime.tv_sec; usec = (xtime.tv_nsec / 1000); delta = tb_ticks_since(tb_last_stamp); #ifdef CONFIG_SMP /* As long as timebases are not in sync, gettimeofday can only * have jiffy resolution on SMP. */ if (!smp_tb_synchronized) delta = 0; #endif /* CONFIG_SMP */ lost_ticks = jiffies - wall_jiffies; } while (read_seqretry_irqrestore(&xtime_lock, seq, flags)); usec += mulhwu(tb_to_us, tb_ticks_per_jiffy * lost_ticks + delta); while (usec >= 1000000) { sec++; usec -= 1000000; } 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; }
void do_gettimeofday(struct timeval *tv) { unsigned long flags; unsigned long sec, usec, delta, seq; do { seq = read_seqbegin_irqsave(&xtime_lock, flags); delta = get_ccount() - last_ccount_stamp; sec = xtime.tv_sec; usec = (xtime.tv_nsec / NSEC_PER_USEC); } while (read_seqretry_irqrestore(&xtime_lock, seq, flags)); usec += (delta * CCOUNT_NSEC) / NSEC_PER_USEC; for (; usec >= 1000000; sec++, usec -= 1000000) ; 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)); while (usec >= 1000000) { usec -= 1000000; ++sec; } tv->tv_sec = sec; tv->tv_usec = usec; }
/* * This version of gettimeofday has near microsecond resolution. */ void do_gettimeofday(struct timeval *tv) { unsigned long flags; extern unsigned long wall_jiffies; unsigned long seq; unsigned long usec, sec, lost; unsigned long max_ntp_tick = tick_usec - tickadj; do { seq = read_seqbegin_irqsave(&xtime_lock, flags); usec = mach_gettimeoffset(); lost = jiffies - wall_jiffies; /* * If time_adjust is negative then NTP is slowing the clock * so make sure not to go into next possible interval. * Better to lose some accuracy than have time go backwards.. */ if (unlikely(time_adjust < 0)) { usec = min(usec, max_ntp_tick); if (lost) usec += lost * max_ntp_tick; } else if (unlikely(lost)) usec += lost * tick_usec; 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; }
/* * Stop the HZ tick on the current CPU. * Only cpu_idle may call this function. */ static void stop_hz_timer(void) { unsigned long flags; unsigned long seq, next; __u64 timer, todval; int cpu = smp_processor_id(); if (sysctl_hz_timer != 0) return; cpu_set(cpu, nohz_cpu_mask); /* * Leave the clock comparator set up for the next timer * tick if either rcu or a softirq is pending. */ if (rcu_needs_cpu(cpu) || local_softirq_pending()) { cpu_clear(cpu, nohz_cpu_mask); return; } /* * This cpu is going really idle. Set up the clock comparator * for the next event. */ next = next_timer_interrupt(); do { seq = read_seqbegin_irqsave(&xtime_lock, flags); timer = ((__u64) next) - ((__u64) jiffies) + jiffies_64; } while (read_seqretry_irqrestore(&xtime_lock, seq, flags)); todval = -1ULL; /* Be careful about overflows. */ if (timer < (-1ULL / CLK_TICKS_PER_JIFFY)) { timer = jiffies_timer_cc + timer * CLK_TICKS_PER_JIFFY; if (timer >= jiffies_timer_cc) todval = timer; } set_clock_comparator(todval); }
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; unsigned long volatile sec, usec, delta, seq; do { seq = read_seqbegin_irqsave(&xtime_lock, flags); sec = xtime.tv_sec; usec = (xtime.tv_nsec / NSEC_PER_USEC); delta = get_linux_timer() - get_ccount(); } while (read_seqretry_irqrestore(&xtime_lock, seq, flags)); usec += (((unsigned long) CCOUNT_PER_JIFFY - delta) * (unsigned long) NSEC_PER_CCOUNT) / NSEC_PER_USEC; for (; usec >= 1000000; sec++, usec -= 1000000) ; tv->tv_sec = sec; tv->tv_usec = usec; }
/* * This version of gettimeofday has near microsecond resolution. */ 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 = mach_gettimeoffset ? mach_gettimeoffset() : 0; 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; }