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/core.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 30#include <linux/export.h> 31#include <linux/timex.h> 32#include <linux/capability.h> 33#include <linux/timekeeper_internal.h> 34#include <linux/errno.h> 35#include <linux/syscalls.h> 36#include <linux/security.h> 37#include <linux/fs.h> 38#include <linux/math64.h> 39#include <linux/ptrace.h> 40 41#include <asm/uaccess.h> 42#include <asm/unistd.h> 43 44#include "timeconst.h" 45#include "timekeeping.h" 46 47/* 48 * The timezone where the local system is located. Used as a default by some 49 * programs who obtain this value by using gettimeofday. 50 */ 51struct timezone sys_tz; 52 53EXPORT_SYMBOL(sys_tz); 54 55#ifdef __ARCH_WANT_SYS_TIME 56 57/* 58 * sys_time() can be implemented in user-level using 59 * sys_gettimeofday(). Is this for backwards compatibility? If so, 60 * why not move it into the appropriate arch directory (for those 61 * architectures that need it). 62 */ 63SYSCALL_DEFINE1(time, time_t __user *, tloc) 64{ 65 time_t i = get_seconds(); 66 67 if (tloc) { 68 if (put_user(i,tloc)) 69 return -EFAULT; 70 } 71 force_successful_syscall_return(); 72 return i; 73} 74 75/* 76 * sys_stime() can be implemented in user-level using 77 * sys_settimeofday(). Is this for backwards compatibility? If so, 78 * why not move it into the appropriate arch directory (for those 79 * architectures that need it). 80 */ 81 82SYSCALL_DEFINE1(stime, time_t __user *, tptr) 83{ 84 struct timespec tv; 85 int err; 86 87 if (get_user(tv.tv_sec, tptr)) 88 return -EFAULT; 89 90 tv.tv_nsec = 0; 91 92 err = security_settime(&tv, NULL); 93 if (err) 94 return err; 95 96 do_settimeofday(&tv); 97 return 0; 98} 99 100#endif /* __ARCH_WANT_SYS_TIME */ 101 102SYSCALL_DEFINE2(gettimeofday, struct timeval __user *, tv, 103 struct timezone __user *, tz) 104{ 105 if (likely(tv != NULL)) { 106 struct timeval ktv; 107 do_gettimeofday(&ktv); 108 if (copy_to_user(tv, &ktv, sizeof(ktv))) 109 return -EFAULT; 110 } 111 if (unlikely(tz != NULL)) { 112 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz))) 113 return -EFAULT; 114 } 115 return 0; 116} 117 118/* 119 * Indicates if there is an offset between the system clock and the hardware 120 * clock/persistent clock/rtc. 121 */ 122int persistent_clock_is_local; 123 124/* 125 * Adjust the time obtained from the CMOS to be UTC time instead of 126 * local time. 127 * 128 * This is ugly, but preferable to the alternatives. Otherwise we 129 * would either need to write a program to do it in /etc/rc (and risk 130 * confusion if the program gets run more than once; it would also be 131 * hard to make the program warp the clock precisely n hours) or 132 * compile in the timezone information into the kernel. Bad, bad.... 133 * 134 * - TYT, 1992-01-01 135 * 136 * The best thing to do is to keep the CMOS clock in universal time (UTC) 137 * as real UNIX machines always do it. This avoids all headaches about 138 * daylight saving times and warping kernel clocks. 139 */ 140static inline void warp_clock(void) 141{ 142 if (sys_tz.tz_minuteswest != 0) { 143 struct timespec adjust; 144 145 persistent_clock_is_local = 1; 146 adjust.tv_sec = sys_tz.tz_minuteswest * 60; 147 adjust.tv_nsec = 0; 148 timekeeping_inject_offset(&adjust); 149 } 150} 151 152/* 153 * In case for some reason the CMOS clock has not already been running 154 * in UTC, but in some local time: The first time we set the timezone, 155 * we will warp the clock so that it is ticking UTC time instead of 156 * local time. Presumably, if someone is setting the timezone then we 157 * are running in an environment where the programs understand about 158 * timezones. This should be done at boot time in the /etc/rc script, 159 * as soon as possible, so that the clock can be set right. Otherwise, 160 * various programs will get confused when the clock gets warped. 161 */ 162 163int do_sys_settimeofday(const struct timespec *tv, const struct timezone *tz) 164{ 165 static int firsttime = 1; 166 int error = 0; 167 168 if (tv && !timespec_valid(tv)) 169 return -EINVAL; 170 171 error = security_settime(tv, tz); 172 if (error) 173 return error; 174 175 if (tz) { 176 sys_tz = *tz; 177 update_vsyscall_tz(); 178 if (firsttime) { 179 firsttime = 0; 180 if (!tv) 181 warp_clock(); 182 } 183 } 184 if (tv) 185 return do_settimeofday(tv); 186 return 0; 187} 188 189SYSCALL_DEFINE2(settimeofday, struct timeval __user *, tv, 190 struct timezone __user *, tz) 191{ 192 struct timeval user_tv; 193 struct timespec new_ts; 194 struct timezone new_tz; 195 196 if (tv) { 197 if (copy_from_user(&user_tv, tv, sizeof(*tv))) 198 return -EFAULT; 199 200 if (!timeval_valid(&user_tv)) 201 return -EINVAL; 202 203 new_ts.tv_sec = user_tv.tv_sec; 204 new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC; 205 } 206 if (tz) { 207 if (copy_from_user(&new_tz, tz, sizeof(*tz))) 208 return -EFAULT; 209 } 210 211 return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL); 212} 213 214SYSCALL_DEFINE1(adjtimex, struct timex __user *, txc_p) 215{ 216 struct timex txc; /* Local copy of parameter */ 217 int ret; 218 219 /* Copy the user data space into the kernel copy 220 * structure. But bear in mind that the structures 221 * may change 222 */ 223 if(copy_from_user(&txc, txc_p, sizeof(struct timex))) 224 return -EFAULT; 225 ret = do_adjtimex(&txc); 226 return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret; 227} 228 229/** 230 * current_fs_time - Return FS time 231 * @sb: Superblock. 232 * 233 * Return the current time truncated to the time granularity supported by 234 * the fs. 235 */ 236struct timespec current_fs_time(struct super_block *sb) 237{ 238 struct timespec now = current_kernel_time(); 239 return timespec_trunc(now, sb->s_time_gran); 240} 241EXPORT_SYMBOL(current_fs_time); 242 243/* 244 * Convert jiffies to milliseconds and back. 245 * 246 * Avoid unnecessary multiplications/divisions in the 247 * two most common HZ cases: 248 */ 249unsigned int jiffies_to_msecs(const unsigned long j) 250{ 251#if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ) 252 return (MSEC_PER_SEC / HZ) * j; 253#elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC) 254 return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC); 255#else 256# if BITS_PER_LONG == 32 257 return (HZ_TO_MSEC_MUL32 * j) >> HZ_TO_MSEC_SHR32; 258# else 259 return (j * HZ_TO_MSEC_NUM) / HZ_TO_MSEC_DEN; 260# endif 261#endif 262} 263EXPORT_SYMBOL(jiffies_to_msecs); 264 265unsigned int jiffies_to_usecs(const unsigned long j) 266{ 267#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ) 268 return (USEC_PER_SEC / HZ) * j; 269#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC) 270 return (j + (HZ / USEC_PER_SEC) - 1)/(HZ / USEC_PER_SEC); 271#else 272# if BITS_PER_LONG == 32 273 return (HZ_TO_USEC_MUL32 * j) >> HZ_TO_USEC_SHR32; 274# else 275 return (j * HZ_TO_USEC_NUM) / HZ_TO_USEC_DEN; 276# endif 277#endif 278} 279EXPORT_SYMBOL(jiffies_to_usecs); 280 281/** 282 * timespec_trunc - Truncate timespec to a granularity 283 * @t: Timespec 284 * @gran: Granularity in ns. 285 * 286 * Truncate a timespec to a granularity. gran must be smaller than a second. 287 * Always rounds down. 288 * 289 * This function should be only used for timestamps returned by 290 * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because 291 * it doesn't handle the better resolution of the latter. 292 */ 293struct timespec timespec_trunc(struct timespec t, unsigned gran) 294{ 295 /* 296 * Division is pretty slow so avoid it for common cases. 297 * Currently current_kernel_time() never returns better than 298 * jiffies resolution. Exploit that. 299 */ 300 if (gran <= jiffies_to_usecs(1) * 1000) { 301 /* nothing */ 302 } else if (gran == 1000000000) { 303 t.tv_nsec = 0; 304 } else { 305 t.tv_nsec -= t.tv_nsec % gran; 306 } 307 return t; 308} 309EXPORT_SYMBOL(timespec_trunc); 310 311/* 312 * mktime64 - Converts date to seconds. 313 * Converts Gregorian date to seconds since 1970-01-01 00:00:00. 314 * Assumes input in normal date format, i.e. 1980-12-31 23:59:59 315 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59. 316 * 317 * [For the Julian calendar (which was used in Russia before 1917, 318 * Britain & colonies before 1752, anywhere else before 1582, 319 * and is still in use by some communities) leave out the 320 * -year/100+year/400 terms, and add 10.] 321 * 322 * This algorithm was first published by Gauss (I think). 323 */ 324time64_t mktime64(const unsigned int year0, const unsigned int mon0, 325 const unsigned int day, const unsigned int hour, 326 const unsigned int min, const unsigned int sec) 327{ 328 unsigned int mon = mon0, year = year0; 329 330 /* 1..12 -> 11,12,1..10 */ 331 if (0 >= (int) (mon -= 2)) { 332 mon += 12; /* Puts Feb last since it has leap day */ 333 year -= 1; 334 } 335 336 return ((((time64_t) 337 (year/4 - year/100 + year/400 + 367*mon/12 + day) + 338 year*365 - 719499 339 )*24 + hour /* now have hours */ 340 )*60 + min /* now have minutes */ 341 )*60 + sec; /* finally seconds */ 342} 343EXPORT_SYMBOL(mktime64); 344 345/** 346 * set_normalized_timespec - set timespec sec and nsec parts and normalize 347 * 348 * @ts: pointer to timespec variable to be set 349 * @sec: seconds to set 350 * @nsec: nanoseconds to set 351 * 352 * Set seconds and nanoseconds field of a timespec variable and 353 * normalize to the timespec storage format 354 * 355 * Note: The tv_nsec part is always in the range of 356 * 0 <= tv_nsec < NSEC_PER_SEC 357 * For negative values only the tv_sec field is negative ! 358 */ 359void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec) 360{ 361 while (nsec >= NSEC_PER_SEC) { 362 /* 363 * The following asm() prevents the compiler from 364 * optimising this loop into a modulo operation. See 365 * also __iter_div_u64_rem() in include/linux/time.h 366 */ 367 asm("" : "+rm"(nsec)); 368 nsec -= NSEC_PER_SEC; 369 ++sec; 370 } 371 while (nsec < 0) { 372 asm("" : "+rm"(nsec)); 373 nsec += NSEC_PER_SEC; 374 --sec; 375 } 376 ts->tv_sec = sec; 377 ts->tv_nsec = nsec; 378} 379EXPORT_SYMBOL(set_normalized_timespec); 380 381/** 382 * ns_to_timespec - Convert nanoseconds to timespec 383 * @nsec: the nanoseconds value to be converted 384 * 385 * Returns the timespec representation of the nsec parameter. 386 */ 387struct timespec ns_to_timespec(const s64 nsec) 388{ 389 struct timespec ts; 390 s32 rem; 391 392 if (!nsec) 393 return (struct timespec) {0, 0}; 394 395 ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem); 396 if (unlikely(rem < 0)) { 397 ts.tv_sec--; 398 rem += NSEC_PER_SEC; 399 } 400 ts.tv_nsec = rem; 401 402 return ts; 403} 404EXPORT_SYMBOL(ns_to_timespec); 405 406/** 407 * ns_to_timeval - Convert nanoseconds to timeval 408 * @nsec: the nanoseconds value to be converted 409 * 410 * Returns the timeval representation of the nsec parameter. 411 */ 412struct timeval ns_to_timeval(const s64 nsec) 413{ 414 struct timespec ts = ns_to_timespec(nsec); 415 struct timeval tv; 416 417 tv.tv_sec = ts.tv_sec; 418 tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000; 419 420 return tv; 421} 422EXPORT_SYMBOL(ns_to_timeval); 423 424#if BITS_PER_LONG == 32 425/** 426 * set_normalized_timespec - set timespec sec and nsec parts and normalize 427 * 428 * @ts: pointer to timespec variable to be set 429 * @sec: seconds to set 430 * @nsec: nanoseconds to set 431 * 432 * Set seconds and nanoseconds field of a timespec variable and 433 * normalize to the timespec storage format 434 * 435 * Note: The tv_nsec part is always in the range of 436 * 0 <= tv_nsec < NSEC_PER_SEC 437 * For negative values only the tv_sec field is negative ! 438 */ 439void set_normalized_timespec64(struct timespec64 *ts, time64_t sec, s64 nsec) 440{ 441 while (nsec >= NSEC_PER_SEC) { 442 /* 443 * The following asm() prevents the compiler from 444 * optimising this loop into a modulo operation. See 445 * also __iter_div_u64_rem() in include/linux/time.h 446 */ 447 asm("" : "+rm"(nsec)); 448 nsec -= NSEC_PER_SEC; 449 ++sec; 450 } 451 while (nsec < 0) { 452 asm("" : "+rm"(nsec)); 453 nsec += NSEC_PER_SEC; 454 --sec; 455 } 456 ts->tv_sec = sec; 457 ts->tv_nsec = nsec; 458} 459EXPORT_SYMBOL(set_normalized_timespec64); 460 461/** 462 * ns_to_timespec64 - Convert nanoseconds to timespec64 463 * @nsec: the nanoseconds value to be converted 464 * 465 * Returns the timespec64 representation of the nsec parameter. 466 */ 467struct timespec64 ns_to_timespec64(const s64 nsec) 468{ 469 struct timespec64 ts; 470 s32 rem; 471 472 if (!nsec) 473 return (struct timespec64) {0, 0}; 474 475 ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem); 476 if (unlikely(rem < 0)) { 477 ts.tv_sec--; 478 rem += NSEC_PER_SEC; 479 } 480 ts.tv_nsec = rem; 481 482 return ts; 483} 484EXPORT_SYMBOL(ns_to_timespec64); 485#endif 486/* 487 * When we convert to jiffies then we interpret incoming values 488 * the following way: 489 * 490 * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET) 491 * 492 * - 'too large' values [that would result in larger than 493 * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too. 494 * 495 * - all other values are converted to jiffies by either multiplying 496 * the input value by a factor or dividing it with a factor 497 * 498 * We must also be careful about 32-bit overflows. 499 */ 500unsigned long msecs_to_jiffies(const unsigned int m) 501{ 502 /* 503 * Negative value, means infinite timeout: 504 */ 505 if ((int)m < 0) 506 return MAX_JIFFY_OFFSET; 507 508#if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ) 509 /* 510 * HZ is equal to or smaller than 1000, and 1000 is a nice 511 * round multiple of HZ, divide with the factor between them, 512 * but round upwards: 513 */ 514 return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ); 515#elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC) 516 /* 517 * HZ is larger than 1000, and HZ is a nice round multiple of 518 * 1000 - simply multiply with the factor between them. 519 * 520 * But first make sure the multiplication result cannot 521 * overflow: 522 */ 523 if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET)) 524 return MAX_JIFFY_OFFSET; 525 526 return m * (HZ / MSEC_PER_SEC); 527#else 528 /* 529 * Generic case - multiply, round and divide. But first 530 * check that if we are doing a net multiplication, that 531 * we wouldn't overflow: 532 */ 533 if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET)) 534 return MAX_JIFFY_OFFSET; 535 536 return (MSEC_TO_HZ_MUL32 * m + MSEC_TO_HZ_ADJ32) 537 >> MSEC_TO_HZ_SHR32; 538#endif 539} 540EXPORT_SYMBOL(msecs_to_jiffies); 541 542unsigned long usecs_to_jiffies(const unsigned int u) 543{ 544 if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET)) 545 return MAX_JIFFY_OFFSET; 546#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ) 547 return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ); 548#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC) 549 return u * (HZ / USEC_PER_SEC); 550#else 551 return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32) 552 >> USEC_TO_HZ_SHR32; 553#endif 554} 555EXPORT_SYMBOL(usecs_to_jiffies); 556 557/* 558 * The TICK_NSEC - 1 rounds up the value to the next resolution. Note 559 * that a remainder subtract here would not do the right thing as the 560 * resolution values don't fall on second boundries. I.e. the line: 561 * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding. 562 * Note that due to the small error in the multiplier here, this 563 * rounding is incorrect for sufficiently large values of tv_nsec, but 564 * well formed timespecs should have tv_nsec < NSEC_PER_SEC, so we're 565 * OK. 566 * 567 * Rather, we just shift the bits off the right. 568 * 569 * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec 570 * value to a scaled second value. 571 */ 572static unsigned long 573__timespec_to_jiffies(unsigned long sec, long nsec) 574{ 575 nsec = nsec + TICK_NSEC - 1; 576 577 if (sec >= MAX_SEC_IN_JIFFIES){ 578 sec = MAX_SEC_IN_JIFFIES; 579 nsec = 0; 580 } 581 return (((u64)sec * SEC_CONVERSION) + 582 (((u64)nsec * NSEC_CONVERSION) >> 583 (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC; 584 585} 586 587unsigned long 588timespec_to_jiffies(const struct timespec *value) 589{ 590 return __timespec_to_jiffies(value->tv_sec, value->tv_nsec); 591} 592 593EXPORT_SYMBOL(timespec_to_jiffies); 594 595void 596jiffies_to_timespec(const unsigned long jiffies, struct timespec *value) 597{ 598 /* 599 * Convert jiffies to nanoseconds and separate with 600 * one divide. 601 */ 602 u32 rem; 603 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC, 604 NSEC_PER_SEC, &rem); 605 value->tv_nsec = rem; 606} 607EXPORT_SYMBOL(jiffies_to_timespec); 608 609/* 610 * We could use a similar algorithm to timespec_to_jiffies (with a 611 * different multiplier for usec instead of nsec). But this has a 612 * problem with rounding: we can't exactly add TICK_NSEC - 1 to the 613 * usec value, since it's not necessarily integral. 614 * 615 * We could instead round in the intermediate scaled representation 616 * (i.e. in units of 1/2^(large scale) jiffies) but that's also 617 * perilous: the scaling introduces a small positive error, which 618 * combined with a division-rounding-upward (i.e. adding 2^(scale) - 1 619 * units to the intermediate before shifting) leads to accidental 620 * overflow and overestimates. 621 * 622 * At the cost of one additional multiplication by a constant, just 623 * use the timespec implementation. 624 */ 625unsigned long 626timeval_to_jiffies(const struct timeval *value) 627{ 628 return __timespec_to_jiffies(value->tv_sec, 629 value->tv_usec * NSEC_PER_USEC); 630} 631EXPORT_SYMBOL(timeval_to_jiffies); 632 633void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value) 634{ 635 /* 636 * Convert jiffies to nanoseconds and separate with 637 * one divide. 638 */ 639 u32 rem; 640 641 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC, 642 NSEC_PER_SEC, &rem); 643 value->tv_usec = rem / NSEC_PER_USEC; 644} 645EXPORT_SYMBOL(jiffies_to_timeval); 646 647/* 648 * Convert jiffies/jiffies_64 to clock_t and back. 649 */ 650clock_t jiffies_to_clock_t(unsigned long x) 651{ 652#if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0 653# if HZ < USER_HZ 654 return x * (USER_HZ / HZ); 655# else 656 return x / (HZ / USER_HZ); 657# endif 658#else 659 return div_u64((u64)x * TICK_NSEC, NSEC_PER_SEC / USER_HZ); 660#endif 661} 662EXPORT_SYMBOL(jiffies_to_clock_t); 663 664unsigned long clock_t_to_jiffies(unsigned long x) 665{ 666#if (HZ % USER_HZ)==0 667 if (x >= ~0UL / (HZ / USER_HZ)) 668 return ~0UL; 669 return x * (HZ / USER_HZ); 670#else 671 /* Don't worry about loss of precision here .. */ 672 if (x >= ~0UL / HZ * USER_HZ) 673 return ~0UL; 674 675 /* .. but do try to contain it here */ 676 return div_u64((u64)x * HZ, USER_HZ); 677#endif 678} 679EXPORT_SYMBOL(clock_t_to_jiffies); 680 681u64 jiffies_64_to_clock_t(u64 x) 682{ 683#if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0 684# if HZ < USER_HZ 685 x = div_u64(x * USER_HZ, HZ); 686# elif HZ > USER_HZ 687 x = div_u64(x, HZ / USER_HZ); 688# else 689 /* Nothing to do */ 690# endif 691#else 692 /* 693 * There are better ways that don't overflow early, 694 * but even this doesn't overflow in hundreds of years 695 * in 64 bits, so.. 696 */ 697 x = div_u64(x * TICK_NSEC, (NSEC_PER_SEC / USER_HZ)); 698#endif 699 return x; 700} 701EXPORT_SYMBOL(jiffies_64_to_clock_t); 702 703u64 nsec_to_clock_t(u64 x) 704{ 705#if (NSEC_PER_SEC % USER_HZ) == 0 706 return div_u64(x, NSEC_PER_SEC / USER_HZ); 707#elif (USER_HZ % 512) == 0 708 return div_u64(x * USER_HZ / 512, NSEC_PER_SEC / 512); 709#else 710 /* 711 * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024, 712 * overflow after 64.99 years. 713 * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ... 714 */ 715 return div_u64(x * 9, (9ull * NSEC_PER_SEC + (USER_HZ / 2)) / USER_HZ); 716#endif 717} 718 719/** 720 * nsecs_to_jiffies64 - Convert nsecs in u64 to jiffies64 721 * 722 * @n: nsecs in u64 723 * 724 * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64. 725 * And this doesn't return MAX_JIFFY_OFFSET since this function is designed 726 * for scheduler, not for use in device drivers to calculate timeout value. 727 * 728 * note: 729 * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512) 730 * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years 731 */ 732u64 nsecs_to_jiffies64(u64 n) 733{ 734#if (NSEC_PER_SEC % HZ) == 0 735 /* Common case, HZ = 100, 128, 200, 250, 256, 500, 512, 1000 etc. */ 736 return div_u64(n, NSEC_PER_SEC / HZ); 737#elif (HZ % 512) == 0 738 /* overflow after 292 years if HZ = 1024 */ 739 return div_u64(n * HZ / 512, NSEC_PER_SEC / 512); 740#else 741 /* 742 * Generic case - optimized for cases where HZ is a multiple of 3. 743 * overflow after 64.99 years, exact for HZ = 60, 72, 90, 120 etc. 744 */ 745 return div_u64(n * 9, (9ull * NSEC_PER_SEC + HZ / 2) / HZ); 746#endif 747} 748EXPORT_SYMBOL(nsecs_to_jiffies64); 749 750/** 751 * nsecs_to_jiffies - Convert nsecs in u64 to jiffies 752 * 753 * @n: nsecs in u64 754 * 755 * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64. 756 * And this doesn't return MAX_JIFFY_OFFSET since this function is designed 757 * for scheduler, not for use in device drivers to calculate timeout value. 758 * 759 * note: 760 * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512) 761 * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years 762 */ 763unsigned long nsecs_to_jiffies(u64 n) 764{ 765 return (unsigned long)nsecs_to_jiffies64(n); 766} 767EXPORT_SYMBOL_GPL(nsecs_to_jiffies); 768 769/* 770 * Add two timespec values and do a safety check for overflow. 771 * It's assumed that both values are valid (>= 0) 772 */ 773struct timespec timespec_add_safe(const struct timespec lhs, 774 const struct timespec rhs) 775{ 776 struct timespec res; 777 778 set_normalized_timespec(&res, lhs.tv_sec + rhs.tv_sec, 779 lhs.tv_nsec + rhs.tv_nsec); 780 781 if (res.tv_sec < lhs.tv_sec || res.tv_sec < rhs.tv_sec) 782 res.tv_sec = TIME_T_MAX; 783 784 return res; 785} 786