timekeeping.c 37 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442
  1. /*
  2. * linux/kernel/time/timekeeping.c
  3. *
  4. * Kernel timekeeping code and accessor functions
  5. *
  6. * This code was moved from linux/kernel/timer.c.
  7. * Please see that file for copyright and history logs.
  8. *
  9. */
  10. #include <linux/module.h>
  11. #include <linux/interrupt.h>
  12. #include <linux/percpu.h>
  13. #include <linux/init.h>
  14. #include <linux/mm.h>
  15. #include <linux/sched.h>
  16. #include <linux/syscore_ops.h>
  17. #include <linux/clocksource.h>
  18. #include <linux/jiffies.h>
  19. #include <linux/time.h>
  20. #include <linux/tick.h>
  21. #include <linux/stop_machine.h>
  22. /* Structure holding internal timekeeping values. */
  23. struct timekeeper {
  24. /* Current clocksource used for timekeeping. */
  25. struct clocksource *clock;
  26. /* NTP adjusted clock multiplier */
  27. u32 mult;
  28. /* The shift value of the current clocksource. */
  29. u32 shift;
  30. /* Number of clock cycles in one NTP interval. */
  31. cycle_t cycle_interval;
  32. /* Number of clock shifted nano seconds in one NTP interval. */
  33. u64 xtime_interval;
  34. /* shifted nano seconds left over when rounding cycle_interval */
  35. s64 xtime_remainder;
  36. /* Raw nano seconds accumulated per NTP interval. */
  37. u32 raw_interval;
  38. /* Current CLOCK_REALTIME time in seconds */
  39. u64 xtime_sec;
  40. /* Clock shifted nano seconds */
  41. u64 xtime_nsec;
  42. /* Difference between accumulated time and NTP time in ntp
  43. * shifted nano seconds. */
  44. s64 ntp_error;
  45. /* Shift conversion between clock shifted nano seconds and
  46. * ntp shifted nano seconds. */
  47. u32 ntp_error_shift;
  48. /*
  49. * wall_to_monotonic is what we need to add to xtime (or xtime corrected
  50. * for sub jiffie times) to get to monotonic time. Monotonic is pegged
  51. * at zero at system boot time, so wall_to_monotonic will be negative,
  52. * however, we will ALWAYS keep the tv_nsec part positive so we can use
  53. * the usual normalization.
  54. *
  55. * wall_to_monotonic is moved after resume from suspend for the
  56. * monotonic time not to jump. We need to add total_sleep_time to
  57. * wall_to_monotonic to get the real boot based time offset.
  58. *
  59. * - wall_to_monotonic is no longer the boot time, getboottime must be
  60. * used instead.
  61. */
  62. struct timespec wall_to_monotonic;
  63. /* Offset clock monotonic -> clock realtime */
  64. ktime_t offs_real;
  65. /* time spent in suspend */
  66. struct timespec total_sleep_time;
  67. /* Offset clock monotonic -> clock boottime */
  68. ktime_t offs_boot;
  69. /* The raw monotonic time for the CLOCK_MONOTONIC_RAW posix clock. */
  70. struct timespec raw_time;
  71. /* Seqlock for all timekeeper values */
  72. seqlock_t lock;
  73. };
  74. static struct timekeeper timekeeper;
  75. /*
  76. * This read-write spinlock protects us from races in SMP while
  77. * playing with xtime.
  78. */
  79. __cacheline_aligned_in_smp DEFINE_SEQLOCK(xtime_lock);
  80. /* flag for if timekeeping is suspended */
  81. int __read_mostly timekeeping_suspended;
  82. static inline void tk_normalize_xtime(struct timekeeper *tk)
  83. {
  84. while (tk->xtime_nsec >= ((u64)NSEC_PER_SEC << tk->shift)) {
  85. tk->xtime_nsec -= (u64)NSEC_PER_SEC << tk->shift;
  86. tk->xtime_sec++;
  87. }
  88. }
  89. static struct timespec tk_xtime(struct timekeeper *tk)
  90. {
  91. struct timespec ts;
  92. ts.tv_sec = tk->xtime_sec;
  93. ts.tv_nsec = (long)(tk->xtime_nsec >> tk->shift);
  94. return ts;
  95. }
  96. static void tk_set_xtime(struct timekeeper *tk, const struct timespec *ts)
  97. {
  98. tk->xtime_sec = ts->tv_sec;
  99. tk->xtime_nsec = (u64)ts->tv_nsec << tk->shift;
  100. }
  101. static void tk_xtime_add(struct timekeeper *tk, const struct timespec *ts)
  102. {
  103. tk->xtime_sec += ts->tv_sec;
  104. tk->xtime_nsec += (u64)ts->tv_nsec << tk->shift;
  105. tk_normalize_xtime(tk);
  106. }
  107. static void tk_set_wall_to_mono(struct timekeeper *tk, struct timespec wtm)
  108. {
  109. struct timespec tmp;
  110. /*
  111. * Verify consistency of: offset_real = -wall_to_monotonic
  112. * before modifying anything
  113. */
  114. set_normalized_timespec(&tmp, -tk->wall_to_monotonic.tv_sec,
  115. -tk->wall_to_monotonic.tv_nsec);
  116. WARN_ON_ONCE(tk->offs_real.tv64 != timespec_to_ktime(tmp).tv64);
  117. tk->wall_to_monotonic = wtm;
  118. set_normalized_timespec(&tmp, -wtm.tv_sec, -wtm.tv_nsec);
  119. tk->offs_real = timespec_to_ktime(tmp);
  120. }
  121. static void tk_set_sleep_time(struct timekeeper *tk, struct timespec t)
  122. {
  123. /* Verify consistency before modifying */
  124. WARN_ON_ONCE(tk->offs_boot.tv64 != timespec_to_ktime(tk->total_sleep_time).tv64);
  125. tk->total_sleep_time = t;
  126. tk->offs_boot = timespec_to_ktime(t);
  127. }
  128. /**
  129. * timekeeper_setup_internals - Set up internals to use clocksource clock.
  130. *
  131. * @clock: Pointer to clocksource.
  132. *
  133. * Calculates a fixed cycle/nsec interval for a given clocksource/adjustment
  134. * pair and interval request.
  135. *
  136. * Unless you're the timekeeping code, you should not be using this!
  137. */
  138. static void tk_setup_internals(struct timekeeper *tk, struct clocksource *clock)
  139. {
  140. cycle_t interval;
  141. u64 tmp, ntpinterval;
  142. struct clocksource *old_clock;
  143. old_clock = tk->clock;
  144. tk->clock = clock;
  145. clock->cycle_last = clock->read(clock);
  146. /* Do the ns -> cycle conversion first, using original mult */
  147. tmp = NTP_INTERVAL_LENGTH;
  148. tmp <<= clock->shift;
  149. ntpinterval = tmp;
  150. tmp += clock->mult/2;
  151. do_div(tmp, clock->mult);
  152. if (tmp == 0)
  153. tmp = 1;
  154. interval = (cycle_t) tmp;
  155. tk->cycle_interval = interval;
  156. /* Go back from cycles -> shifted ns */
  157. tk->xtime_interval = (u64) interval * clock->mult;
  158. tk->xtime_remainder = ntpinterval - tk->xtime_interval;
  159. tk->raw_interval =
  160. ((u64) interval * clock->mult) >> clock->shift;
  161. /* if changing clocks, convert xtime_nsec shift units */
  162. if (old_clock) {
  163. int shift_change = clock->shift - old_clock->shift;
  164. if (shift_change < 0)
  165. tk->xtime_nsec >>= -shift_change;
  166. else
  167. tk->xtime_nsec <<= shift_change;
  168. }
  169. tk->shift = clock->shift;
  170. tk->ntp_error = 0;
  171. tk->ntp_error_shift = NTP_SCALE_SHIFT - clock->shift;
  172. /*
  173. * The timekeeper keeps its own mult values for the currently
  174. * active clocksource. These value will be adjusted via NTP
  175. * to counteract clock drifting.
  176. */
  177. tk->mult = clock->mult;
  178. }
  179. /* Timekeeper helper functions. */
  180. static inline s64 timekeeping_get_ns(struct timekeeper *tk)
  181. {
  182. cycle_t cycle_now, cycle_delta;
  183. struct clocksource *clock;
  184. s64 nsec;
  185. /* read clocksource: */
  186. clock = tk->clock;
  187. cycle_now = clock->read(clock);
  188. /* calculate the delta since the last update_wall_time: */
  189. cycle_delta = (cycle_now - clock->cycle_last) & clock->mask;
  190. nsec = cycle_delta * tk->mult + tk->xtime_nsec;
  191. nsec >>= tk->shift;
  192. /* If arch requires, add in gettimeoffset() */
  193. return nsec + arch_gettimeoffset();
  194. }
  195. static inline s64 timekeeping_get_ns_raw(struct timekeeper *tk)
  196. {
  197. cycle_t cycle_now, cycle_delta;
  198. struct clocksource *clock;
  199. s64 nsec;
  200. /* read clocksource: */
  201. clock = tk->clock;
  202. cycle_now = clock->read(clock);
  203. /* calculate the delta since the last update_wall_time: */
  204. cycle_delta = (cycle_now - clock->cycle_last) & clock->mask;
  205. /* convert delta to nanoseconds. */
  206. nsec = clocksource_cyc2ns(cycle_delta, clock->mult, clock->shift);
  207. /* If arch requires, add in gettimeoffset() */
  208. return nsec + arch_gettimeoffset();
  209. }
  210. /* must hold write on timekeeper.lock */
  211. static void timekeeping_update(struct timekeeper *tk, bool clearntp)
  212. {
  213. struct timespec xt;
  214. if (clearntp) {
  215. tk->ntp_error = 0;
  216. ntp_clear();
  217. }
  218. xt = tk_xtime(tk);
  219. update_vsyscall(&xt, &tk->wall_to_monotonic, tk->clock, tk->mult);
  220. }
  221. /**
  222. * timekeeping_forward_now - update clock to the current time
  223. *
  224. * Forward the current clock to update its state since the last call to
  225. * update_wall_time(). This is useful before significant clock changes,
  226. * as it avoids having to deal with this time offset explicitly.
  227. */
  228. static void timekeeping_forward_now(struct timekeeper *tk)
  229. {
  230. cycle_t cycle_now, cycle_delta;
  231. struct clocksource *clock;
  232. s64 nsec;
  233. clock = tk->clock;
  234. cycle_now = clock->read(clock);
  235. cycle_delta = (cycle_now - clock->cycle_last) & clock->mask;
  236. clock->cycle_last = cycle_now;
  237. tk->xtime_nsec += cycle_delta * tk->mult;
  238. /* If arch requires, add in gettimeoffset() */
  239. tk->xtime_nsec += (u64)arch_gettimeoffset() << tk->shift;
  240. tk_normalize_xtime(tk);
  241. nsec = clocksource_cyc2ns(cycle_delta, clock->mult, clock->shift);
  242. timespec_add_ns(&tk->raw_time, nsec);
  243. }
  244. /**
  245. * getnstimeofday - Returns the time of day in a timespec
  246. * @ts: pointer to the timespec to be set
  247. *
  248. * Returns the time of day in a timespec.
  249. */
  250. void getnstimeofday(struct timespec *ts)
  251. {
  252. struct timekeeper *tk = &timekeeper;
  253. unsigned long seq;
  254. s64 nsecs = 0;
  255. WARN_ON(timekeeping_suspended);
  256. do {
  257. seq = read_seqbegin(&tk->lock);
  258. ts->tv_sec = tk->xtime_sec;
  259. nsecs = timekeeping_get_ns(tk);
  260. } while (read_seqretry(&tk->lock, seq));
  261. ts->tv_nsec = 0;
  262. timespec_add_ns(ts, nsecs);
  263. }
  264. EXPORT_SYMBOL(getnstimeofday);
  265. ktime_t ktime_get(void)
  266. {
  267. struct timekeeper *tk = &timekeeper;
  268. unsigned int seq;
  269. s64 secs, nsecs;
  270. WARN_ON(timekeeping_suspended);
  271. do {
  272. seq = read_seqbegin(&tk->lock);
  273. secs = tk->xtime_sec + tk->wall_to_monotonic.tv_sec;
  274. nsecs = timekeeping_get_ns(tk) + tk->wall_to_monotonic.tv_nsec;
  275. } while (read_seqretry(&tk->lock, seq));
  276. /*
  277. * Use ktime_set/ktime_add_ns to create a proper ktime on
  278. * 32-bit architectures without CONFIG_KTIME_SCALAR.
  279. */
  280. return ktime_add_ns(ktime_set(secs, 0), nsecs);
  281. }
  282. EXPORT_SYMBOL_GPL(ktime_get);
  283. /**
  284. * ktime_get_ts - get the monotonic clock in timespec format
  285. * @ts: pointer to timespec variable
  286. *
  287. * The function calculates the monotonic clock from the realtime
  288. * clock and the wall_to_monotonic offset and stores the result
  289. * in normalized timespec format in the variable pointed to by @ts.
  290. */
  291. void ktime_get_ts(struct timespec *ts)
  292. {
  293. struct timekeeper *tk = &timekeeper;
  294. struct timespec tomono;
  295. s64 nsec;
  296. unsigned int seq;
  297. WARN_ON(timekeeping_suspended);
  298. do {
  299. seq = read_seqbegin(&tk->lock);
  300. ts->tv_sec = tk->xtime_sec;
  301. nsec = timekeeping_get_ns(tk);
  302. tomono = tk->wall_to_monotonic;
  303. } while (read_seqretry(&tk->lock, seq));
  304. ts->tv_sec += tomono.tv_sec;
  305. ts->tv_nsec = 0;
  306. timespec_add_ns(ts, nsec + tomono.tv_nsec);
  307. }
  308. EXPORT_SYMBOL_GPL(ktime_get_ts);
  309. #ifdef CONFIG_NTP_PPS
  310. /**
  311. * getnstime_raw_and_real - get day and raw monotonic time in timespec format
  312. * @ts_raw: pointer to the timespec to be set to raw monotonic time
  313. * @ts_real: pointer to the timespec to be set to the time of day
  314. *
  315. * This function reads both the time of day and raw monotonic time at the
  316. * same time atomically and stores the resulting timestamps in timespec
  317. * format.
  318. */
  319. void getnstime_raw_and_real(struct timespec *ts_raw, struct timespec *ts_real)
  320. {
  321. struct timekeeper *tk = &timekeeper;
  322. unsigned long seq;
  323. s64 nsecs_raw, nsecs_real;
  324. WARN_ON_ONCE(timekeeping_suspended);
  325. do {
  326. seq = read_seqbegin(&tk->lock);
  327. *ts_raw = tk->raw_time;
  328. ts_real->tv_sec = tk->xtime_sec;
  329. ts_real->tv_nsec = 0;
  330. nsecs_raw = timekeeping_get_ns_raw(tk);
  331. nsecs_real = timekeeping_get_ns(tk);
  332. } while (read_seqretry(&tk->lock, seq));
  333. timespec_add_ns(ts_raw, nsecs_raw);
  334. timespec_add_ns(ts_real, nsecs_real);
  335. }
  336. EXPORT_SYMBOL(getnstime_raw_and_real);
  337. #endif /* CONFIG_NTP_PPS */
  338. /**
  339. * do_gettimeofday - Returns the time of day in a timeval
  340. * @tv: pointer to the timeval to be set
  341. *
  342. * NOTE: Users should be converted to using getnstimeofday()
  343. */
  344. void do_gettimeofday(struct timeval *tv)
  345. {
  346. struct timespec now;
  347. getnstimeofday(&now);
  348. tv->tv_sec = now.tv_sec;
  349. tv->tv_usec = now.tv_nsec/1000;
  350. }
  351. EXPORT_SYMBOL(do_gettimeofday);
  352. /**
  353. * do_settimeofday - Sets the time of day
  354. * @tv: pointer to the timespec variable containing the new time
  355. *
  356. * Sets the time of day to the new time and update NTP and notify hrtimers
  357. */
  358. int do_settimeofday(const struct timespec *tv)
  359. {
  360. struct timekeeper *tk = &timekeeper;
  361. struct timespec ts_delta, xt;
  362. unsigned long flags;
  363. if (!timespec_valid_strict(tv))
  364. return -EINVAL;
  365. write_seqlock_irqsave(&tk->lock, flags);
  366. timekeeping_forward_now(tk);
  367. xt = tk_xtime(tk);
  368. ts_delta.tv_sec = tv->tv_sec - xt.tv_sec;
  369. ts_delta.tv_nsec = tv->tv_nsec - xt.tv_nsec;
  370. tk_set_wall_to_mono(tk, timespec_sub(tk->wall_to_monotonic, ts_delta));
  371. tk_set_xtime(tk, tv);
  372. timekeeping_update(tk, true);
  373. write_sequnlock_irqrestore(&tk->lock, flags);
  374. /* signal hrtimers about time change */
  375. clock_was_set();
  376. return 0;
  377. }
  378. EXPORT_SYMBOL(do_settimeofday);
  379. /**
  380. * timekeeping_inject_offset - Adds or subtracts from the current time.
  381. * @tv: pointer to the timespec variable containing the offset
  382. *
  383. * Adds or subtracts an offset value from the current time.
  384. */
  385. int timekeeping_inject_offset(struct timespec *ts)
  386. {
  387. struct timekeeper *tk = &timekeeper;
  388. unsigned long flags;
  389. struct timespec tmp;
  390. int ret = 0;
  391. if ((unsigned long)ts->tv_nsec >= NSEC_PER_SEC)
  392. return -EINVAL;
  393. write_seqlock_irqsave(&tk->lock, flags);
  394. timekeeping_forward_now(tk);
  395. /* Make sure the proposed value is valid */
  396. tmp = timespec_add(tk_xtime(tk), *ts);
  397. if (!timespec_valid_strict(&tmp)) {
  398. ret = -EINVAL;
  399. goto error;
  400. }
  401. tk_xtime_add(tk, ts);
  402. tk_set_wall_to_mono(tk, timespec_sub(tk->wall_to_monotonic, *ts));
  403. error: /* even if we error out, we forwarded the time, so call update */
  404. timekeeping_update(tk, true);
  405. write_sequnlock_irqrestore(&tk->lock, flags);
  406. /* signal hrtimers about time change */
  407. clock_was_set();
  408. return ret;
  409. }
  410. EXPORT_SYMBOL(timekeeping_inject_offset);
  411. /**
  412. * change_clocksource - Swaps clocksources if a new one is available
  413. *
  414. * Accumulates current time interval and initializes new clocksource
  415. */
  416. static int change_clocksource(void *data)
  417. {
  418. struct timekeeper *tk = &timekeeper;
  419. struct clocksource *new, *old;
  420. unsigned long flags;
  421. new = (struct clocksource *) data;
  422. write_seqlock_irqsave(&tk->lock, flags);
  423. timekeeping_forward_now(tk);
  424. if (!new->enable || new->enable(new) == 0) {
  425. old = tk->clock;
  426. tk_setup_internals(tk, new);
  427. if (old->disable)
  428. old->disable(old);
  429. }
  430. timekeeping_update(tk, true);
  431. write_sequnlock_irqrestore(&tk->lock, flags);
  432. return 0;
  433. }
  434. /**
  435. * timekeeping_notify - Install a new clock source
  436. * @clock: pointer to the clock source
  437. *
  438. * This function is called from clocksource.c after a new, better clock
  439. * source has been registered. The caller holds the clocksource_mutex.
  440. */
  441. void timekeeping_notify(struct clocksource *clock)
  442. {
  443. struct timekeeper *tk = &timekeeper;
  444. if (tk->clock == clock)
  445. return;
  446. stop_machine(change_clocksource, clock, NULL);
  447. tick_clock_notify();
  448. }
  449. /**
  450. * ktime_get_real - get the real (wall-) time in ktime_t format
  451. *
  452. * returns the time in ktime_t format
  453. */
  454. ktime_t ktime_get_real(void)
  455. {
  456. struct timespec now;
  457. getnstimeofday(&now);
  458. return timespec_to_ktime(now);
  459. }
  460. EXPORT_SYMBOL_GPL(ktime_get_real);
  461. /**
  462. * getrawmonotonic - Returns the raw monotonic time in a timespec
  463. * @ts: pointer to the timespec to be set
  464. *
  465. * Returns the raw monotonic time (completely un-modified by ntp)
  466. */
  467. void getrawmonotonic(struct timespec *ts)
  468. {
  469. struct timekeeper *tk = &timekeeper;
  470. unsigned long seq;
  471. s64 nsecs;
  472. do {
  473. seq = read_seqbegin(&tk->lock);
  474. nsecs = timekeeping_get_ns_raw(tk);
  475. *ts = tk->raw_time;
  476. } while (read_seqretry(&tk->lock, seq));
  477. timespec_add_ns(ts, nsecs);
  478. }
  479. EXPORT_SYMBOL(getrawmonotonic);
  480. /**
  481. * timekeeping_valid_for_hres - Check if timekeeping is suitable for hres
  482. */
  483. int timekeeping_valid_for_hres(void)
  484. {
  485. struct timekeeper *tk = &timekeeper;
  486. unsigned long seq;
  487. int ret;
  488. do {
  489. seq = read_seqbegin(&tk->lock);
  490. ret = tk->clock->flags & CLOCK_SOURCE_VALID_FOR_HRES;
  491. } while (read_seqretry(&tk->lock, seq));
  492. return ret;
  493. }
  494. /**
  495. * timekeeping_max_deferment - Returns max time the clocksource can be deferred
  496. */
  497. u64 timekeeping_max_deferment(void)
  498. {
  499. struct timekeeper *tk = &timekeeper;
  500. unsigned long seq;
  501. u64 ret;
  502. do {
  503. seq = read_seqbegin(&tk->lock);
  504. ret = tk->clock->max_idle_ns;
  505. } while (read_seqretry(&tk->lock, seq));
  506. return ret;
  507. }
  508. /**
  509. * read_persistent_clock - Return time from the persistent clock.
  510. *
  511. * Weak dummy function for arches that do not yet support it.
  512. * Reads the time from the battery backed persistent clock.
  513. * Returns a timespec with tv_sec=0 and tv_nsec=0 if unsupported.
  514. *
  515. * XXX - Do be sure to remove it once all arches implement it.
  516. */
  517. void __attribute__((weak)) read_persistent_clock(struct timespec *ts)
  518. {
  519. ts->tv_sec = 0;
  520. ts->tv_nsec = 0;
  521. }
  522. /**
  523. * read_boot_clock - Return time of the system start.
  524. *
  525. * Weak dummy function for arches that do not yet support it.
  526. * Function to read the exact time the system has been started.
  527. * Returns a timespec with tv_sec=0 and tv_nsec=0 if unsupported.
  528. *
  529. * XXX - Do be sure to remove it once all arches implement it.
  530. */
  531. void __attribute__((weak)) read_boot_clock(struct timespec *ts)
  532. {
  533. ts->tv_sec = 0;
  534. ts->tv_nsec = 0;
  535. }
  536. /*
  537. * timekeeping_init - Initializes the clocksource and common timekeeping values
  538. */
  539. void __init timekeeping_init(void)
  540. {
  541. struct timekeeper *tk = &timekeeper;
  542. struct clocksource *clock;
  543. unsigned long flags;
  544. struct timespec now, boot, tmp;
  545. read_persistent_clock(&now);
  546. if (!timespec_valid_strict(&now)) {
  547. pr_warn("WARNING: Persistent clock returned invalid value!\n"
  548. " Check your CMOS/BIOS settings.\n");
  549. now.tv_sec = 0;
  550. now.tv_nsec = 0;
  551. }
  552. read_boot_clock(&boot);
  553. if (!timespec_valid_strict(&boot)) {
  554. pr_warn("WARNING: Boot clock returned invalid value!\n"
  555. " Check your CMOS/BIOS settings.\n");
  556. boot.tv_sec = 0;
  557. boot.tv_nsec = 0;
  558. }
  559. seqlock_init(&tk->lock);
  560. ntp_init();
  561. write_seqlock_irqsave(&tk->lock, flags);
  562. clock = clocksource_default_clock();
  563. if (clock->enable)
  564. clock->enable(clock);
  565. tk_setup_internals(tk, clock);
  566. tk_set_xtime(tk, &now);
  567. tk->raw_time.tv_sec = 0;
  568. tk->raw_time.tv_nsec = 0;
  569. if (boot.tv_sec == 0 && boot.tv_nsec == 0)
  570. boot = tk_xtime(tk);
  571. set_normalized_timespec(&tmp, -boot.tv_sec, -boot.tv_nsec);
  572. tk_set_wall_to_mono(tk, tmp);
  573. tmp.tv_sec = 0;
  574. tmp.tv_nsec = 0;
  575. tk_set_sleep_time(tk, tmp);
  576. write_sequnlock_irqrestore(&tk->lock, flags);
  577. }
  578. /* time in seconds when suspend began */
  579. static struct timespec timekeeping_suspend_time;
  580. /**
  581. * __timekeeping_inject_sleeptime - Internal function to add sleep interval
  582. * @delta: pointer to a timespec delta value
  583. *
  584. * Takes a timespec offset measuring a suspend interval and properly
  585. * adds the sleep offset to the timekeeping variables.
  586. */
  587. static void __timekeeping_inject_sleeptime(struct timekeeper *tk,
  588. struct timespec *delta)
  589. {
  590. if (!timespec_valid_strict(delta)) {
  591. printk(KERN_WARNING "__timekeeping_inject_sleeptime: Invalid "
  592. "sleep delta value!\n");
  593. return;
  594. }
  595. tk_xtime_add(tk, delta);
  596. tk_set_wall_to_mono(tk, timespec_sub(tk->wall_to_monotonic, *delta));
  597. tk_set_sleep_time(tk, timespec_add(tk->total_sleep_time, *delta));
  598. }
  599. /**
  600. * timekeeping_inject_sleeptime - Adds suspend interval to timeekeeping values
  601. * @delta: pointer to a timespec delta value
  602. *
  603. * This hook is for architectures that cannot support read_persistent_clock
  604. * because their RTC/persistent clock is only accessible when irqs are enabled.
  605. *
  606. * This function should only be called by rtc_resume(), and allows
  607. * a suspend offset to be injected into the timekeeping values.
  608. */
  609. void timekeeping_inject_sleeptime(struct timespec *delta)
  610. {
  611. struct timekeeper *tk = &timekeeper;
  612. unsigned long flags;
  613. struct timespec ts;
  614. /* Make sure we don't set the clock twice */
  615. read_persistent_clock(&ts);
  616. if (!(ts.tv_sec == 0 && ts.tv_nsec == 0))
  617. return;
  618. write_seqlock_irqsave(&tk->lock, flags);
  619. timekeeping_forward_now(tk);
  620. __timekeeping_inject_sleeptime(tk, delta);
  621. timekeeping_update(tk, true);
  622. write_sequnlock_irqrestore(&tk->lock, flags);
  623. /* signal hrtimers about time change */
  624. clock_was_set();
  625. }
  626. /**
  627. * timekeeping_resume - Resumes the generic timekeeping subsystem.
  628. *
  629. * This is for the generic clocksource timekeeping.
  630. * xtime/wall_to_monotonic/jiffies/etc are
  631. * still managed by arch specific suspend/resume code.
  632. */
  633. static void timekeeping_resume(void)
  634. {
  635. struct timekeeper *tk = &timekeeper;
  636. unsigned long flags;
  637. struct timespec ts;
  638. read_persistent_clock(&ts);
  639. clocksource_resume();
  640. write_seqlock_irqsave(&tk->lock, flags);
  641. if (timespec_compare(&ts, &timekeeping_suspend_time) > 0) {
  642. ts = timespec_sub(ts, timekeeping_suspend_time);
  643. __timekeeping_inject_sleeptime(tk, &ts);
  644. }
  645. /* re-base the last cycle value */
  646. tk->clock->cycle_last = tk->clock->read(tk->clock);
  647. tk->ntp_error = 0;
  648. timekeeping_suspended = 0;
  649. timekeeping_update(tk, false);
  650. write_sequnlock_irqrestore(&tk->lock, flags);
  651. touch_softlockup_watchdog();
  652. clockevents_notify(CLOCK_EVT_NOTIFY_RESUME, NULL);
  653. /* Resume hrtimers */
  654. hrtimers_resume();
  655. }
  656. static int timekeeping_suspend(void)
  657. {
  658. struct timekeeper *tk = &timekeeper;
  659. unsigned long flags;
  660. struct timespec delta, delta_delta;
  661. static struct timespec old_delta;
  662. read_persistent_clock(&timekeeping_suspend_time);
  663. write_seqlock_irqsave(&tk->lock, flags);
  664. timekeeping_forward_now(tk);
  665. timekeeping_suspended = 1;
  666. /*
  667. * To avoid drift caused by repeated suspend/resumes,
  668. * which each can add ~1 second drift error,
  669. * try to compensate so the difference in system time
  670. * and persistent_clock time stays close to constant.
  671. */
  672. delta = timespec_sub(tk_xtime(tk), timekeeping_suspend_time);
  673. delta_delta = timespec_sub(delta, old_delta);
  674. if (abs(delta_delta.tv_sec) >= 2) {
  675. /*
  676. * if delta_delta is too large, assume time correction
  677. * has occured and set old_delta to the current delta.
  678. */
  679. old_delta = delta;
  680. } else {
  681. /* Otherwise try to adjust old_system to compensate */
  682. timekeeping_suspend_time =
  683. timespec_add(timekeeping_suspend_time, delta_delta);
  684. }
  685. write_sequnlock_irqrestore(&tk->lock, flags);
  686. clockevents_notify(CLOCK_EVT_NOTIFY_SUSPEND, NULL);
  687. clocksource_suspend();
  688. return 0;
  689. }
  690. /* sysfs resume/suspend bits for timekeeping */
  691. static struct syscore_ops timekeeping_syscore_ops = {
  692. .resume = timekeeping_resume,
  693. .suspend = timekeeping_suspend,
  694. };
  695. static int __init timekeeping_init_ops(void)
  696. {
  697. register_syscore_ops(&timekeeping_syscore_ops);
  698. return 0;
  699. }
  700. device_initcall(timekeeping_init_ops);
  701. /*
  702. * If the error is already larger, we look ahead even further
  703. * to compensate for late or lost adjustments.
  704. */
  705. static __always_inline int timekeeping_bigadjust(struct timekeeper *tk,
  706. s64 error, s64 *interval,
  707. s64 *offset)
  708. {
  709. s64 tick_error, i;
  710. u32 look_ahead, adj;
  711. s32 error2, mult;
  712. /*
  713. * Use the current error value to determine how much to look ahead.
  714. * The larger the error the slower we adjust for it to avoid problems
  715. * with losing too many ticks, otherwise we would overadjust and
  716. * produce an even larger error. The smaller the adjustment the
  717. * faster we try to adjust for it, as lost ticks can do less harm
  718. * here. This is tuned so that an error of about 1 msec is adjusted
  719. * within about 1 sec (or 2^20 nsec in 2^SHIFT_HZ ticks).
  720. */
  721. error2 = tk->ntp_error >> (NTP_SCALE_SHIFT + 22 - 2 * SHIFT_HZ);
  722. error2 = abs(error2);
  723. for (look_ahead = 0; error2 > 0; look_ahead++)
  724. error2 >>= 2;
  725. /*
  726. * Now calculate the error in (1 << look_ahead) ticks, but first
  727. * remove the single look ahead already included in the error.
  728. */
  729. tick_error = ntp_tick_length() >> (tk->ntp_error_shift + 1);
  730. tick_error -= tk->xtime_interval >> 1;
  731. error = ((error - tick_error) >> look_ahead) + tick_error;
  732. /* Finally calculate the adjustment shift value. */
  733. i = *interval;
  734. mult = 1;
  735. if (error < 0) {
  736. error = -error;
  737. *interval = -*interval;
  738. *offset = -*offset;
  739. mult = -1;
  740. }
  741. for (adj = 0; error > i; adj++)
  742. error >>= 1;
  743. *interval <<= adj;
  744. *offset <<= adj;
  745. return mult << adj;
  746. }
  747. /*
  748. * Adjust the multiplier to reduce the error value,
  749. * this is optimized for the most common adjustments of -1,0,1,
  750. * for other values we can do a bit more work.
  751. */
  752. static void timekeeping_adjust(struct timekeeper *tk, s64 offset)
  753. {
  754. s64 error, interval = tk->cycle_interval;
  755. int adj;
  756. /*
  757. * The point of this is to check if the error is greater than half
  758. * an interval.
  759. *
  760. * First we shift it down from NTP_SHIFT to clocksource->shifted nsecs.
  761. *
  762. * Note we subtract one in the shift, so that error is really error*2.
  763. * This "saves" dividing(shifting) interval twice, but keeps the
  764. * (error > interval) comparison as still measuring if error is
  765. * larger than half an interval.
  766. *
  767. * Note: It does not "save" on aggravation when reading the code.
  768. */
  769. error = tk->ntp_error >> (tk->ntp_error_shift - 1);
  770. if (error > interval) {
  771. /*
  772. * We now divide error by 4(via shift), which checks if
  773. * the error is greater than twice the interval.
  774. * If it is greater, we need a bigadjust, if its smaller,
  775. * we can adjust by 1.
  776. */
  777. error >>= 2;
  778. /*
  779. * XXX - In update_wall_time, we round up to the next
  780. * nanosecond, and store the amount rounded up into
  781. * the error. This causes the likely below to be unlikely.
  782. *
  783. * The proper fix is to avoid rounding up by using
  784. * the high precision tk->xtime_nsec instead of
  785. * xtime.tv_nsec everywhere. Fixing this will take some
  786. * time.
  787. */
  788. if (likely(error <= interval))
  789. adj = 1;
  790. else
  791. adj = timekeeping_bigadjust(tk, error, &interval, &offset);
  792. } else {
  793. if (error < -interval) {
  794. /* See comment above, this is just switched for the negative */
  795. error >>= 2;
  796. if (likely(error >= -interval)) {
  797. adj = -1;
  798. interval = -interval;
  799. offset = -offset;
  800. } else {
  801. adj = timekeeping_bigadjust(tk, error, &interval, &offset);
  802. }
  803. } else {
  804. goto out_adjust;
  805. }
  806. }
  807. if (unlikely(tk->clock->maxadj &&
  808. (tk->mult + adj > tk->clock->mult + tk->clock->maxadj))) {
  809. printk_once(KERN_WARNING
  810. "Adjusting %s more than 11%% (%ld vs %ld)\n",
  811. tk->clock->name, (long)tk->mult + adj,
  812. (long)tk->clock->mult + tk->clock->maxadj);
  813. }
  814. /*
  815. * So the following can be confusing.
  816. *
  817. * To keep things simple, lets assume adj == 1 for now.
  818. *
  819. * When adj != 1, remember that the interval and offset values
  820. * have been appropriately scaled so the math is the same.
  821. *
  822. * The basic idea here is that we're increasing the multiplier
  823. * by one, this causes the xtime_interval to be incremented by
  824. * one cycle_interval. This is because:
  825. * xtime_interval = cycle_interval * mult
  826. * So if mult is being incremented by one:
  827. * xtime_interval = cycle_interval * (mult + 1)
  828. * Its the same as:
  829. * xtime_interval = (cycle_interval * mult) + cycle_interval
  830. * Which can be shortened to:
  831. * xtime_interval += cycle_interval
  832. *
  833. * So offset stores the non-accumulated cycles. Thus the current
  834. * time (in shifted nanoseconds) is:
  835. * now = (offset * adj) + xtime_nsec
  836. * Now, even though we're adjusting the clock frequency, we have
  837. * to keep time consistent. In other words, we can't jump back
  838. * in time, and we also want to avoid jumping forward in time.
  839. *
  840. * So given the same offset value, we need the time to be the same
  841. * both before and after the freq adjustment.
  842. * now = (offset * adj_1) + xtime_nsec_1
  843. * now = (offset * adj_2) + xtime_nsec_2
  844. * So:
  845. * (offset * adj_1) + xtime_nsec_1 =
  846. * (offset * adj_2) + xtime_nsec_2
  847. * And we know:
  848. * adj_2 = adj_1 + 1
  849. * So:
  850. * (offset * adj_1) + xtime_nsec_1 =
  851. * (offset * (adj_1+1)) + xtime_nsec_2
  852. * (offset * adj_1) + xtime_nsec_1 =
  853. * (offset * adj_1) + offset + xtime_nsec_2
  854. * Canceling the sides:
  855. * xtime_nsec_1 = offset + xtime_nsec_2
  856. * Which gives us:
  857. * xtime_nsec_2 = xtime_nsec_1 - offset
  858. * Which simplfies to:
  859. * xtime_nsec -= offset
  860. *
  861. * XXX - TODO: Doc ntp_error calculation.
  862. */
  863. tk->mult += adj;
  864. tk->xtime_interval += interval;
  865. tk->xtime_nsec -= offset;
  866. tk->ntp_error -= (interval - offset) << tk->ntp_error_shift;
  867. out_adjust:
  868. /*
  869. * It may be possible that when we entered this function, xtime_nsec
  870. * was very small. Further, if we're slightly speeding the clocksource
  871. * in the code above, its possible the required corrective factor to
  872. * xtime_nsec could cause it to underflow.
  873. *
  874. * Now, since we already accumulated the second, cannot simply roll
  875. * the accumulated second back, since the NTP subsystem has been
  876. * notified via second_overflow. So instead we push xtime_nsec forward
  877. * by the amount we underflowed, and add that amount into the error.
  878. *
  879. * We'll correct this error next time through this function, when
  880. * xtime_nsec is not as small.
  881. */
  882. if (unlikely((s64)tk->xtime_nsec < 0)) {
  883. s64 neg = -(s64)tk->xtime_nsec;
  884. tk->xtime_nsec = 0;
  885. tk->ntp_error += neg << tk->ntp_error_shift;
  886. }
  887. }
  888. /**
  889. * accumulate_nsecs_to_secs - Accumulates nsecs into secs
  890. *
  891. * Helper function that accumulates a the nsecs greater then a second
  892. * from the xtime_nsec field to the xtime_secs field.
  893. * It also calls into the NTP code to handle leapsecond processing.
  894. *
  895. */
  896. static inline void accumulate_nsecs_to_secs(struct timekeeper *tk)
  897. {
  898. u64 nsecps = (u64)NSEC_PER_SEC << tk->shift;
  899. while (tk->xtime_nsec >= nsecps) {
  900. int leap;
  901. tk->xtime_nsec -= nsecps;
  902. tk->xtime_sec++;
  903. /* Figure out if its a leap sec and apply if needed */
  904. leap = second_overflow(tk->xtime_sec);
  905. if (unlikely(leap)) {
  906. struct timespec ts;
  907. tk->xtime_sec += leap;
  908. ts.tv_sec = leap;
  909. ts.tv_nsec = 0;
  910. tk_set_wall_to_mono(tk,
  911. timespec_sub(tk->wall_to_monotonic, ts));
  912. clock_was_set_delayed();
  913. }
  914. }
  915. }
  916. /**
  917. * logarithmic_accumulation - shifted accumulation of cycles
  918. *
  919. * This functions accumulates a shifted interval of cycles into
  920. * into a shifted interval nanoseconds. Allows for O(log) accumulation
  921. * loop.
  922. *
  923. * Returns the unconsumed cycles.
  924. */
  925. static cycle_t logarithmic_accumulation(struct timekeeper *tk, cycle_t offset,
  926. u32 shift)
  927. {
  928. u64 raw_nsecs;
  929. /* If the offset is smaller then a shifted interval, do nothing */
  930. if (offset < tk->cycle_interval<<shift)
  931. return offset;
  932. /* Accumulate one shifted interval */
  933. offset -= tk->cycle_interval << shift;
  934. tk->clock->cycle_last += tk->cycle_interval << shift;
  935. tk->xtime_nsec += tk->xtime_interval << shift;
  936. accumulate_nsecs_to_secs(tk);
  937. /* Accumulate raw time */
  938. raw_nsecs = tk->raw_interval << shift;
  939. raw_nsecs += tk->raw_time.tv_nsec;
  940. if (raw_nsecs >= NSEC_PER_SEC) {
  941. u64 raw_secs = raw_nsecs;
  942. raw_nsecs = do_div(raw_secs, NSEC_PER_SEC);
  943. tk->raw_time.tv_sec += raw_secs;
  944. }
  945. tk->raw_time.tv_nsec = raw_nsecs;
  946. /* Accumulate error between NTP and clock interval */
  947. tk->ntp_error += ntp_tick_length() << shift;
  948. tk->ntp_error -= (tk->xtime_interval + tk->xtime_remainder) <<
  949. (tk->ntp_error_shift + shift);
  950. return offset;
  951. }
  952. /**
  953. * update_wall_time - Uses the current clocksource to increment the wall time
  954. *
  955. */
  956. static void update_wall_time(void)
  957. {
  958. struct clocksource *clock;
  959. struct timekeeper *tk = &timekeeper;
  960. cycle_t offset;
  961. int shift = 0, maxshift;
  962. unsigned long flags;
  963. s64 remainder;
  964. write_seqlock_irqsave(&tk->lock, flags);
  965. /* Make sure we're fully resumed: */
  966. if (unlikely(timekeeping_suspended))
  967. goto out;
  968. clock = tk->clock;
  969. #ifdef CONFIG_ARCH_USES_GETTIMEOFFSET
  970. offset = tk->cycle_interval;
  971. #else
  972. offset = (clock->read(clock) - clock->cycle_last) & clock->mask;
  973. #endif
  974. /* Check if there's really nothing to do */
  975. if (offset < tk->cycle_interval)
  976. goto out;
  977. /*
  978. * With NO_HZ we may have to accumulate many cycle_intervals
  979. * (think "ticks") worth of time at once. To do this efficiently,
  980. * we calculate the largest doubling multiple of cycle_intervals
  981. * that is smaller than the offset. We then accumulate that
  982. * chunk in one go, and then try to consume the next smaller
  983. * doubled multiple.
  984. */
  985. shift = ilog2(offset) - ilog2(tk->cycle_interval);
  986. shift = max(0, shift);
  987. /* Bound shift to one less than what overflows tick_length */
  988. maxshift = (64 - (ilog2(ntp_tick_length())+1)) - 1;
  989. shift = min(shift, maxshift);
  990. while (offset >= tk->cycle_interval) {
  991. offset = logarithmic_accumulation(tk, offset, shift);
  992. if (offset < tk->cycle_interval<<shift)
  993. shift--;
  994. }
  995. /* correct the clock when NTP error is too big */
  996. timekeeping_adjust(tk, offset);
  997. /*
  998. * Store only full nanoseconds into xtime_nsec after rounding
  999. * it up and add the remainder to the error difference.
  1000. * XXX - This is necessary to avoid small 1ns inconsistnecies caused
  1001. * by truncating the remainder in vsyscalls. However, it causes
  1002. * additional work to be done in timekeeping_adjust(). Once
  1003. * the vsyscall implementations are converted to use xtime_nsec
  1004. * (shifted nanoseconds), this can be killed.
  1005. */
  1006. remainder = tk->xtime_nsec & ((1ULL << tk->shift) - 1);
  1007. tk->xtime_nsec -= remainder;
  1008. tk->xtime_nsec += 1ULL << tk->shift;
  1009. tk->ntp_error += remainder << tk->ntp_error_shift;
  1010. /*
  1011. * Finally, make sure that after the rounding
  1012. * xtime_nsec isn't larger than NSEC_PER_SEC
  1013. */
  1014. accumulate_nsecs_to_secs(tk);
  1015. timekeeping_update(tk, false);
  1016. out:
  1017. write_sequnlock_irqrestore(&tk->lock, flags);
  1018. }
  1019. /**
  1020. * getboottime - Return the real time of system boot.
  1021. * @ts: pointer to the timespec to be set
  1022. *
  1023. * Returns the wall-time of boot in a timespec.
  1024. *
  1025. * This is based on the wall_to_monotonic offset and the total suspend
  1026. * time. Calls to settimeofday will affect the value returned (which
  1027. * basically means that however wrong your real time clock is at boot time,
  1028. * you get the right time here).
  1029. */
  1030. void getboottime(struct timespec *ts)
  1031. {
  1032. struct timekeeper *tk = &timekeeper;
  1033. struct timespec boottime = {
  1034. .tv_sec = tk->wall_to_monotonic.tv_sec +
  1035. tk->total_sleep_time.tv_sec,
  1036. .tv_nsec = tk->wall_to_monotonic.tv_nsec +
  1037. tk->total_sleep_time.tv_nsec
  1038. };
  1039. set_normalized_timespec(ts, -boottime.tv_sec, -boottime.tv_nsec);
  1040. }
  1041. EXPORT_SYMBOL_GPL(getboottime);
  1042. /**
  1043. * get_monotonic_boottime - Returns monotonic time since boot
  1044. * @ts: pointer to the timespec to be set
  1045. *
  1046. * Returns the monotonic time since boot in a timespec.
  1047. *
  1048. * This is similar to CLOCK_MONTONIC/ktime_get_ts, but also
  1049. * includes the time spent in suspend.
  1050. */
  1051. void get_monotonic_boottime(struct timespec *ts)
  1052. {
  1053. struct timekeeper *tk = &timekeeper;
  1054. struct timespec tomono, sleep;
  1055. s64 nsec;
  1056. unsigned int seq;
  1057. WARN_ON(timekeeping_suspended);
  1058. do {
  1059. seq = read_seqbegin(&tk->lock);
  1060. ts->tv_sec = tk->xtime_sec;
  1061. nsec = timekeeping_get_ns(tk);
  1062. tomono = tk->wall_to_monotonic;
  1063. sleep = tk->total_sleep_time;
  1064. } while (read_seqretry(&tk->lock, seq));
  1065. ts->tv_sec += tomono.tv_sec + sleep.tv_sec;
  1066. ts->tv_nsec = 0;
  1067. timespec_add_ns(ts, nsec + tomono.tv_nsec + sleep.tv_nsec);
  1068. }
  1069. EXPORT_SYMBOL_GPL(get_monotonic_boottime);
  1070. /**
  1071. * ktime_get_boottime - Returns monotonic time since boot in a ktime
  1072. *
  1073. * Returns the monotonic time since boot in a ktime
  1074. *
  1075. * This is similar to CLOCK_MONTONIC/ktime_get, but also
  1076. * includes the time spent in suspend.
  1077. */
  1078. ktime_t ktime_get_boottime(void)
  1079. {
  1080. struct timespec ts;
  1081. get_monotonic_boottime(&ts);
  1082. return timespec_to_ktime(ts);
  1083. }
  1084. EXPORT_SYMBOL_GPL(ktime_get_boottime);
  1085. /**
  1086. * monotonic_to_bootbased - Convert the monotonic time to boot based.
  1087. * @ts: pointer to the timespec to be converted
  1088. */
  1089. void monotonic_to_bootbased(struct timespec *ts)
  1090. {
  1091. struct timekeeper *tk = &timekeeper;
  1092. *ts = timespec_add(*ts, tk->total_sleep_time);
  1093. }
  1094. EXPORT_SYMBOL_GPL(monotonic_to_bootbased);
  1095. unsigned long get_seconds(void)
  1096. {
  1097. struct timekeeper *tk = &timekeeper;
  1098. return tk->xtime_sec;
  1099. }
  1100. EXPORT_SYMBOL(get_seconds);
  1101. struct timespec __current_kernel_time(void)
  1102. {
  1103. struct timekeeper *tk = &timekeeper;
  1104. return tk_xtime(tk);
  1105. }
  1106. struct timespec current_kernel_time(void)
  1107. {
  1108. struct timekeeper *tk = &timekeeper;
  1109. struct timespec now;
  1110. unsigned long seq;
  1111. do {
  1112. seq = read_seqbegin(&tk->lock);
  1113. now = tk_xtime(tk);
  1114. } while (read_seqretry(&tk->lock, seq));
  1115. return now;
  1116. }
  1117. EXPORT_SYMBOL(current_kernel_time);
  1118. struct timespec get_monotonic_coarse(void)
  1119. {
  1120. struct timekeeper *tk = &timekeeper;
  1121. struct timespec now, mono;
  1122. unsigned long seq;
  1123. do {
  1124. seq = read_seqbegin(&tk->lock);
  1125. now = tk_xtime(tk);
  1126. mono = tk->wall_to_monotonic;
  1127. } while (read_seqretry(&tk->lock, seq));
  1128. set_normalized_timespec(&now, now.tv_sec + mono.tv_sec,
  1129. now.tv_nsec + mono.tv_nsec);
  1130. return now;
  1131. }
  1132. /*
  1133. * The 64-bit jiffies value is not atomic - you MUST NOT read it
  1134. * without sampling the sequence number in xtime_lock.
  1135. * jiffies is defined in the linker script...
  1136. */
  1137. void do_timer(unsigned long ticks)
  1138. {
  1139. jiffies_64 += ticks;
  1140. update_wall_time();
  1141. calc_global_load(ticks);
  1142. }
  1143. /**
  1144. * get_xtime_and_monotonic_and_sleep_offset() - get xtime, wall_to_monotonic,
  1145. * and sleep offsets.
  1146. * @xtim: pointer to timespec to be set with xtime
  1147. * @wtom: pointer to timespec to be set with wall_to_monotonic
  1148. * @sleep: pointer to timespec to be set with time in suspend
  1149. */
  1150. void get_xtime_and_monotonic_and_sleep_offset(struct timespec *xtim,
  1151. struct timespec *wtom, struct timespec *sleep)
  1152. {
  1153. struct timekeeper *tk = &timekeeper;
  1154. unsigned long seq;
  1155. do {
  1156. seq = read_seqbegin(&tk->lock);
  1157. *xtim = tk_xtime(tk);
  1158. *wtom = tk->wall_to_monotonic;
  1159. *sleep = tk->total_sleep_time;
  1160. } while (read_seqretry(&tk->lock, seq));
  1161. }
  1162. #ifdef CONFIG_HIGH_RES_TIMERS
  1163. /**
  1164. * ktime_get_update_offsets - hrtimer helper
  1165. * @offs_real: pointer to storage for monotonic -> realtime offset
  1166. * @offs_boot: pointer to storage for monotonic -> boottime offset
  1167. *
  1168. * Returns current monotonic time and updates the offsets
  1169. * Called from hrtimer_interupt() or retrigger_next_event()
  1170. */
  1171. ktime_t ktime_get_update_offsets(ktime_t *offs_real, ktime_t *offs_boot)
  1172. {
  1173. struct timekeeper *tk = &timekeeper;
  1174. ktime_t now;
  1175. unsigned int seq;
  1176. u64 secs, nsecs;
  1177. do {
  1178. seq = read_seqbegin(&tk->lock);
  1179. secs = tk->xtime_sec;
  1180. nsecs = timekeeping_get_ns(tk);
  1181. *offs_real = tk->offs_real;
  1182. *offs_boot = tk->offs_boot;
  1183. } while (read_seqretry(&tk->lock, seq));
  1184. now = ktime_add_ns(ktime_set(secs, 0), nsecs);
  1185. now = ktime_sub(now, *offs_real);
  1186. return now;
  1187. }
  1188. #endif
  1189. /**
  1190. * ktime_get_monotonic_offset() - get wall_to_monotonic in ktime_t format
  1191. */
  1192. ktime_t ktime_get_monotonic_offset(void)
  1193. {
  1194. struct timekeeper *tk = &timekeeper;
  1195. unsigned long seq;
  1196. struct timespec wtom;
  1197. do {
  1198. seq = read_seqbegin(&tk->lock);
  1199. wtom = tk->wall_to_monotonic;
  1200. } while (read_seqretry(&tk->lock, seq));
  1201. return timespec_to_ktime(wtom);
  1202. }
  1203. EXPORT_SYMBOL_GPL(ktime_get_monotonic_offset);
  1204. /**
  1205. * xtime_update() - advances the timekeeping infrastructure
  1206. * @ticks: number of ticks, that have elapsed since the last call.
  1207. *
  1208. * Must be called with interrupts disabled.
  1209. */
  1210. void xtime_update(unsigned long ticks)
  1211. {
  1212. write_seqlock(&xtime_lock);
  1213. do_timer(ticks);
  1214. write_sequnlock(&xtime_lock);
  1215. }