1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30#include <linux/module.h>
31#include <linux/timex.h>
32#include <linux/capability.h>
33#include <linux/clocksource.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
46
47
48
49
50struct timezone sys_tz;
51
52EXPORT_SYMBOL(sys_tz);
53
54#ifdef __ARCH_WANT_SYS_TIME
55
56
57
58
59
60
61
62SYSCALL_DEFINE1(time, time_t __user *, tloc)
63{
64 time_t i = get_seconds();
65
66 if (tloc) {
67 if (put_user(i,tloc))
68 return -EFAULT;
69 }
70 force_successful_syscall_return();
71 return i;
72}
73
74
75
76
77
78
79
80
81SYSCALL_DEFINE1(stime, time_t __user *, tptr)
82{
83 struct timespec tv;
84 int err;
85
86 if (get_user(tv.tv_sec, tptr))
87 return -EFAULT;
88
89 tv.tv_nsec = 0;
90
91 err = security_settime(&tv, NULL);
92 if (err)
93 return err;
94
95 do_settimeofday(&tv);
96 return 0;
97}
98
99#endif
100
101SYSCALL_DEFINE2(gettimeofday, struct timeval __user *, tv,
102 struct timezone __user *, tz)
103{
104 if (likely(tv != NULL)) {
105 struct timeval ktv;
106 do_gettimeofday(&ktv);
107 if (copy_to_user(tv, &ktv, sizeof(ktv)))
108 return -EFAULT;
109 }
110 if (unlikely(tz != NULL)) {
111 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
112 return -EFAULT;
113 }
114 return 0;
115}
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133static inline void warp_clock(void)
134{
135 struct timespec adjust;
136
137 adjust = current_kernel_time();
138 adjust.tv_sec += sys_tz.tz_minuteswest * 60;
139 do_settimeofday(&adjust);
140}
141
142
143
144
145
146
147
148
149
150
151
152
153int do_sys_settimeofday(struct timespec *tv, struct timezone *tz)
154{
155 static int firsttime = 1;
156 int error = 0;
157
158 if (tv && !timespec_valid(tv))
159 return -EINVAL;
160
161 error = security_settime(tv, tz);
162 if (error)
163 return error;
164
165 if (tz) {
166
167 sys_tz = *tz;
168 update_vsyscall_tz();
169 if (firsttime) {
170 firsttime = 0;
171 if (!tv)
172 warp_clock();
173 }
174 }
175 if (tv)
176 {
177
178
179
180 return do_settimeofday(tv);
181 }
182 return 0;
183}
184
185SYSCALL_DEFINE2(settimeofday, struct timeval __user *, tv,
186 struct timezone __user *, tz)
187{
188 struct timeval user_tv;
189 struct timespec new_ts;
190 struct timezone new_tz;
191
192 if (tv) {
193 if (copy_from_user(&user_tv, tv, sizeof(*tv)))
194 return -EFAULT;
195 new_ts.tv_sec = user_tv.tv_sec;
196 new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
197 }
198 if (tz) {
199 if (copy_from_user(&new_tz, tz, sizeof(*tz)))
200 return -EFAULT;
201 }
202
203 return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
204}
205
206SYSCALL_DEFINE1(adjtimex, struct timex __user *, txc_p)
207{
208 struct timex txc;
209 int ret;
210
211
212
213
214
215 if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
216 return -EFAULT;
217 ret = do_adjtimex(&txc);
218 return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
219}
220
221
222
223
224
225
226
227
228struct timespec current_fs_time(struct super_block *sb)
229{
230 struct timespec now = current_kernel_time();
231 return timespec_trunc(now, sb->s_time_gran);
232}
233EXPORT_SYMBOL(current_fs_time);
234
235
236
237
238
239
240
241inline unsigned int jiffies_to_msecs(const unsigned long j)
242{
243#if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
244 return (MSEC_PER_SEC / HZ) * j;
245#elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
246 return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
247#else
248# if BITS_PER_LONG == 32
249 return (HZ_TO_MSEC_MUL32 * j) >> HZ_TO_MSEC_SHR32;
250# else
251 return (j * HZ_TO_MSEC_NUM) / HZ_TO_MSEC_DEN;
252# endif
253#endif
254}
255EXPORT_SYMBOL(jiffies_to_msecs);
256
257inline unsigned int jiffies_to_usecs(const unsigned long j)
258{
259#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
260 return (USEC_PER_SEC / HZ) * j;
261#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
262 return (j + (HZ / USEC_PER_SEC) - 1)/(HZ / USEC_PER_SEC);
263#else
264# if BITS_PER_LONG == 32
265 return (HZ_TO_USEC_MUL32 * j) >> HZ_TO_USEC_SHR32;
266# else
267 return (j * HZ_TO_USEC_NUM) / HZ_TO_USEC_DEN;
268# endif
269#endif
270}
271EXPORT_SYMBOL(jiffies_to_usecs);
272
273
274
275
276
277
278
279
280
281
282
283
284
285struct timespec timespec_trunc(struct timespec t, unsigned gran)
286{
287
288
289
290
291
292 if (gran <= jiffies_to_usecs(1) * 1000) {
293
294 } else if (gran == 1000000000) {
295 t.tv_nsec = 0;
296 } else {
297 t.tv_nsec -= t.tv_nsec % gran;
298 }
299 return t;
300}
301EXPORT_SYMBOL(timespec_trunc);
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318unsigned long
319mktime(const unsigned int year0, const unsigned int mon0,
320 const unsigned int day, const unsigned int hour,
321 const unsigned int min, const unsigned int sec)
322{
323 unsigned int mon = mon0, year = year0;
324
325
326 if (0 >= (int) (mon -= 2)) {
327 mon += 12;
328 year -= 1;
329 }
330
331 return ((((unsigned long)
332 (year/4 - year/100 + year/400 + 367*mon/12 + day) +
333 year*365 - 719499
334 )*24 + hour
335 )*60 + min
336 )*60 + sec;
337}
338
339EXPORT_SYMBOL(mktime);
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec)
356{
357 while (nsec >= NSEC_PER_SEC) {
358
359
360
361
362
363 asm("" : "+rm"(nsec));
364 nsec -= NSEC_PER_SEC;
365 ++sec;
366 }
367 while (nsec < 0) {
368 asm("" : "+rm"(nsec));
369 nsec += NSEC_PER_SEC;
370 --sec;
371 }
372 ts->tv_sec = sec;
373 ts->tv_nsec = nsec;
374}
375EXPORT_SYMBOL(set_normalized_timespec);
376
377
378
379
380
381
382
383struct timespec ns_to_timespec(const s64 nsec)
384{
385 struct timespec ts;
386 s32 rem;
387
388 if (!nsec)
389 return (struct timespec) {0, 0};
390
391 ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
392 if (unlikely(rem < 0)) {
393 ts.tv_sec--;
394 rem += NSEC_PER_SEC;
395 }
396 ts.tv_nsec = rem;
397
398 return ts;
399}
400EXPORT_SYMBOL(ns_to_timespec);
401
402
403
404
405
406
407
408struct timeval ns_to_timeval(const s64 nsec)
409{
410 struct timespec ts = ns_to_timespec(nsec);
411 struct timeval tv;
412
413 tv.tv_sec = ts.tv_sec;
414 tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
415
416 return tv;
417}
418EXPORT_SYMBOL(ns_to_timeval);
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434unsigned long msecs_to_jiffies(const unsigned int m)
435{
436
437
438
439 if ((int)m < 0)
440 return MAX_JIFFY_OFFSET;
441
442#if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
443
444
445
446
447
448 return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
449#elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
450
451
452
453
454
455
456
457 if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
458 return MAX_JIFFY_OFFSET;
459
460 return m * (HZ / MSEC_PER_SEC);
461#else
462
463
464
465
466
467 if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
468 return MAX_JIFFY_OFFSET;
469
470 return (MSEC_TO_HZ_MUL32 * m + MSEC_TO_HZ_ADJ32)
471 >> MSEC_TO_HZ_SHR32;
472#endif
473}
474EXPORT_SYMBOL(msecs_to_jiffies);
475
476unsigned long usecs_to_jiffies(const unsigned int u)
477{
478 if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
479 return MAX_JIFFY_OFFSET;
480#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
481 return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
482#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
483 return u * (HZ / USEC_PER_SEC);
484#else
485 return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32)
486 >> USEC_TO_HZ_SHR32;
487#endif
488}
489EXPORT_SYMBOL(usecs_to_jiffies);
490
491
492
493
494
495
496
497
498
499
500
501
502unsigned long
503timespec_to_jiffies(const struct timespec *value)
504{
505 unsigned long sec = value->tv_sec;
506 long nsec = value->tv_nsec + TICK_NSEC - 1;
507
508 if (sec >= MAX_SEC_IN_JIFFIES){
509 sec = MAX_SEC_IN_JIFFIES;
510 nsec = 0;
511 }
512 return (((u64)sec * SEC_CONVERSION) +
513 (((u64)nsec * NSEC_CONVERSION) >>
514 (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
515
516}
517EXPORT_SYMBOL(timespec_to_jiffies);
518
519void
520jiffies_to_timespec(const unsigned long jiffies, struct timespec *value)
521{
522
523
524
525
526 u32 rem;
527 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
528 NSEC_PER_SEC, &rem);
529 value->tv_nsec = rem;
530}
531EXPORT_SYMBOL(jiffies_to_timespec);
532
533
534
535
536
537
538
539
540
541
542
543
544
545unsigned long
546timeval_to_jiffies(const struct timeval *value)
547{
548 unsigned long sec = value->tv_sec;
549 long usec = value->tv_usec;
550
551 if (sec >= MAX_SEC_IN_JIFFIES){
552 sec = MAX_SEC_IN_JIFFIES;
553 usec = 0;
554 }
555 return (((u64)sec * SEC_CONVERSION) +
556 (((u64)usec * USEC_CONVERSION + USEC_ROUND) >>
557 (USEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
558}
559EXPORT_SYMBOL(timeval_to_jiffies);
560
561void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
562{
563
564
565
566
567 u32 rem;
568
569 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
570 NSEC_PER_SEC, &rem);
571 value->tv_usec = rem / NSEC_PER_USEC;
572}
573EXPORT_SYMBOL(jiffies_to_timeval);
574
575
576
577
578clock_t jiffies_to_clock_t(long x)
579{
580#if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
581# if HZ < USER_HZ
582 return x * (USER_HZ / HZ);
583# else
584 return x / (HZ / USER_HZ);
585# endif
586#else
587 return div_u64((u64)x * TICK_NSEC, NSEC_PER_SEC / USER_HZ);
588#endif
589}
590EXPORT_SYMBOL(jiffies_to_clock_t);
591
592unsigned long clock_t_to_jiffies(unsigned long x)
593{
594#if (HZ % USER_HZ)==0
595 if (x >= ~0UL / (HZ / USER_HZ))
596 return ~0UL;
597 return x * (HZ / USER_HZ);
598#else
599
600 if (x >= ~0UL / HZ * USER_HZ)
601 return ~0UL;
602
603
604 return div_u64((u64)x * HZ, USER_HZ);
605#endif
606}
607EXPORT_SYMBOL(clock_t_to_jiffies);
608
609u64 jiffies_64_to_clock_t(u64 x)
610{
611#if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
612# if HZ < USER_HZ
613 x = div_u64(x * USER_HZ, HZ);
614# elif HZ > USER_HZ
615 x = div_u64(x, HZ / USER_HZ);
616# else
617
618# endif
619#else
620
621
622
623
624
625 x = div_u64(x * TICK_NSEC, (NSEC_PER_SEC / USER_HZ));
626#endif
627 return x;
628}
629EXPORT_SYMBOL(jiffies_64_to_clock_t);
630
631u64 nsec_to_clock_t(u64 x)
632{
633#if (NSEC_PER_SEC % USER_HZ) == 0
634 return div_u64(x, NSEC_PER_SEC / USER_HZ);
635#elif (USER_HZ % 512) == 0
636 return div_u64(x * USER_HZ / 512, NSEC_PER_SEC / 512);
637#else
638
639
640
641
642
643 return div_u64(x * 9, (9ull * NSEC_PER_SEC + (USER_HZ / 2)) / USER_HZ);
644#endif
645}
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660unsigned long nsecs_to_jiffies(u64 n)
661{
662#if (NSEC_PER_SEC % HZ) == 0
663
664 return div_u64(n, NSEC_PER_SEC / HZ);
665#elif (HZ % 512) == 0
666
667 return div_u64(n * HZ / 512, NSEC_PER_SEC / 512);
668#else
669
670
671
672
673 return div_u64(n * 9, (9ull * NSEC_PER_SEC + HZ / 2) / HZ);
674#endif
675}
676
677#if (BITS_PER_LONG < 64)
678u64 get_jiffies_64(void)
679{
680 unsigned long seq;
681 u64 ret;
682
683 do {
684 seq = read_seqbegin(&xtime_lock);
685 ret = jiffies_64;
686 } while (read_seqretry(&xtime_lock, seq));
687 return ret;
688}
689EXPORT_SYMBOL(get_jiffies_64);
690#endif
691
692EXPORT_SYMBOL(jiffies);
693
694
695
696
697
698struct timespec timespec_add_safe(const struct timespec lhs,
699 const struct timespec rhs)
700{
701 struct timespec res;
702
703 set_normalized_timespec(&res, lhs.tv_sec + rhs.tv_sec,
704 lhs.tv_nsec + rhs.tv_nsec);
705
706 if (res.tv_sec < lhs.tv_sec || res.tv_sec < rhs.tv_sec)
707 res.tv_sec = TIME_T_MAX;
708
709 return res;
710}
711