pvclock.c 4.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170
  1. /* paravirtual clock -- common code used by kvm/xen
  2. This program is free software; you can redistribute it and/or modify
  3. it under the terms of the GNU General Public License as published by
  4. the Free Software Foundation; either version 2 of the License, or
  5. (at your option) any later version.
  6. This program is distributed in the hope that it will be useful,
  7. but WITHOUT ANY WARRANTY; without even the implied warranty of
  8. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  9. GNU General Public License for more details.
  10. You should have received a copy of the GNU General Public License
  11. along with this program; if not, write to the Free Software
  12. Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  13. */
  14. #include <linux/kernel.h>
  15. #include <linux/percpu.h>
  16. #include <linux/notifier.h>
  17. #include <linux/sched.h>
  18. #include <linux/gfp.h>
  19. #include <linux/bootmem.h>
  20. #include <asm/fixmap.h>
  21. #include <asm/pvclock.h>
  22. static u8 valid_flags __read_mostly = 0;
  23. void pvclock_set_flags(u8 flags)
  24. {
  25. valid_flags = flags;
  26. }
  27. unsigned long pvclock_tsc_khz(struct pvclock_vcpu_time_info *src)
  28. {
  29. u64 pv_tsc_khz = 1000000ULL << 32;
  30. do_div(pv_tsc_khz, src->tsc_to_system_mul);
  31. if (src->tsc_shift < 0)
  32. pv_tsc_khz <<= -src->tsc_shift;
  33. else
  34. pv_tsc_khz >>= src->tsc_shift;
  35. return pv_tsc_khz;
  36. }
  37. void pvclock_touch_watchdogs(void)
  38. {
  39. touch_softlockup_watchdog_sync();
  40. clocksource_touch_watchdog();
  41. rcu_cpu_stall_reset();
  42. reset_hung_task_detector();
  43. }
  44. static atomic64_t last_value = ATOMIC64_INIT(0);
  45. void pvclock_resume(void)
  46. {
  47. atomic64_set(&last_value, 0);
  48. }
  49. u8 pvclock_read_flags(struct pvclock_vcpu_time_info *src)
  50. {
  51. unsigned version;
  52. cycle_t ret;
  53. u8 flags;
  54. do {
  55. version = __pvclock_read_cycles(src, &ret, &flags);
  56. /* Make sure that the version double-check is last. */
  57. smp_rmb();
  58. } while ((src->version & 1) || version != src->version);
  59. return flags & valid_flags;
  60. }
  61. cycle_t pvclock_clocksource_read(struct pvclock_vcpu_time_info *src)
  62. {
  63. unsigned version;
  64. cycle_t ret;
  65. u64 last;
  66. u8 flags;
  67. do {
  68. version = __pvclock_read_cycles(src, &ret, &flags);
  69. /* Make sure that the version double-check is last. */
  70. smp_rmb();
  71. } while ((src->version & 1) || version != src->version);
  72. if (unlikely((flags & PVCLOCK_GUEST_STOPPED) != 0)) {
  73. src->flags &= ~PVCLOCK_GUEST_STOPPED;
  74. pvclock_touch_watchdogs();
  75. }
  76. if ((valid_flags & PVCLOCK_TSC_STABLE_BIT) &&
  77. (flags & PVCLOCK_TSC_STABLE_BIT))
  78. return ret;
  79. /*
  80. * Assumption here is that last_value, a global accumulator, always goes
  81. * forward. If we are less than that, we should not be much smaller.
  82. * We assume there is an error marging we're inside, and then the correction
  83. * does not sacrifice accuracy.
  84. *
  85. * For reads: global may have changed between test and return,
  86. * but this means someone else updated poked the clock at a later time.
  87. * We just need to make sure we are not seeing a backwards event.
  88. *
  89. * For updates: last_value = ret is not enough, since two vcpus could be
  90. * updating at the same time, and one of them could be slightly behind,
  91. * making the assumption that last_value always go forward fail to hold.
  92. */
  93. last = atomic64_read(&last_value);
  94. do {
  95. if (ret < last)
  96. return last;
  97. last = atomic64_cmpxchg(&last_value, last, ret);
  98. } while (unlikely(last != ret));
  99. return ret;
  100. }
  101. void pvclock_read_wallclock(struct pvclock_wall_clock *wall_clock,
  102. struct pvclock_vcpu_time_info *vcpu_time,
  103. struct timespec *ts)
  104. {
  105. u32 version;
  106. u64 delta;
  107. struct timespec now;
  108. /* get wallclock at system boot */
  109. do {
  110. version = wall_clock->version;
  111. rmb(); /* fetch version before time */
  112. now.tv_sec = wall_clock->sec;
  113. now.tv_nsec = wall_clock->nsec;
  114. rmb(); /* fetch time before checking version */
  115. } while ((wall_clock->version & 1) || (version != wall_clock->version));
  116. delta = pvclock_clocksource_read(vcpu_time); /* time since system boot */
  117. delta += now.tv_sec * (u64)NSEC_PER_SEC + now.tv_nsec;
  118. now.tv_nsec = do_div(delta, NSEC_PER_SEC);
  119. now.tv_sec = delta;
  120. set_normalized_timespec(ts, now.tv_sec, now.tv_nsec);
  121. }
  122. #ifdef CONFIG_X86_64
  123. /*
  124. * Initialize the generic pvclock vsyscall state. This will allocate
  125. * a/some page(s) for the per-vcpu pvclock information, set up a
  126. * fixmap mapping for the page(s)
  127. */
  128. int __init pvclock_init_vsyscall(struct pvclock_vsyscall_time_info *i,
  129. int size)
  130. {
  131. int idx;
  132. WARN_ON (size != PVCLOCK_VSYSCALL_NR_PAGES*PAGE_SIZE);
  133. for (idx = 0; idx <= (PVCLOCK_FIXMAP_END-PVCLOCK_FIXMAP_BEGIN); idx++) {
  134. __set_fixmap(PVCLOCK_FIXMAP_BEGIN + idx,
  135. __pa(i) + (idx*PAGE_SIZE),
  136. PAGE_KERNEL_VVAR);
  137. }
  138. return 0;
  139. }
  140. #endif