time.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745
  1. /*
  2. * linux/kernel/time.c
  3. *
  4. * Copyright (C) 1991, 1992 Linus Torvalds
  5. *
  6. * This file contains the interface functions for the various
  7. * time related system calls: time, stime, gettimeofday, settimeofday,
  8. * adjtime
  9. */
  10. /*
  11. * Modification history kernel/time.c
  12. *
  13. * 1993-09-02 Philip Gladstone
  14. * Created file with time related functions from sched.c and adjtimex()
  15. * 1993-10-08 Torsten Duwe
  16. * adjtime interface update and CMOS clock write code
  17. * 1995-08-13 Torsten Duwe
  18. * kernel PLL updated to 1994-12-13 specs (rfc-1589)
  19. * 1999-01-16 Ulrich Windl
  20. * Introduced error checking for many cases in adjtimex().
  21. * Updated NTP code according to technical memorandum Jan '96
  22. * "A Kernel Model for Precision Timekeeping" by Dave Mills
  23. * Allow time_constant larger than MAXTC(6) for NTP v4 (MAXTC == 10)
  24. * (Even though the technical memorandum forbids it)
  25. * 2004-07-14 Christoph Lameter
  26. * Added getnstimeofday to allow the posix timer functions to return
  27. * with nanosecond accuracy
  28. */
  29. #include <linux/module.h>
  30. #include <linux/timex.h>
  31. #include <linux/capability.h>
  32. #include <linux/errno.h>
  33. #include <linux/smp_lock.h>
  34. #include <linux/syscalls.h>
  35. #include <linux/security.h>
  36. #include <linux/fs.h>
  37. #include <linux/module.h>
  38. #include <asm/uaccess.h>
  39. #include <asm/unistd.h>
  40. /*
  41. * The timezone where the local system is located. Used as a default by some
  42. * programs who obtain this value by using gettimeofday.
  43. */
  44. struct timezone sys_tz;
  45. EXPORT_SYMBOL(sys_tz);
  46. #ifdef __ARCH_WANT_SYS_TIME
  47. /*
  48. * sys_time() can be implemented in user-level using
  49. * sys_gettimeofday(). Is this for backwards compatibility? If so,
  50. * why not move it into the appropriate arch directory (for those
  51. * architectures that need it).
  52. */
  53. asmlinkage long sys_time(time_t __user * tloc)
  54. {
  55. time_t i;
  56. struct timeval tv;
  57. do_gettimeofday(&tv);
  58. i = tv.tv_sec;
  59. if (tloc) {
  60. if (put_user(i,tloc))
  61. i = -EFAULT;
  62. }
  63. return i;
  64. }
  65. /*
  66. * sys_stime() can be implemented in user-level using
  67. * sys_settimeofday(). Is this for backwards compatibility? If so,
  68. * why not move it into the appropriate arch directory (for those
  69. * architectures that need it).
  70. */
  71. asmlinkage long sys_stime(time_t __user *tptr)
  72. {
  73. struct timespec tv;
  74. int err;
  75. if (get_user(tv.tv_sec, tptr))
  76. return -EFAULT;
  77. tv.tv_nsec = 0;
  78. err = security_settime(&tv, NULL);
  79. if (err)
  80. return err;
  81. do_settimeofday(&tv);
  82. return 0;
  83. }
  84. #endif /* __ARCH_WANT_SYS_TIME */
  85. asmlinkage long sys_gettimeofday(struct timeval __user *tv, struct timezone __user *tz)
  86. {
  87. if (likely(tv != NULL)) {
  88. struct timeval ktv;
  89. do_gettimeofday(&ktv);
  90. if (copy_to_user(tv, &ktv, sizeof(ktv)))
  91. return -EFAULT;
  92. }
  93. if (unlikely(tz != NULL)) {
  94. if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
  95. return -EFAULT;
  96. }
  97. return 0;
  98. }
  99. /*
  100. * Adjust the time obtained from the CMOS to be UTC time instead of
  101. * local time.
  102. *
  103. * This is ugly, but preferable to the alternatives. Otherwise we
  104. * would either need to write a program to do it in /etc/rc (and risk
  105. * confusion if the program gets run more than once; it would also be
  106. * hard to make the program warp the clock precisely n hours) or
  107. * compile in the timezone information into the kernel. Bad, bad....
  108. *
  109. * - TYT, 1992-01-01
  110. *
  111. * The best thing to do is to keep the CMOS clock in universal time (UTC)
  112. * as real UNIX machines always do it. This avoids all headaches about
  113. * daylight saving times and warping kernel clocks.
  114. */
  115. static inline void warp_clock(void)
  116. {
  117. write_seqlock_irq(&xtime_lock);
  118. wall_to_monotonic.tv_sec -= sys_tz.tz_minuteswest * 60;
  119. xtime.tv_sec += sys_tz.tz_minuteswest * 60;
  120. time_interpolator_reset();
  121. write_sequnlock_irq(&xtime_lock);
  122. clock_was_set();
  123. }
  124. /*
  125. * In case for some reason the CMOS clock has not already been running
  126. * in UTC, but in some local time: The first time we set the timezone,
  127. * we will warp the clock so that it is ticking UTC time instead of
  128. * local time. Presumably, if someone is setting the timezone then we
  129. * are running in an environment where the programs understand about
  130. * timezones. This should be done at boot time in the /etc/rc script,
  131. * as soon as possible, so that the clock can be set right. Otherwise,
  132. * various programs will get confused when the clock gets warped.
  133. */
  134. int do_sys_settimeofday(struct timespec *tv, struct timezone *tz)
  135. {
  136. static int firsttime = 1;
  137. int error = 0;
  138. if (tv && !timespec_valid(tv))
  139. return -EINVAL;
  140. error = security_settime(tv, tz);
  141. if (error)
  142. return error;
  143. if (tz) {
  144. /* SMP safe, global irq locking makes it work. */
  145. sys_tz = *tz;
  146. if (firsttime) {
  147. firsttime = 0;
  148. if (!tv)
  149. warp_clock();
  150. }
  151. }
  152. if (tv)
  153. {
  154. /* SMP safe, again the code in arch/foo/time.c should
  155. * globally block out interrupts when it runs.
  156. */
  157. return do_settimeofday(tv);
  158. }
  159. return 0;
  160. }
  161. asmlinkage long sys_settimeofday(struct timeval __user *tv,
  162. struct timezone __user *tz)
  163. {
  164. struct timeval user_tv;
  165. struct timespec new_ts;
  166. struct timezone new_tz;
  167. if (tv) {
  168. if (copy_from_user(&user_tv, tv, sizeof(*tv)))
  169. return -EFAULT;
  170. new_ts.tv_sec = user_tv.tv_sec;
  171. new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
  172. }
  173. if (tz) {
  174. if (copy_from_user(&new_tz, tz, sizeof(*tz)))
  175. return -EFAULT;
  176. }
  177. return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
  178. }
  179. asmlinkage long sys_adjtimex(struct timex __user *txc_p)
  180. {
  181. struct timex txc; /* Local copy of parameter */
  182. int ret;
  183. /* Copy the user data space into the kernel copy
  184. * structure. But bear in mind that the structures
  185. * may change
  186. */
  187. if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
  188. return -EFAULT;
  189. ret = do_adjtimex(&txc);
  190. return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
  191. }
  192. inline struct timespec current_kernel_time(void)
  193. {
  194. struct timespec now;
  195. unsigned long seq;
  196. do {
  197. seq = read_seqbegin(&xtime_lock);
  198. now = xtime;
  199. } while (read_seqretry(&xtime_lock, seq));
  200. return now;
  201. }
  202. EXPORT_SYMBOL(current_kernel_time);
  203. /**
  204. * current_fs_time - Return FS time
  205. * @sb: Superblock.
  206. *
  207. * Return the current time truncated to the time granularity supported by
  208. * the fs.
  209. */
  210. struct timespec current_fs_time(struct super_block *sb)
  211. {
  212. struct timespec now = current_kernel_time();
  213. return timespec_trunc(now, sb->s_time_gran);
  214. }
  215. EXPORT_SYMBOL(current_fs_time);
  216. /**
  217. * timespec_trunc - Truncate timespec to a granularity
  218. * @t: Timespec
  219. * @gran: Granularity in ns.
  220. *
  221. * Truncate a timespec to a granularity. gran must be smaller than a second.
  222. * Always rounds down.
  223. *
  224. * This function should be only used for timestamps returned by
  225. * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
  226. * it doesn't handle the better resolution of the later.
  227. */
  228. struct timespec timespec_trunc(struct timespec t, unsigned gran)
  229. {
  230. /*
  231. * Division is pretty slow so avoid it for common cases.
  232. * Currently current_kernel_time() never returns better than
  233. * jiffies resolution. Exploit that.
  234. */
  235. if (gran <= jiffies_to_usecs(1) * 1000) {
  236. /* nothing */
  237. } else if (gran == 1000000000) {
  238. t.tv_nsec = 0;
  239. } else {
  240. t.tv_nsec -= t.tv_nsec % gran;
  241. }
  242. return t;
  243. }
  244. EXPORT_SYMBOL(timespec_trunc);
  245. #ifdef CONFIG_TIME_INTERPOLATION
  246. void getnstimeofday (struct timespec *tv)
  247. {
  248. unsigned long seq,sec,nsec;
  249. do {
  250. seq = read_seqbegin(&xtime_lock);
  251. sec = xtime.tv_sec;
  252. nsec = xtime.tv_nsec+time_interpolator_get_offset();
  253. } while (unlikely(read_seqretry(&xtime_lock, seq)));
  254. while (unlikely(nsec >= NSEC_PER_SEC)) {
  255. nsec -= NSEC_PER_SEC;
  256. ++sec;
  257. }
  258. tv->tv_sec = sec;
  259. tv->tv_nsec = nsec;
  260. }
  261. EXPORT_SYMBOL_GPL(getnstimeofday);
  262. int do_settimeofday (struct timespec *tv)
  263. {
  264. time_t wtm_sec, sec = tv->tv_sec;
  265. long wtm_nsec, nsec = tv->tv_nsec;
  266. if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
  267. return -EINVAL;
  268. write_seqlock_irq(&xtime_lock);
  269. {
  270. wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
  271. wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
  272. set_normalized_timespec(&xtime, sec, nsec);
  273. set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
  274. time_adjust = 0; /* stop active adjtime() */
  275. time_status |= STA_UNSYNC;
  276. time_maxerror = NTP_PHASE_LIMIT;
  277. time_esterror = NTP_PHASE_LIMIT;
  278. time_interpolator_reset();
  279. }
  280. write_sequnlock_irq(&xtime_lock);
  281. clock_was_set();
  282. return 0;
  283. }
  284. EXPORT_SYMBOL(do_settimeofday);
  285. void do_gettimeofday (struct timeval *tv)
  286. {
  287. unsigned long seq, nsec, usec, sec, offset;
  288. do {
  289. seq = read_seqbegin(&xtime_lock);
  290. offset = time_interpolator_get_offset();
  291. sec = xtime.tv_sec;
  292. nsec = xtime.tv_nsec;
  293. } while (unlikely(read_seqretry(&xtime_lock, seq)));
  294. usec = (nsec + offset) / 1000;
  295. while (unlikely(usec >= USEC_PER_SEC)) {
  296. usec -= USEC_PER_SEC;
  297. ++sec;
  298. }
  299. tv->tv_sec = sec;
  300. tv->tv_usec = usec;
  301. }
  302. EXPORT_SYMBOL(do_gettimeofday);
  303. #else
  304. #ifndef CONFIG_GENERIC_TIME
  305. /*
  306. * Simulate gettimeofday using do_gettimeofday which only allows a timeval
  307. * and therefore only yields usec accuracy
  308. */
  309. void getnstimeofday(struct timespec *tv)
  310. {
  311. struct timeval x;
  312. do_gettimeofday(&x);
  313. tv->tv_sec = x.tv_sec;
  314. tv->tv_nsec = x.tv_usec * NSEC_PER_USEC;
  315. }
  316. EXPORT_SYMBOL_GPL(getnstimeofday);
  317. #endif
  318. #endif
  319. /* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
  320. * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
  321. * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
  322. *
  323. * [For the Julian calendar (which was used in Russia before 1917,
  324. * Britain & colonies before 1752, anywhere else before 1582,
  325. * and is still in use by some communities) leave out the
  326. * -year/100+year/400 terms, and add 10.]
  327. *
  328. * This algorithm was first published by Gauss (I think).
  329. *
  330. * WARNING: this function will overflow on 2106-02-07 06:28:16 on
  331. * machines were long is 32-bit! (However, as time_t is signed, we
  332. * will already get problems at other places on 2038-01-19 03:14:08)
  333. */
  334. unsigned long
  335. mktime(const unsigned int year0, const unsigned int mon0,
  336. const unsigned int day, const unsigned int hour,
  337. const unsigned int min, const unsigned int sec)
  338. {
  339. unsigned int mon = mon0, year = year0;
  340. /* 1..12 -> 11,12,1..10 */
  341. if (0 >= (int) (mon -= 2)) {
  342. mon += 12; /* Puts Feb last since it has leap day */
  343. year -= 1;
  344. }
  345. return ((((unsigned long)
  346. (year/4 - year/100 + year/400 + 367*mon/12 + day) +
  347. year*365 - 719499
  348. )*24 + hour /* now have hours */
  349. )*60 + min /* now have minutes */
  350. )*60 + sec; /* finally seconds */
  351. }
  352. EXPORT_SYMBOL(mktime);
  353. /**
  354. * set_normalized_timespec - set timespec sec and nsec parts and normalize
  355. *
  356. * @ts: pointer to timespec variable to be set
  357. * @sec: seconds to set
  358. * @nsec: nanoseconds to set
  359. *
  360. * Set seconds and nanoseconds field of a timespec variable and
  361. * normalize to the timespec storage format
  362. *
  363. * Note: The tv_nsec part is always in the range of
  364. * 0 <= tv_nsec < NSEC_PER_SEC
  365. * For negative values only the tv_sec field is negative !
  366. */
  367. void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec)
  368. {
  369. while (nsec >= NSEC_PER_SEC) {
  370. nsec -= NSEC_PER_SEC;
  371. ++sec;
  372. }
  373. while (nsec < 0) {
  374. nsec += NSEC_PER_SEC;
  375. --sec;
  376. }
  377. ts->tv_sec = sec;
  378. ts->tv_nsec = nsec;
  379. }
  380. /**
  381. * ns_to_timespec - Convert nanoseconds to timespec
  382. * @nsec: the nanoseconds value to be converted
  383. *
  384. * Returns the timespec representation of the nsec parameter.
  385. */
  386. struct timespec ns_to_timespec(const s64 nsec)
  387. {
  388. struct timespec ts;
  389. if (!nsec)
  390. return (struct timespec) {0, 0};
  391. ts.tv_sec = div_long_long_rem_signed(nsec, NSEC_PER_SEC, &ts.tv_nsec);
  392. if (unlikely(nsec < 0))
  393. set_normalized_timespec(&ts, ts.tv_sec, ts.tv_nsec);
  394. return ts;
  395. }
  396. /**
  397. * ns_to_timeval - Convert nanoseconds to timeval
  398. * @nsec: the nanoseconds value to be converted
  399. *
  400. * Returns the timeval representation of the nsec parameter.
  401. */
  402. struct timeval ns_to_timeval(const s64 nsec)
  403. {
  404. struct timespec ts = ns_to_timespec(nsec);
  405. struct timeval tv;
  406. tv.tv_sec = ts.tv_sec;
  407. tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
  408. return tv;
  409. }
  410. /*
  411. * Convert jiffies to milliseconds and back.
  412. *
  413. * Avoid unnecessary multiplications/divisions in the
  414. * two most common HZ cases:
  415. */
  416. unsigned int jiffies_to_msecs(const unsigned long j)
  417. {
  418. #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
  419. return (MSEC_PER_SEC / HZ) * j;
  420. #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
  421. return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
  422. #else
  423. return (j * MSEC_PER_SEC) / HZ;
  424. #endif
  425. }
  426. EXPORT_SYMBOL(jiffies_to_msecs);
  427. unsigned int jiffies_to_usecs(const unsigned long j)
  428. {
  429. #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
  430. return (USEC_PER_SEC / HZ) * j;
  431. #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
  432. return (j + (HZ / USEC_PER_SEC) - 1)/(HZ / USEC_PER_SEC);
  433. #else
  434. return (j * USEC_PER_SEC) / HZ;
  435. #endif
  436. }
  437. EXPORT_SYMBOL(jiffies_to_usecs);
  438. /*
  439. * When we convert to jiffies then we interpret incoming values
  440. * the following way:
  441. *
  442. * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
  443. *
  444. * - 'too large' values [that would result in larger than
  445. * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
  446. *
  447. * - all other values are converted to jiffies by either multiplying
  448. * the input value by a factor or dividing it with a factor
  449. *
  450. * We must also be careful about 32-bit overflows.
  451. */
  452. unsigned long msecs_to_jiffies(const unsigned int m)
  453. {
  454. /*
  455. * Negative value, means infinite timeout:
  456. */
  457. if ((int)m < 0)
  458. return MAX_JIFFY_OFFSET;
  459. #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
  460. /*
  461. * HZ is equal to or smaller than 1000, and 1000 is a nice
  462. * round multiple of HZ, divide with the factor between them,
  463. * but round upwards:
  464. */
  465. return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
  466. #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
  467. /*
  468. * HZ is larger than 1000, and HZ is a nice round multiple of
  469. * 1000 - simply multiply with the factor between them.
  470. *
  471. * But first make sure the multiplication result cannot
  472. * overflow:
  473. */
  474. if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
  475. return MAX_JIFFY_OFFSET;
  476. return m * (HZ / MSEC_PER_SEC);
  477. #else
  478. /*
  479. * Generic case - multiply, round and divide. But first
  480. * check that if we are doing a net multiplication, that
  481. * we wouldnt overflow:
  482. */
  483. if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
  484. return MAX_JIFFY_OFFSET;
  485. return (m * HZ + MSEC_PER_SEC - 1) / MSEC_PER_SEC;
  486. #endif
  487. }
  488. EXPORT_SYMBOL(msecs_to_jiffies);
  489. unsigned long usecs_to_jiffies(const unsigned int u)
  490. {
  491. if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
  492. return MAX_JIFFY_OFFSET;
  493. #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
  494. return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
  495. #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
  496. return u * (HZ / USEC_PER_SEC);
  497. #else
  498. return (u * HZ + USEC_PER_SEC - 1) / USEC_PER_SEC;
  499. #endif
  500. }
  501. EXPORT_SYMBOL(usecs_to_jiffies);
  502. /*
  503. * The TICK_NSEC - 1 rounds up the value to the next resolution. Note
  504. * that a remainder subtract here would not do the right thing as the
  505. * resolution values don't fall on second boundries. I.e. the line:
  506. * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
  507. *
  508. * Rather, we just shift the bits off the right.
  509. *
  510. * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
  511. * value to a scaled second value.
  512. */
  513. unsigned long
  514. timespec_to_jiffies(const struct timespec *value)
  515. {
  516. unsigned long sec = value->tv_sec;
  517. long nsec = value->tv_nsec + TICK_NSEC - 1;
  518. if (sec >= MAX_SEC_IN_JIFFIES){
  519. sec = MAX_SEC_IN_JIFFIES;
  520. nsec = 0;
  521. }
  522. return (((u64)sec * SEC_CONVERSION) +
  523. (((u64)nsec * NSEC_CONVERSION) >>
  524. (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
  525. }
  526. EXPORT_SYMBOL(timespec_to_jiffies);
  527. void
  528. jiffies_to_timespec(const unsigned long jiffies, struct timespec *value)
  529. {
  530. /*
  531. * Convert jiffies to nanoseconds and separate with
  532. * one divide.
  533. */
  534. u64 nsec = (u64)jiffies * TICK_NSEC;
  535. value->tv_sec = div_long_long_rem(nsec, NSEC_PER_SEC, &value->tv_nsec);
  536. }
  537. EXPORT_SYMBOL(jiffies_to_timespec);
  538. /* Same for "timeval"
  539. *
  540. * Well, almost. The problem here is that the real system resolution is
  541. * in nanoseconds and the value being converted is in micro seconds.
  542. * Also for some machines (those that use HZ = 1024, in-particular),
  543. * there is a LARGE error in the tick size in microseconds.
  544. * The solution we use is to do the rounding AFTER we convert the
  545. * microsecond part. Thus the USEC_ROUND, the bits to be shifted off.
  546. * Instruction wise, this should cost only an additional add with carry
  547. * instruction above the way it was done above.
  548. */
  549. unsigned long
  550. timeval_to_jiffies(const struct timeval *value)
  551. {
  552. unsigned long sec = value->tv_sec;
  553. long usec = value->tv_usec;
  554. if (sec >= MAX_SEC_IN_JIFFIES){
  555. sec = MAX_SEC_IN_JIFFIES;
  556. usec = 0;
  557. }
  558. return (((u64)sec * SEC_CONVERSION) +
  559. (((u64)usec * USEC_CONVERSION + USEC_ROUND) >>
  560. (USEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
  561. }
  562. EXPORT_SYMBOL(timeval_to_jiffies);
  563. void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
  564. {
  565. /*
  566. * Convert jiffies to nanoseconds and separate with
  567. * one divide.
  568. */
  569. u64 nsec = (u64)jiffies * TICK_NSEC;
  570. long tv_usec;
  571. value->tv_sec = div_long_long_rem(nsec, NSEC_PER_SEC, &tv_usec);
  572. tv_usec /= NSEC_PER_USEC;
  573. value->tv_usec = tv_usec;
  574. }
  575. EXPORT_SYMBOL(jiffies_to_timeval);
  576. /*
  577. * Convert jiffies/jiffies_64 to clock_t and back.
  578. */
  579. clock_t jiffies_to_clock_t(long x)
  580. {
  581. #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
  582. return x / (HZ / USER_HZ);
  583. #else
  584. u64 tmp = (u64)x * TICK_NSEC;
  585. do_div(tmp, (NSEC_PER_SEC / USER_HZ));
  586. return (long)tmp;
  587. #endif
  588. }
  589. EXPORT_SYMBOL(jiffies_to_clock_t);
  590. unsigned long clock_t_to_jiffies(unsigned long x)
  591. {
  592. #if (HZ % USER_HZ)==0
  593. if (x >= ~0UL / (HZ / USER_HZ))
  594. return ~0UL;
  595. return x * (HZ / USER_HZ);
  596. #else
  597. u64 jif;
  598. /* Don't worry about loss of precision here .. */
  599. if (x >= ~0UL / HZ * USER_HZ)
  600. return ~0UL;
  601. /* .. but do try to contain it here */
  602. jif = x * (u64) HZ;
  603. do_div(jif, USER_HZ);
  604. return jif;
  605. #endif
  606. }
  607. EXPORT_SYMBOL(clock_t_to_jiffies);
  608. u64 jiffies_64_to_clock_t(u64 x)
  609. {
  610. #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
  611. do_div(x, HZ / USER_HZ);
  612. #else
  613. /*
  614. * There are better ways that don't overflow early,
  615. * but even this doesn't overflow in hundreds of years
  616. * in 64 bits, so..
  617. */
  618. x *= TICK_NSEC;
  619. do_div(x, (NSEC_PER_SEC / USER_HZ));
  620. #endif
  621. return x;
  622. }
  623. EXPORT_SYMBOL(jiffies_64_to_clock_t);
  624. u64 nsec_to_clock_t(u64 x)
  625. {
  626. #if (NSEC_PER_SEC % USER_HZ) == 0
  627. do_div(x, (NSEC_PER_SEC / USER_HZ));
  628. #elif (USER_HZ % 512) == 0
  629. x *= USER_HZ/512;
  630. do_div(x, (NSEC_PER_SEC / 512));
  631. #else
  632. /*
  633. * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
  634. * overflow after 64.99 years.
  635. * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
  636. */
  637. x *= 9;
  638. do_div(x, (unsigned long)((9ull * NSEC_PER_SEC + (USER_HZ/2)) /
  639. USER_HZ));
  640. #endif
  641. return x;
  642. }
  643. #if (BITS_PER_LONG < 64)
  644. u64 get_jiffies_64(void)
  645. {
  646. unsigned long seq;
  647. u64 ret;
  648. do {
  649. seq = read_seqbegin(&xtime_lock);
  650. ret = jiffies_64;
  651. } while (read_seqretry(&xtime_lock, seq));
  652. return ret;
  653. }
  654. EXPORT_SYMBOL(get_jiffies_64);
  655. #endif
  656. EXPORT_SYMBOL(jiffies);