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
39#include <asm/uaccess.h>
40#include <asm/unistd.h>
41
42
43
44
45
46struct timezone sys_tz;
47
48EXPORT_SYMBOL(sys_tz);
49
50#ifdef __ARCH_WANT_SYS_TIME
51
52
53
54
55
56
57
58asmlinkage long sys_time(time_t __user * tloc)
59{
60 time_t i = get_seconds();
61
62 if (tloc) {
63 if (put_user(i,tloc))
64 i = -EFAULT;
65 }
66 return i;
67}
68
69
70
71
72
73
74
75
76asmlinkage long sys_stime(time_t __user *tptr)
77{
78 struct timespec tv;
79 int err;
80
81 if (get_user(tv.tv_sec, tptr))
82 return -EFAULT;
83
84 tv.tv_nsec = 0;
85
86 err = security_settime(&tv, NULL);
87 if (err)
88 return err;
89
90 do_settimeofday(&tv);
91 return 0;
92}
93
94#endif
95
96asmlinkage long sys_gettimeofday(struct timeval __user *tv, struct timezone __user *tz)
97{
98 if (likely(tv != NULL)) {
99 struct timeval ktv;
100 do_gettimeofday(&ktv);
101 if (copy_to_user(tv, &ktv, sizeof(ktv)))
102 return -EFAULT;
103 }
104 if (unlikely(tz != NULL)) {
105 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
106 return -EFAULT;
107 }
108 return 0;
109}
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127static inline void warp_clock(void)
128{
129 write_seqlock_irq(&xtime_lock);
130 wall_to_monotonic.tv_sec -= sys_tz.tz_minuteswest * 60;
131 xtime.tv_sec += sys_tz.tz_minuteswest * 60;
132 write_sequnlock_irq(&xtime_lock);
133 clock_was_set();
134}
135
136
137
138
139
140
141
142
143
144
145
146
147int do_sys_settimeofday(struct timespec *tv, struct timezone *tz)
148{
149 static int firsttime = 1;
150 int error = 0;
151
152 if (tv && !timespec_valid(tv))
153 return -EINVAL;
154
155 error = security_settime(tv, tz);
156 if (error)
157 return error;
158
159 if (tz) {
160
161 sys_tz = *tz;
162 update_vsyscall_tz();
163 if (firsttime) {
164 firsttime = 0;
165 if (!tv)
166 warp_clock();
167 }
168 }
169 if (tv)
170 {
171
172
173
174 return do_settimeofday(tv);
175 }
176 return 0;
177}
178
179asmlinkage long sys_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
200asmlinkage long sys_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
235unsigned int inline 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 return (j * MSEC_PER_SEC) / HZ;
243#endif
244}
245EXPORT_SYMBOL(jiffies_to_msecs);
246
247unsigned int inline jiffies_to_usecs(const unsigned long j)
248{
249#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
250 return (USEC_PER_SEC / HZ) * j;
251#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
252 return (j + (HZ / USEC_PER_SEC) - 1)/(HZ / USEC_PER_SEC);
253#else
254 return (j * USEC_PER_SEC) / HZ;
255#endif
256}
257EXPORT_SYMBOL(jiffies_to_usecs);
258
259
260
261
262
263
264
265
266
267
268
269
270
271struct timespec timespec_trunc(struct timespec t, unsigned gran)
272{
273
274
275
276
277
278 if (gran <= jiffies_to_usecs(1) * 1000) {
279
280 } else if (gran == 1000000000) {
281 t.tv_nsec = 0;
282 } else {
283 t.tv_nsec -= t.tv_nsec % gran;
284 }
285 return t;
286}
287EXPORT_SYMBOL(timespec_trunc);
288
289#ifndef CONFIG_GENERIC_TIME
290
291
292
293
294void getnstimeofday(struct timespec *tv)
295{
296 struct timeval x;
297
298 do_gettimeofday(&x);
299 tv->tv_sec = x.tv_sec;
300 tv->tv_nsec = x.tv_usec * NSEC_PER_USEC;
301}
302EXPORT_SYMBOL_GPL(getnstimeofday);
303#endif
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320unsigned long
321mktime(const unsigned int year0, const unsigned int mon0,
322 const unsigned int day, const unsigned int hour,
323 const unsigned int min, const unsigned int sec)
324{
325 unsigned int mon = mon0, year = year0;
326
327
328 if (0 >= (int) (mon -= 2)) {
329 mon += 12;
330 year -= 1;
331 }
332
333 return ((((unsigned long)
334 (year/4 - year/100 + year/400 + 367*mon/12 + day) +
335 year*365 - 719499
336 )*24 + hour
337 )*60 + min
338 )*60 + sec;
339}
340
341EXPORT_SYMBOL(mktime);
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec)
358{
359 while (nsec >= NSEC_PER_SEC) {
360 nsec -= NSEC_PER_SEC;
361 ++sec;
362 }
363 while (nsec < 0) {
364 nsec += NSEC_PER_SEC;
365 --sec;
366 }
367 ts->tv_sec = sec;
368 ts->tv_nsec = nsec;
369}
370
371
372
373
374
375
376
377struct timespec ns_to_timespec(const s64 nsec)
378{
379 struct timespec ts;
380
381 if (!nsec)
382 return (struct timespec) {0, 0};
383
384 ts.tv_sec = div_long_long_rem_signed(nsec, NSEC_PER_SEC, &ts.tv_nsec);
385 if (unlikely(nsec < 0))
386 set_normalized_timespec(&ts, ts.tv_sec, ts.tv_nsec);
387
388 return ts;
389}
390EXPORT_SYMBOL(ns_to_timespec);
391
392
393
394
395
396
397
398struct timeval ns_to_timeval(const s64 nsec)
399{
400 struct timespec ts = ns_to_timespec(nsec);
401 struct timeval tv;
402
403 tv.tv_sec = ts.tv_sec;
404 tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
405
406 return tv;
407}
408EXPORT_SYMBOL(ns_to_timeval);
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424unsigned long msecs_to_jiffies(const unsigned int m)
425{
426
427
428
429 if ((int)m < 0)
430 return MAX_JIFFY_OFFSET;
431
432#if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
433
434
435
436
437
438 return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
439#elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
440
441
442
443
444
445
446
447 if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
448 return MAX_JIFFY_OFFSET;
449
450 return m * (HZ / MSEC_PER_SEC);
451#else
452
453
454
455
456
457 if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
458 return MAX_JIFFY_OFFSET;
459
460 return (m * HZ + MSEC_PER_SEC - 1) / MSEC_PER_SEC;
461#endif
462}
463EXPORT_SYMBOL(msecs_to_jiffies);
464
465unsigned long usecs_to_jiffies(const unsigned int u)
466{
467 if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
468 return MAX_JIFFY_OFFSET;
469#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
470 return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
471#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
472 return u * (HZ / USEC_PER_SEC);
473#else
474 return (u * HZ + USEC_PER_SEC - 1) / USEC_PER_SEC;
475#endif
476}
477EXPORT_SYMBOL(usecs_to_jiffies);
478
479
480
481
482
483
484
485
486
487
488
489
490unsigned long
491timespec_to_jiffies(const struct timespec *value)
492{
493 unsigned long sec = value->tv_sec;
494 long nsec = value->tv_nsec + TICK_NSEC - 1;
495
496 if (sec >= MAX_SEC_IN_JIFFIES){
497 sec = MAX_SEC_IN_JIFFIES;
498 nsec = 0;
499 }
500 return (((u64)sec * SEC_CONVERSION) +
501 (((u64)nsec * NSEC_CONVERSION) >>
502 (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
503
504}
505EXPORT_SYMBOL(timespec_to_jiffies);
506
507void
508jiffies_to_timespec(const unsigned long jiffies, struct timespec *value)
509{
510
511
512
513
514 u64 nsec = (u64)jiffies * TICK_NSEC;
515 value->tv_sec = div_long_long_rem(nsec, NSEC_PER_SEC, &value->tv_nsec);
516}
517EXPORT_SYMBOL(jiffies_to_timespec);
518
519
520
521
522
523
524
525
526
527
528
529
530
531unsigned long
532timeval_to_jiffies(const struct timeval *value)
533{
534 unsigned long sec = value->tv_sec;
535 long usec = value->tv_usec;
536
537 if (sec >= MAX_SEC_IN_JIFFIES){
538 sec = MAX_SEC_IN_JIFFIES;
539 usec = 0;
540 }
541 return (((u64)sec * SEC_CONVERSION) +
542 (((u64)usec * USEC_CONVERSION + USEC_ROUND) >>
543 (USEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
544}
545EXPORT_SYMBOL(timeval_to_jiffies);
546
547void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
548{
549
550
551
552
553 u64 nsec = (u64)jiffies * TICK_NSEC;
554 long tv_usec;
555
556 value->tv_sec = div_long_long_rem(nsec, NSEC_PER_SEC, &tv_usec);
557 tv_usec /= NSEC_PER_USEC;
558 value->tv_usec = tv_usec;
559}
560EXPORT_SYMBOL(jiffies_to_timeval);
561
562
563
564
565clock_t jiffies_to_clock_t(long x)
566{
567#if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
568 return x / (HZ / USER_HZ);
569#else
570 u64 tmp = (u64)x * TICK_NSEC;
571 do_div(tmp, (NSEC_PER_SEC / USER_HZ));
572 return (long)tmp;
573#endif
574}
575EXPORT_SYMBOL(jiffies_to_clock_t);
576
577unsigned long clock_t_to_jiffies(unsigned long x)
578{
579#if (HZ % USER_HZ)==0
580 if (x >= ~0UL / (HZ / USER_HZ))
581 return ~0UL;
582 return x * (HZ / USER_HZ);
583#else
584 u64 jif;
585
586
587 if (x >= ~0UL / HZ * USER_HZ)
588 return ~0UL;
589
590
591 jif = x * (u64) HZ;
592 do_div(jif, USER_HZ);
593 return jif;
594#endif
595}
596EXPORT_SYMBOL(clock_t_to_jiffies);
597
598u64 jiffies_64_to_clock_t(u64 x)
599{
600#if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
601 do_div(x, HZ / USER_HZ);
602#else
603
604
605
606
607
608 x *= TICK_NSEC;
609 do_div(x, (NSEC_PER_SEC / USER_HZ));
610#endif
611 return x;
612}
613
614EXPORT_SYMBOL(jiffies_64_to_clock_t);
615
616u64 nsec_to_clock_t(u64 x)
617{
618#if (NSEC_PER_SEC % USER_HZ) == 0
619 do_div(x, (NSEC_PER_SEC / USER_HZ));
620#elif (USER_HZ % 512) == 0
621 x *= USER_HZ/512;
622 do_div(x, (NSEC_PER_SEC / 512));
623#else
624
625
626
627
628
629 x *= 9;
630 do_div(x, (unsigned long)((9ull * NSEC_PER_SEC + (USER_HZ/2)) /
631 USER_HZ));
632#endif
633 return x;
634}
635
636#if (BITS_PER_LONG < 64)
637u64 get_jiffies_64(void)
638{
639 unsigned long seq;
640 u64 ret;
641
642 do {
643 seq = read_seqbegin(&xtime_lock);
644 ret = jiffies_64;
645 } while (read_seqretry(&xtime_lock, seq));
646 return ret;
647}
648
649EXPORT_SYMBOL(get_jiffies_64);
650#endif
651
652EXPORT_SYMBOL(jiffies);
653