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/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
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(const struct timespec *tv, const 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 sys_tz = *tz;
167 update_vsyscall_tz();
168 if (firsttime) {
169 firsttime = 0;
170 if (!tv)
171 warp_clock();
172 }
173 }
174 if (tv)
175 return do_settimeofday(tv);
176 return 0;
177}
178
179SYSCALL_DEFINE2(settimeofday, struct timeval __user *, tv,
180 struct timezone __user *, tz)
181{
182 struct timeval user_tv;
183 struct timespec new_ts;
184 struct timezone new_tz;
185
186 if (tv) {
187 if (copy_from_user(&user_tv, tv, sizeof(*tv)))
188 return -EFAULT;
189 new_ts.tv_sec = user_tv.tv_sec;
190 new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
191 }
192 if (tz) {
193 if (copy_from_user(&new_tz, tz, sizeof(*tz)))
194 return -EFAULT;
195 }
196
197 return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
198}
199
200SYSCALL_DEFINE1(adjtimex, struct timex __user *, txc_p)
201{
202 struct timex txc;
203 int ret;
204
205
206
207
208
209 if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
210 return -EFAULT;
211 ret = do_adjtimex(&txc);
212 return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
213}
214
215
216
217
218
219
220
221
222struct timespec current_fs_time(struct super_block *sb)
223{
224 struct timespec now = current_kernel_time();
225 return timespec_trunc(now, sb->s_time_gran);
226}
227EXPORT_SYMBOL(current_fs_time);
228
229
230
231
232
233
234
235inline unsigned int jiffies_to_msecs(const unsigned long j)
236{
237#if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
238 return (MSEC_PER_SEC / HZ) * j;
239#elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
240 return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
241#else
242# if BITS_PER_LONG == 32
243 return (HZ_TO_MSEC_MUL32 * j) >> HZ_TO_MSEC_SHR32;
244# else
245 return (j * HZ_TO_MSEC_NUM) / HZ_TO_MSEC_DEN;
246# endif
247#endif
248}
249EXPORT_SYMBOL(jiffies_to_msecs);
250
251inline unsigned int jiffies_to_usecs(const unsigned long j)
252{
253#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
254 return (USEC_PER_SEC / HZ) * j;
255#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
256 return (j + (HZ / USEC_PER_SEC) - 1)/(HZ / USEC_PER_SEC);
257#else
258# if BITS_PER_LONG == 32
259 return (HZ_TO_USEC_MUL32 * j) >> HZ_TO_USEC_SHR32;
260# else
261 return (j * HZ_TO_USEC_NUM) / HZ_TO_USEC_DEN;
262# endif
263#endif
264}
265EXPORT_SYMBOL(jiffies_to_usecs);
266
267
268
269
270
271
272
273
274
275
276
277
278
279struct timespec timespec_trunc(struct timespec t, unsigned gran)
280{
281
282
283
284
285
286 if (gran <= jiffies_to_usecs(1) * 1000) {
287
288 } else if (gran == 1000000000) {
289 t.tv_nsec = 0;
290 } else {
291 t.tv_nsec -= t.tv_nsec % gran;
292 }
293 return t;
294}
295EXPORT_SYMBOL(timespec_trunc);
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312unsigned long
313mktime(const unsigned int year0, const unsigned int mon0,
314 const unsigned int day, const unsigned int hour,
315 const unsigned int min, const unsigned int sec)
316{
317 unsigned int mon = mon0, year = year0;
318
319
320 if (0 >= (int) (mon -= 2)) {
321 mon += 12;
322 year -= 1;
323 }
324
325 return ((((unsigned long)
326 (year/4 - year/100 + year/400 + 367*mon/12 + day) +
327 year*365 - 719499
328 )*24 + hour
329 )*60 + min
330 )*60 + sec;
331}
332
333EXPORT_SYMBOL(mktime);
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec)
350{
351 while (nsec >= NSEC_PER_SEC) {
352
353
354
355
356
357 asm("" : "+rm"(nsec));
358 nsec -= NSEC_PER_SEC;
359 ++sec;
360 }
361 while (nsec < 0) {
362 asm("" : "+rm"(nsec));
363 nsec += NSEC_PER_SEC;
364 --sec;
365 }
366 ts->tv_sec = sec;
367 ts->tv_nsec = nsec;
368}
369EXPORT_SYMBOL(set_normalized_timespec);
370
371
372
373
374
375
376
377struct timespec ns_to_timespec(const s64 nsec)
378{
379 struct timespec ts;
380 s32 rem;
381
382 if (!nsec)
383 return (struct timespec) {0, 0};
384
385 ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
386 if (unlikely(rem < 0)) {
387 ts.tv_sec--;
388 rem += NSEC_PER_SEC;
389 }
390 ts.tv_nsec = rem;
391
392 return ts;
393}
394EXPORT_SYMBOL(ns_to_timespec);
395
396
397
398
399
400
401
402struct timeval ns_to_timeval(const s64 nsec)
403{
404 struct timespec ts = ns_to_timespec(nsec);
405 struct timeval tv;
406
407 tv.tv_sec = ts.tv_sec;
408 tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
409
410 return tv;
411}
412EXPORT_SYMBOL(ns_to_timeval);
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428unsigned long msecs_to_jiffies(const unsigned int m)
429{
430
431
432
433 if ((int)m < 0)
434 return MAX_JIFFY_OFFSET;
435
436#if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
437
438
439
440
441
442 return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
443#elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
444
445
446
447
448
449
450
451 if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
452 return MAX_JIFFY_OFFSET;
453
454 return m * (HZ / MSEC_PER_SEC);
455#else
456
457
458
459
460
461 if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
462 return MAX_JIFFY_OFFSET;
463
464 return (MSEC_TO_HZ_MUL32 * m + MSEC_TO_HZ_ADJ32)
465 >> MSEC_TO_HZ_SHR32;
466#endif
467}
468EXPORT_SYMBOL(msecs_to_jiffies);
469
470unsigned long usecs_to_jiffies(const unsigned int u)
471{
472 if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
473 return MAX_JIFFY_OFFSET;
474#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
475 return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
476#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
477 return u * (HZ / USEC_PER_SEC);
478#else
479 return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32)
480 >> USEC_TO_HZ_SHR32;
481#endif
482}
483EXPORT_SYMBOL(usecs_to_jiffies);
484
485
486
487
488
489
490
491
492
493
494
495
496unsigned long
497timespec_to_jiffies(const struct timespec *value)
498{
499 unsigned long sec = value->tv_sec;
500 long nsec = value->tv_nsec + TICK_NSEC - 1;
501
502 if (sec >= MAX_SEC_IN_JIFFIES){
503 sec = MAX_SEC_IN_JIFFIES;
504 nsec = 0;
505 }
506 return (((u64)sec * SEC_CONVERSION) +
507 (((u64)nsec * NSEC_CONVERSION) >>
508 (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
509
510}
511EXPORT_SYMBOL(timespec_to_jiffies);
512
513void
514jiffies_to_timespec(const unsigned long jiffies, struct timespec *value)
515{
516
517
518
519
520 u32 rem;
521 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
522 NSEC_PER_SEC, &rem);
523 value->tv_nsec = rem;
524}
525EXPORT_SYMBOL(jiffies_to_timespec);
526
527
528
529
530
531
532
533
534
535
536
537
538
539unsigned long
540timeval_to_jiffies(const struct timeval *value)
541{
542 unsigned long sec = value->tv_sec;
543 long usec = value->tv_usec;
544
545 if (sec >= MAX_SEC_IN_JIFFIES){
546 sec = MAX_SEC_IN_JIFFIES;
547 usec = 0;
548 }
549 return (((u64)sec * SEC_CONVERSION) +
550 (((u64)usec * USEC_CONVERSION + USEC_ROUND) >>
551 (USEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
552}
553EXPORT_SYMBOL(timeval_to_jiffies);
554
555void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
556{
557
558
559
560
561 u32 rem;
562
563 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
564 NSEC_PER_SEC, &rem);
565 value->tv_usec = rem / NSEC_PER_USEC;
566}
567EXPORT_SYMBOL(jiffies_to_timeval);
568
569
570
571
572clock_t jiffies_to_clock_t(unsigned long x)
573{
574#if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
575# if HZ < USER_HZ
576 return x * (USER_HZ / HZ);
577# else
578 return x / (HZ / USER_HZ);
579# endif
580#else
581 return div_u64((u64)x * TICK_NSEC, NSEC_PER_SEC / USER_HZ);
582#endif
583}
584EXPORT_SYMBOL(jiffies_to_clock_t);
585
586unsigned long clock_t_to_jiffies(unsigned long x)
587{
588#if (HZ % USER_HZ)==0
589 if (x >= ~0UL / (HZ / USER_HZ))
590 return ~0UL;
591 return x * (HZ / USER_HZ);
592#else
593
594 if (x >= ~0UL / HZ * USER_HZ)
595 return ~0UL;
596
597
598 return div_u64((u64)x * HZ, USER_HZ);
599#endif
600}
601EXPORT_SYMBOL(clock_t_to_jiffies);
602
603u64 jiffies_64_to_clock_t(u64 x)
604{
605#if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
606# if HZ < USER_HZ
607 x = div_u64(x * USER_HZ, HZ);
608# elif HZ > USER_HZ
609 x = div_u64(x, HZ / USER_HZ);
610# else
611
612# endif
613#else
614
615
616
617
618
619 x = div_u64(x * TICK_NSEC, (NSEC_PER_SEC / USER_HZ));
620#endif
621 return x;
622}
623EXPORT_SYMBOL(jiffies_64_to_clock_t);
624
625u64 nsec_to_clock_t(u64 x)
626{
627#if (NSEC_PER_SEC % USER_HZ) == 0
628 return div_u64(x, NSEC_PER_SEC / USER_HZ);
629#elif (USER_HZ % 512) == 0
630 return div_u64(x * USER_HZ / 512, NSEC_PER_SEC / 512);
631#else
632
633
634
635
636
637 return div_u64(x * 9, (9ull * NSEC_PER_SEC + (USER_HZ / 2)) / USER_HZ);
638#endif
639}
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654u64 nsecs_to_jiffies64(u64 n)
655{
656#if (NSEC_PER_SEC % HZ) == 0
657
658 return div_u64(n, NSEC_PER_SEC / HZ);
659#elif (HZ % 512) == 0
660
661 return div_u64(n * HZ / 512, NSEC_PER_SEC / 512);
662#else
663
664
665
666
667 return div_u64(n * 9, (9ull * NSEC_PER_SEC + HZ / 2) / HZ);
668#endif
669}
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684unsigned long nsecs_to_jiffies(u64 n)
685{
686 return (unsigned long)nsecs_to_jiffies64(n);
687}
688
689
690
691
692
693struct timespec timespec_add_safe(const struct timespec lhs,
694 const struct timespec rhs)
695{
696 struct timespec res;
697
698 set_normalized_timespec(&res, lhs.tv_sec + rhs.tv_sec,
699 lhs.tv_nsec + rhs.tv_nsec);
700
701 if (res.tv_sec < lhs.tv_sec || res.tv_sec < rhs.tv_sec)
702 res.tv_sec = TIME_T_MAX;
703
704 return res;
705}
706