~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/time/posix-timers.c

Version: ~ [ linux-5.3-rc5 ] ~ [ linux-5.2.9 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.67 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.139 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.72 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * linux/kernel/posix-timers.c
  3  *
  4  *
  5  * 2002-10-15  Posix Clocks & timers
  6  *                           by George Anzinger george@mvista.com
  7  *
  8  *                           Copyright (C) 2002 2003 by MontaVista Software.
  9  *
 10  * 2004-06-01  Fix CLOCK_REALTIME clock/timer TIMER_ABSTIME bug.
 11  *                           Copyright (C) 2004 Boris Hu
 12  *
 13  * This program is free software; you can redistribute it and/or modify
 14  * it under the terms of the GNU General Public License as published by
 15  * the Free Software Foundation; either version 2 of the License, or (at
 16  * your option) any later version.
 17  *
 18  * This program is distributed in the hope that it will be useful, but
 19  * WITHOUT ANY WARRANTY; without even the implied warranty of
 20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 21  * General Public License for more details.
 22 
 23  * You should have received a copy of the GNU General Public License
 24  * along with this program; if not, write to the Free Software
 25  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 26  *
 27  * MontaVista Software | 1237 East Arques Avenue | Sunnyvale | CA 94085 | USA
 28  */
 29 
 30 /* These are all the functions necessary to implement
 31  * POSIX clocks & timers
 32  */
 33 #include <linux/mm.h>
 34 #include <linux/interrupt.h>
 35 #include <linux/slab.h>
 36 #include <linux/time.h>
 37 #include <linux/mutex.h>
 38 #include <linux/sched/task.h>
 39 
 40 #include <linux/uaccess.h>
 41 #include <linux/list.h>
 42 #include <linux/init.h>
 43 #include <linux/compiler.h>
 44 #include <linux/hash.h>
 45 #include <linux/posix-clock.h>
 46 #include <linux/posix-timers.h>
 47 #include <linux/syscalls.h>
 48 #include <linux/wait.h>
 49 #include <linux/workqueue.h>
 50 #include <linux/export.h>
 51 #include <linux/hashtable.h>
 52 
 53 #include "timekeeping.h"
 54 
 55 /*
 56  * Management arrays for POSIX timers. Timers are now kept in static hash table
 57  * with 512 entries.
 58  * Timer ids are allocated by local routine, which selects proper hash head by
 59  * key, constructed from current->signal address and per signal struct counter.
 60  * This keeps timer ids unique per process, but now they can intersect between
 61  * processes.
 62  */
 63 
 64 /*
 65  * Lets keep our timers in a slab cache :-)
 66  */
 67 static struct kmem_cache *posix_timers_cache;
 68 
 69 static DEFINE_HASHTABLE(posix_timers_hashtable, 9);
 70 static DEFINE_SPINLOCK(hash_lock);
 71 
 72 /*
 73  * we assume that the new SIGEV_THREAD_ID shares no bits with the other
 74  * SIGEV values.  Here we put out an error if this assumption fails.
 75  */
 76 #if SIGEV_THREAD_ID != (SIGEV_THREAD_ID & \
 77                        ~(SIGEV_SIGNAL | SIGEV_NONE | SIGEV_THREAD))
 78 #error "SIGEV_THREAD_ID must not share bit with other SIGEV values!"
 79 #endif
 80 
 81 /*
 82  * parisc wants ENOTSUP instead of EOPNOTSUPP
 83  */
 84 #ifndef ENOTSUP
 85 # define ENANOSLEEP_NOTSUP EOPNOTSUPP
 86 #else
 87 # define ENANOSLEEP_NOTSUP ENOTSUP
 88 #endif
 89 
 90 /*
 91  * The timer ID is turned into a timer address by idr_find().
 92  * Verifying a valid ID consists of:
 93  *
 94  * a) checking that idr_find() returns other than -1.
 95  * b) checking that the timer id matches the one in the timer itself.
 96  * c) that the timer owner is in the callers thread group.
 97  */
 98 
 99 /*
100  * CLOCKs: The POSIX standard calls for a couple of clocks and allows us
101  *          to implement others.  This structure defines the various
102  *          clocks.
103  *
104  * RESOLUTION: Clock resolution is used to round up timer and interval
105  *          times, NOT to report clock times, which are reported with as
106  *          much resolution as the system can muster.  In some cases this
107  *          resolution may depend on the underlying clock hardware and
108  *          may not be quantifiable until run time, and only then is the
109  *          necessary code is written.  The standard says we should say
110  *          something about this issue in the documentation...
111  *
112  * FUNCTIONS: The CLOCKs structure defines possible functions to
113  *          handle various clock functions.
114  *
115  *          The standard POSIX timer management code assumes the
116  *          following: 1.) The k_itimer struct (sched.h) is used for
117  *          the timer.  2.) The list, it_lock, it_clock, it_id and
118  *          it_pid fields are not modified by timer code.
119  *
120  * Permissions: It is assumed that the clock_settime() function defined
121  *          for each clock will take care of permission checks.  Some
122  *          clocks may be set able by any user (i.e. local process
123  *          clocks) others not.  Currently the only set able clock we
124  *          have is CLOCK_REALTIME and its high res counter part, both of
125  *          which we beg off on and pass to do_sys_settimeofday().
126  */
127 
128 static struct k_clock posix_clocks[MAX_CLOCKS];
129 
130 /*
131  * These ones are defined below.
132  */
133 static int common_nsleep(const clockid_t, int flags, struct timespec *t,
134                          struct timespec __user *rmtp);
135 static int common_timer_create(struct k_itimer *new_timer);
136 static void common_timer_get(struct k_itimer *, struct itimerspec *);
137 static int common_timer_set(struct k_itimer *, int,
138                             struct itimerspec *, struct itimerspec *);
139 static int common_timer_del(struct k_itimer *timer);
140 
141 static enum hrtimer_restart posix_timer_fn(struct hrtimer *data);
142 
143 static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags);
144 
145 #define lock_timer(tid, flags)                                             \
146 ({      struct k_itimer *__timr;                                           \
147         __cond_lock(&__timr->it_lock, __timr = __lock_timer(tid, flags));  \
148         __timr;                                                            \
149 })
150 
151 static int hash(struct signal_struct *sig, unsigned int nr)
152 {
153         return hash_32(hash32_ptr(sig) ^ nr, HASH_BITS(posix_timers_hashtable));
154 }
155 
156 static struct k_itimer *__posix_timers_find(struct hlist_head *head,
157                                             struct signal_struct *sig,
158                                             timer_t id)
159 {
160         struct k_itimer *timer;
161 
162         hlist_for_each_entry_rcu(timer, head, t_hash) {
163                 if ((timer->it_signal == sig) && (timer->it_id == id))
164                         return timer;
165         }
166         return NULL;
167 }
168 
169 static struct k_itimer *posix_timer_by_id(timer_t id)
170 {
171         struct signal_struct *sig = current->signal;
172         struct hlist_head *head = &posix_timers_hashtable[hash(sig, id)];
173 
174         return __posix_timers_find(head, sig, id);
175 }
176 
177 static int posix_timer_add(struct k_itimer *timer)
178 {
179         struct signal_struct *sig = current->signal;
180         int first_free_id = sig->posix_timer_id;
181         struct hlist_head *head;
182         int ret = -ENOENT;
183 
184         do {
185                 spin_lock(&hash_lock);
186                 head = &posix_timers_hashtable[hash(sig, sig->posix_timer_id)];
187                 if (!__posix_timers_find(head, sig, sig->posix_timer_id)) {
188                         hlist_add_head_rcu(&timer->t_hash, head);
189                         ret = sig->posix_timer_id;
190                 }
191                 if (++sig->posix_timer_id < 0)
192                         sig->posix_timer_id = 0;
193                 if ((sig->posix_timer_id == first_free_id) && (ret == -ENOENT))
194                         /* Loop over all possible ids completed */
195                         ret = -EAGAIN;
196                 spin_unlock(&hash_lock);
197         } while (ret == -ENOENT);
198         return ret;
199 }
200 
201 static inline void unlock_timer(struct k_itimer *timr, unsigned long flags)
202 {
203         spin_unlock_irqrestore(&timr->it_lock, flags);
204 }
205 
206 /* Get clock_realtime */
207 static int posix_clock_realtime_get(clockid_t which_clock, struct timespec *tp)
208 {
209         ktime_get_real_ts(tp);
210         return 0;
211 }
212 
213 /* Set clock_realtime */
214 static int posix_clock_realtime_set(const clockid_t which_clock,
215                                     const struct timespec *tp)
216 {
217         return do_sys_settimeofday(tp, NULL);
218 }
219 
220 static int posix_clock_realtime_adj(const clockid_t which_clock,
221                                     struct timex *t)
222 {
223         return do_adjtimex(t);
224 }
225 
226 /*
227  * Get monotonic time for posix timers
228  */
229 static int posix_ktime_get_ts(clockid_t which_clock, struct timespec *tp)
230 {
231         ktime_get_ts(tp);
232         return 0;
233 }
234 
235 /*
236  * Get monotonic-raw time for posix timers
237  */
238 static int posix_get_monotonic_raw(clockid_t which_clock, struct timespec *tp)
239 {
240         getrawmonotonic(tp);
241         return 0;
242 }
243 
244 
245 static int posix_get_realtime_coarse(clockid_t which_clock, struct timespec *tp)
246 {
247         *tp = current_kernel_time();
248         return 0;
249 }
250 
251 static int posix_get_monotonic_coarse(clockid_t which_clock,
252                                                 struct timespec *tp)
253 {
254         *tp = get_monotonic_coarse();
255         return 0;
256 }
257 
258 static int posix_get_coarse_res(const clockid_t which_clock, struct timespec *tp)
259 {
260         *tp = ktime_to_timespec(KTIME_LOW_RES);
261         return 0;
262 }
263 
264 static int posix_get_boottime(const clockid_t which_clock, struct timespec *tp)
265 {
266         get_monotonic_boottime(tp);
267         return 0;
268 }
269 
270 static int posix_get_tai(clockid_t which_clock, struct timespec *tp)
271 {
272         timekeeping_clocktai(tp);
273         return 0;
274 }
275 
276 static int posix_get_hrtimer_res(clockid_t which_clock, struct timespec *tp)
277 {
278         tp->tv_sec = 0;
279         tp->tv_nsec = hrtimer_resolution;
280         return 0;
281 }
282 
283 /*
284  * Initialize everything, well, just everything in Posix clocks/timers ;)
285  */
286 static __init int init_posix_timers(void)
287 {
288         struct k_clock clock_realtime = {
289                 .clock_getres   = posix_get_hrtimer_res,
290                 .clock_get      = posix_clock_realtime_get,
291                 .clock_set      = posix_clock_realtime_set,
292                 .clock_adj      = posix_clock_realtime_adj,
293                 .nsleep         = common_nsleep,
294                 .nsleep_restart = hrtimer_nanosleep_restart,
295                 .timer_create   = common_timer_create,
296                 .timer_set      = common_timer_set,
297                 .timer_get      = common_timer_get,
298                 .timer_del      = common_timer_del,
299         };
300         struct k_clock clock_monotonic = {
301                 .clock_getres   = posix_get_hrtimer_res,
302                 .clock_get      = posix_ktime_get_ts,
303                 .nsleep         = common_nsleep,
304                 .nsleep_restart = hrtimer_nanosleep_restart,
305                 .timer_create   = common_timer_create,
306                 .timer_set      = common_timer_set,
307                 .timer_get      = common_timer_get,
308                 .timer_del      = common_timer_del,
309         };
310         struct k_clock clock_monotonic_raw = {
311                 .clock_getres   = posix_get_hrtimer_res,
312                 .clock_get      = posix_get_monotonic_raw,
313         };
314         struct k_clock clock_realtime_coarse = {
315                 .clock_getres   = posix_get_coarse_res,
316                 .clock_get      = posix_get_realtime_coarse,
317         };
318         struct k_clock clock_monotonic_coarse = {
319                 .clock_getres   = posix_get_coarse_res,
320                 .clock_get      = posix_get_monotonic_coarse,
321         };
322         struct k_clock clock_tai = {
323                 .clock_getres   = posix_get_hrtimer_res,
324                 .clock_get      = posix_get_tai,
325                 .nsleep         = common_nsleep,
326                 .nsleep_restart = hrtimer_nanosleep_restart,
327                 .timer_create   = common_timer_create,
328                 .timer_set      = common_timer_set,
329                 .timer_get      = common_timer_get,
330                 .timer_del      = common_timer_del,
331         };
332         struct k_clock clock_boottime = {
333                 .clock_getres   = posix_get_hrtimer_res,
334                 .clock_get      = posix_get_boottime,
335                 .nsleep         = common_nsleep,
336                 .nsleep_restart = hrtimer_nanosleep_restart,
337                 .timer_create   = common_timer_create,
338                 .timer_set      = common_timer_set,
339                 .timer_get      = common_timer_get,
340                 .timer_del      = common_timer_del,
341         };
342 
343         posix_timers_register_clock(CLOCK_REALTIME, &clock_realtime);
344         posix_timers_register_clock(CLOCK_MONOTONIC, &clock_monotonic);
345         posix_timers_register_clock(CLOCK_MONOTONIC_RAW, &clock_monotonic_raw);
346         posix_timers_register_clock(CLOCK_REALTIME_COARSE, &clock_realtime_coarse);
347         posix_timers_register_clock(CLOCK_MONOTONIC_COARSE, &clock_monotonic_coarse);
348         posix_timers_register_clock(CLOCK_BOOTTIME, &clock_boottime);
349         posix_timers_register_clock(CLOCK_TAI, &clock_tai);
350 
351         posix_timers_cache = kmem_cache_create("posix_timers_cache",
352                                         sizeof (struct k_itimer), 0, SLAB_PANIC,
353                                         NULL);
354         return 0;
355 }
356 
357 __initcall(init_posix_timers);
358 
359 static void schedule_next_timer(struct k_itimer *timr)
360 {
361         struct hrtimer *timer = &timr->it.real.timer;
362 
363         if (timr->it.real.interval == 0)
364                 return;
365 
366         timr->it_overrun += (unsigned int) hrtimer_forward(timer,
367                                                 timer->base->get_time(),
368                                                 timr->it.real.interval);
369 
370         timr->it_overrun_last = timr->it_overrun;
371         timr->it_overrun = -1;
372         ++timr->it_requeue_pending;
373         hrtimer_restart(timer);
374 }
375 
376 /*
377  * This function is exported for use by the signal deliver code.  It is
378  * called just prior to the info block being released and passes that
379  * block to us.  It's function is to update the overrun entry AND to
380  * restart the timer.  It should only be called if the timer is to be
381  * restarted (i.e. we have flagged this in the sys_private entry of the
382  * info block).
383  *
384  * To protect against the timer going away while the interrupt is queued,
385  * we require that the it_requeue_pending flag be set.
386  */
387 void do_schedule_next_timer(struct siginfo *info)
388 {
389         struct k_itimer *timr;
390         unsigned long flags;
391 
392         timr = lock_timer(info->si_tid, &flags);
393 
394         if (timr && timr->it_requeue_pending == info->si_sys_private) {
395                 if (timr->it_clock < 0)
396                         posix_cpu_timer_schedule(timr);
397                 else
398                         schedule_next_timer(timr);
399 
400                 info->si_overrun += timr->it_overrun_last;
401         }
402 
403         if (timr)
404                 unlock_timer(timr, flags);
405 }
406 
407 int posix_timer_event(struct k_itimer *timr, int si_private)
408 {
409         struct task_struct *task;
410         int shared, ret = -1;
411         /*
412          * FIXME: if ->sigq is queued we can race with
413          * dequeue_signal()->do_schedule_next_timer().
414          *
415          * If dequeue_signal() sees the "right" value of
416          * si_sys_private it calls do_schedule_next_timer().
417          * We re-queue ->sigq and drop ->it_lock().
418          * do_schedule_next_timer() locks the timer
419          * and re-schedules it while ->sigq is pending.
420          * Not really bad, but not that we want.
421          */
422         timr->sigq->info.si_sys_private = si_private;
423 
424         rcu_read_lock();
425         task = pid_task(timr->it_pid, PIDTYPE_PID);
426         if (task) {
427                 shared = !(timr->it_sigev_notify & SIGEV_THREAD_ID);
428                 ret = send_sigqueue(timr->sigq, task, shared);
429         }
430         rcu_read_unlock();
431         /* If we failed to send the signal the timer stops. */
432         return ret > 0;
433 }
434 EXPORT_SYMBOL_GPL(posix_timer_event);
435 
436 /*
437  * This function gets called when a POSIX.1b interval timer expires.  It
438  * is used as a callback from the kernel internal timer.  The
439  * run_timer_list code ALWAYS calls with interrupts on.
440 
441  * This code is for CLOCK_REALTIME* and CLOCK_MONOTONIC* timers.
442  */
443 static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer)
444 {
445         struct k_itimer *timr;
446         unsigned long flags;
447         int si_private = 0;
448         enum hrtimer_restart ret = HRTIMER_NORESTART;
449 
450         timr = container_of(timer, struct k_itimer, it.real.timer);
451         spin_lock_irqsave(&timr->it_lock, flags);
452 
453         if (timr->it.real.interval != 0)
454                 si_private = ++timr->it_requeue_pending;
455 
456         if (posix_timer_event(timr, si_private)) {
457                 /*
458                  * signal was not sent because of sig_ignor
459                  * we will not get a call back to restart it AND
460                  * it should be restarted.
461                  */
462                 if (timr->it.real.interval != 0) {
463                         ktime_t now = hrtimer_cb_get_time(timer);
464 
465                         /*
466                          * FIXME: What we really want, is to stop this
467                          * timer completely and restart it in case the
468                          * SIG_IGN is removed. This is a non trivial
469                          * change which involves sighand locking
470                          * (sigh !), which we don't want to do late in
471                          * the release cycle.
472                          *
473                          * For now we just let timers with an interval
474                          * less than a jiffie expire every jiffie to
475                          * avoid softirq starvation in case of SIG_IGN
476                          * and a very small interval, which would put
477                          * the timer right back on the softirq pending
478                          * list. By moving now ahead of time we trick
479                          * hrtimer_forward() to expire the timer
480                          * later, while we still maintain the overrun
481                          * accuracy, but have some inconsistency in
482                          * the timer_gettime() case. This is at least
483                          * better than a starved softirq. A more
484                          * complex fix which solves also another related
485                          * inconsistency is already in the pipeline.
486                          */
487 #ifdef CONFIG_HIGH_RES_TIMERS
488                         {
489                                 ktime_t kj = NSEC_PER_SEC / HZ;
490 
491                                 if (timr->it.real.interval < kj)
492                                         now = ktime_add(now, kj);
493                         }
494 #endif
495                         timr->it_overrun += (unsigned int)
496                                 hrtimer_forward(timer, now,
497                                                 timr->it.real.interval);
498                         ret = HRTIMER_RESTART;
499                         ++timr->it_requeue_pending;
500                 }
501         }
502 
503         unlock_timer(timr, flags);
504         return ret;
505 }
506 
507 static struct pid *good_sigevent(sigevent_t * event)
508 {
509         struct task_struct *rtn = current->group_leader;
510 
511         if ((event->sigev_notify & SIGEV_THREAD_ID ) &&
512                 (!(rtn = find_task_by_vpid(event->sigev_notify_thread_id)) ||
513                  !same_thread_group(rtn, current) ||
514                  (event->sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_SIGNAL))
515                 return NULL;
516 
517         if (((event->sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE) &&
518             ((event->sigev_signo <= 0) || (event->sigev_signo > SIGRTMAX)))
519                 return NULL;
520 
521         return task_pid(rtn);
522 }
523 
524 void posix_timers_register_clock(const clockid_t clock_id,
525                                  struct k_clock *new_clock)
526 {
527         if ((unsigned) clock_id >= MAX_CLOCKS) {
528                 printk(KERN_WARNING "POSIX clock register failed for clock_id %d\n",
529                        clock_id);
530                 return;
531         }
532 
533         if (!new_clock->clock_get) {
534                 printk(KERN_WARNING "POSIX clock id %d lacks clock_get()\n",
535                        clock_id);
536                 return;
537         }
538         if (!new_clock->clock_getres) {
539                 printk(KERN_WARNING "POSIX clock id %d lacks clock_getres()\n",
540                        clock_id);
541                 return;
542         }
543 
544         posix_clocks[clock_id] = *new_clock;
545 }
546 EXPORT_SYMBOL_GPL(posix_timers_register_clock);
547 
548 static struct k_itimer * alloc_posix_timer(void)
549 {
550         struct k_itimer *tmr;
551         tmr = kmem_cache_zalloc(posix_timers_cache, GFP_KERNEL);
552         if (!tmr)
553                 return tmr;
554         if (unlikely(!(tmr->sigq = sigqueue_alloc()))) {
555                 kmem_cache_free(posix_timers_cache, tmr);
556                 return NULL;
557         }
558         memset(&tmr->sigq->info, 0, sizeof(siginfo_t));
559         return tmr;
560 }
561 
562 static void k_itimer_rcu_free(struct rcu_head *head)
563 {
564         struct k_itimer *tmr = container_of(head, struct k_itimer, it.rcu);
565 
566         kmem_cache_free(posix_timers_cache, tmr);
567 }
568 
569 #define IT_ID_SET       1
570 #define IT_ID_NOT_SET   0
571 static void release_posix_timer(struct k_itimer *tmr, int it_id_set)
572 {
573         if (it_id_set) {
574                 unsigned long flags;
575                 spin_lock_irqsave(&hash_lock, flags);
576                 hlist_del_rcu(&tmr->t_hash);
577                 spin_unlock_irqrestore(&hash_lock, flags);
578         }
579         put_pid(tmr->it_pid);
580         sigqueue_free(tmr->sigq);
581         call_rcu(&tmr->it.rcu, k_itimer_rcu_free);
582 }
583 
584 static struct k_clock *clockid_to_kclock(const clockid_t id)
585 {
586         if (id < 0)
587                 return (id & CLOCKFD_MASK) == CLOCKFD ?
588                         &clock_posix_dynamic : &clock_posix_cpu;
589 
590         if (id >= MAX_CLOCKS || !posix_clocks[id].clock_getres)
591                 return NULL;
592         return &posix_clocks[id];
593 }
594 
595 static int common_timer_create(struct k_itimer *new_timer)
596 {
597         hrtimer_init(&new_timer->it.real.timer, new_timer->it_clock, 0);
598         return 0;
599 }
600 
601 /* Create a POSIX.1b interval timer. */
602 
603 SYSCALL_DEFINE3(timer_create, const clockid_t, which_clock,
604                 struct sigevent __user *, timer_event_spec,
605                 timer_t __user *, created_timer_id)
606 {
607         struct k_clock *kc = clockid_to_kclock(which_clock);
608         struct k_itimer *new_timer;
609         int error, new_timer_id;
610         sigevent_t event;
611         int it_id_set = IT_ID_NOT_SET;
612 
613         if (!kc)
614                 return -EINVAL;
615         if (!kc->timer_create)
616                 return -EOPNOTSUPP;
617 
618         new_timer = alloc_posix_timer();
619         if (unlikely(!new_timer))
620                 return -EAGAIN;
621 
622         spin_lock_init(&new_timer->it_lock);
623         new_timer_id = posix_timer_add(new_timer);
624         if (new_timer_id < 0) {
625                 error = new_timer_id;
626                 goto out;
627         }
628 
629         it_id_set = IT_ID_SET;
630         new_timer->it_id = (timer_t) new_timer_id;
631         new_timer->it_clock = which_clock;
632         new_timer->it_overrun = -1;
633 
634         if (timer_event_spec) {
635                 if (copy_from_user(&event, timer_event_spec, sizeof (event))) {
636                         error = -EFAULT;
637                         goto out;
638                 }
639                 rcu_read_lock();
640                 new_timer->it_pid = get_pid(good_sigevent(&event));
641                 rcu_read_unlock();
642                 if (!new_timer->it_pid) {
643                         error = -EINVAL;
644                         goto out;
645                 }
646         } else {
647                 memset(&event.sigev_value, 0, sizeof(event.sigev_value));
648                 event.sigev_notify = SIGEV_SIGNAL;
649                 event.sigev_signo = SIGALRM;
650                 event.sigev_value.sival_int = new_timer->it_id;
651                 new_timer->it_pid = get_pid(task_tgid(current));
652         }
653 
654         new_timer->it_sigev_notify     = event.sigev_notify;
655         new_timer->sigq->info.si_signo = event.sigev_signo;
656         new_timer->sigq->info.si_value = event.sigev_value;
657         new_timer->sigq->info.si_tid   = new_timer->it_id;
658         new_timer->sigq->info.si_code  = SI_TIMER;
659 
660         if (copy_to_user(created_timer_id,
661                          &new_timer_id, sizeof (new_timer_id))) {
662                 error = -EFAULT;
663                 goto out;
664         }
665 
666         error = kc->timer_create(new_timer);
667         if (error)
668                 goto out;
669 
670         spin_lock_irq(&current->sighand->siglock);
671         new_timer->it_signal = current->signal;
672         list_add(&new_timer->list, &current->signal->posix_timers);
673         spin_unlock_irq(&current->sighand->siglock);
674 
675         return 0;
676         /*
677          * In the case of the timer belonging to another task, after
678          * the task is unlocked, the timer is owned by the other task
679          * and may cease to exist at any time.  Don't use or modify
680          * new_timer after the unlock call.
681          */
682 out:
683         release_posix_timer(new_timer, it_id_set);
684         return error;
685 }
686 
687 /*
688  * Locking issues: We need to protect the result of the id look up until
689  * we get the timer locked down so it is not deleted under us.  The
690  * removal is done under the idr spinlock so we use that here to bridge
691  * the find to the timer lock.  To avoid a dead lock, the timer id MUST
692  * be release with out holding the timer lock.
693  */
694 static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags)
695 {
696         struct k_itimer *timr;
697 
698         /*
699          * timer_t could be any type >= int and we want to make sure any
700          * @timer_id outside positive int range fails lookup.
701          */
702         if ((unsigned long long)timer_id > INT_MAX)
703                 return NULL;
704 
705         rcu_read_lock();
706         timr = posix_timer_by_id(timer_id);
707         if (timr) {
708                 spin_lock_irqsave(&timr->it_lock, *flags);
709                 if (timr->it_signal == current->signal) {
710                         rcu_read_unlock();
711                         return timr;
712                 }
713                 spin_unlock_irqrestore(&timr->it_lock, *flags);
714         }
715         rcu_read_unlock();
716 
717         return NULL;
718 }
719 
720 /*
721  * Get the time remaining on a POSIX.1b interval timer.  This function
722  * is ALWAYS called with spin_lock_irq on the timer, thus it must not
723  * mess with irq.
724  *
725  * We have a couple of messes to clean up here.  First there is the case
726  * of a timer that has a requeue pending.  These timers should appear to
727  * be in the timer list with an expiry as if we were to requeue them
728  * now.
729  *
730  * The second issue is the SIGEV_NONE timer which may be active but is
731  * not really ever put in the timer list (to save system resources).
732  * This timer may be expired, and if so, we will do it here.  Otherwise
733  * it is the same as a requeue pending timer WRT to what we should
734  * report.
735  */
736 static void
737 common_timer_get(struct k_itimer *timr, struct itimerspec *cur_setting)
738 {
739         ktime_t now, remaining, iv;
740         struct hrtimer *timer = &timr->it.real.timer;
741 
742         memset(cur_setting, 0, sizeof(struct itimerspec));
743 
744         iv = timr->it.real.interval;
745 
746         /* interval timer ? */
747         if (iv)
748                 cur_setting->it_interval = ktime_to_timespec(iv);
749         else if (!hrtimer_active(timer) &&
750                  (timr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE)
751                 return;
752 
753         now = timer->base->get_time();
754 
755         /*
756          * When a requeue is pending or this is a SIGEV_NONE
757          * timer move the expiry time forward by intervals, so
758          * expiry is > now.
759          */
760         if (iv && (timr->it_requeue_pending & REQUEUE_PENDING ||
761                    (timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE))
762                 timr->it_overrun += (unsigned int) hrtimer_forward(timer, now, iv);
763 
764         remaining = __hrtimer_expires_remaining_adjusted(timer, now);
765         /* Return 0 only, when the timer is expired and not pending */
766         if (remaining <= 0) {
767                 /*
768                  * A single shot SIGEV_NONE timer must return 0, when
769                  * it is expired !
770                  */
771                 if ((timr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE)
772                         cur_setting->it_value.tv_nsec = 1;
773         } else
774                 cur_setting->it_value = ktime_to_timespec(remaining);
775 }
776 
777 /* Get the time remaining on a POSIX.1b interval timer. */
778 SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
779                 struct itimerspec __user *, setting)
780 {
781         struct itimerspec cur_setting;
782         struct k_itimer *timr;
783         struct k_clock *kc;
784         unsigned long flags;
785         int ret = 0;
786 
787         timr = lock_timer(timer_id, &flags);
788         if (!timr)
789                 return -EINVAL;
790 
791         kc = clockid_to_kclock(timr->it_clock);
792         if (WARN_ON_ONCE(!kc || !kc->timer_get))
793                 ret = -EINVAL;
794         else
795                 kc->timer_get(timr, &cur_setting);
796 
797         unlock_timer(timr, flags);
798 
799         if (!ret && copy_to_user(setting, &cur_setting, sizeof (cur_setting)))
800                 return -EFAULT;
801 
802         return ret;
803 }
804 
805 /*
806  * Get the number of overruns of a POSIX.1b interval timer.  This is to
807  * be the overrun of the timer last delivered.  At the same time we are
808  * accumulating overruns on the next timer.  The overrun is frozen when
809  * the signal is delivered, either at the notify time (if the info block
810  * is not queued) or at the actual delivery time (as we are informed by
811  * the call back to do_schedule_next_timer().  So all we need to do is
812  * to pick up the frozen overrun.
813  */
814 SYSCALL_DEFINE1(timer_getoverrun, timer_t, timer_id)
815 {
816         struct k_itimer *timr;
817         int overrun;
818         unsigned long flags;
819 
820         timr = lock_timer(timer_id, &flags);
821         if (!timr)
822                 return -EINVAL;
823 
824         overrun = timr->it_overrun_last;
825         unlock_timer(timr, flags);
826 
827         return overrun;
828 }
829 
830 /* Set a POSIX.1b interval timer. */
831 /* timr->it_lock is taken. */
832 static int
833 common_timer_set(struct k_itimer *timr, int flags,
834                  struct itimerspec *new_setting, struct itimerspec *old_setting)
835 {
836         struct hrtimer *timer = &timr->it.real.timer;
837         enum hrtimer_mode mode;
838 
839         if (old_setting)
840                 common_timer_get(timr, old_setting);
841 
842         /* disable the timer */
843         timr->it.real.interval = 0;
844         /*
845          * careful here.  If smp we could be in the "fire" routine which will
846          * be spinning as we hold the lock.  But this is ONLY an SMP issue.
847          */
848         if (hrtimer_try_to_cancel(timer) < 0)
849                 return TIMER_RETRY;
850 
851         timr->it_requeue_pending = (timr->it_requeue_pending + 2) & 
852                 ~REQUEUE_PENDING;
853         timr->it_overrun_last = 0;
854 
855         /* switch off the timer when it_value is zero */
856         if (!new_setting->it_value.tv_sec && !new_setting->it_value.tv_nsec)
857                 return 0;
858 
859         mode = flags & TIMER_ABSTIME ? HRTIMER_MODE_ABS : HRTIMER_MODE_REL;
860         hrtimer_init(&timr->it.real.timer, timr->it_clock, mode);
861         timr->it.real.timer.function = posix_timer_fn;
862 
863         hrtimer_set_expires(timer, timespec_to_ktime(new_setting->it_value));
864 
865         /* Convert interval */
866         timr->it.real.interval = timespec_to_ktime(new_setting->it_interval);
867 
868         /* SIGEV_NONE timers are not queued ! See common_timer_get */
869         if (((timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE)) {
870                 /* Setup correct expiry time for relative timers */
871                 if (mode == HRTIMER_MODE_REL) {
872                         hrtimer_add_expires(timer, timer->base->get_time());
873                 }
874                 return 0;
875         }
876 
877         hrtimer_start_expires(timer, mode);
878         return 0;
879 }
880 
881 /* Set a POSIX.1b interval timer */
882 SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
883                 const struct itimerspec __user *, new_setting,
884                 struct itimerspec __user *, old_setting)
885 {
886         struct k_itimer *timr;
887         struct itimerspec new_spec, old_spec;
888         int error = 0;
889         unsigned long flag;
890         struct itimerspec *rtn = old_setting ? &old_spec : NULL;
891         struct k_clock *kc;
892 
893         if (!new_setting)
894                 return -EINVAL;
895 
896         if (copy_from_user(&new_spec, new_setting, sizeof (new_spec)))
897                 return -EFAULT;
898 
899         if (!timespec_valid(&new_spec.it_interval) ||
900             !timespec_valid(&new_spec.it_value))
901                 return -EINVAL;
902 retry:
903         timr = lock_timer(timer_id, &flag);
904         if (!timr)
905                 return -EINVAL;
906 
907         kc = clockid_to_kclock(timr->it_clock);
908         if (WARN_ON_ONCE(!kc || !kc->timer_set))
909                 error = -EINVAL;
910         else
911                 error = kc->timer_set(timr, flags, &new_spec, rtn);
912 
913         unlock_timer(timr, flag);
914         if (error == TIMER_RETRY) {
915                 rtn = NULL;     // We already got the old time...
916                 goto retry;
917         }
918 
919         if (old_setting && !error &&
920             copy_to_user(old_setting, &old_spec, sizeof (old_spec)))
921                 error = -EFAULT;
922 
923         return error;
924 }
925 
926 static int common_timer_del(struct k_itimer *timer)
927 {
928         timer->it.real.interval = 0;
929 
930         if (hrtimer_try_to_cancel(&timer->it.real.timer) < 0)
931                 return TIMER_RETRY;
932         return 0;
933 }
934 
935 static inline int timer_delete_hook(struct k_itimer *timer)
936 {
937         struct k_clock *kc = clockid_to_kclock(timer->it_clock);
938 
939         if (WARN_ON_ONCE(!kc || !kc->timer_del))
940                 return -EINVAL;
941         return kc->timer_del(timer);
942 }
943 
944 /* Delete a POSIX.1b interval timer. */
945 SYSCALL_DEFINE1(timer_delete, timer_t, timer_id)
946 {
947         struct k_itimer *timer;
948         unsigned long flags;
949 
950 retry_delete:
951         timer = lock_timer(timer_id, &flags);
952         if (!timer)
953                 return -EINVAL;
954 
955         if (timer_delete_hook(timer) == TIMER_RETRY) {
956                 unlock_timer(timer, flags);
957                 goto retry_delete;
958         }
959 
960         spin_lock(&current->sighand->siglock);
961         list_del(&timer->list);
962         spin_unlock(&current->sighand->siglock);
963         /*
964          * This keeps any tasks waiting on the spin lock from thinking
965          * they got something (see the lock code above).
966          */
967         timer->it_signal = NULL;
968 
969         unlock_timer(timer, flags);
970         release_posix_timer(timer, IT_ID_SET);
971         return 0;
972 }
973 
974 /*
975  * return timer owned by the process, used by exit_itimers
976  */
977 static void itimer_delete(struct k_itimer *timer)
978 {
979         unsigned long flags;
980 
981 retry_delete:
982         spin_lock_irqsave(&timer->it_lock, flags);
983 
984         if (timer_delete_hook(timer) == TIMER_RETRY) {
985                 unlock_timer(timer, flags);
986                 goto retry_delete;
987         }
988         list_del(&timer->list);
989         /*
990          * This keeps any tasks waiting on the spin lock from thinking
991          * they got something (see the lock code above).
992          */
993         timer->it_signal = NULL;
994 
995         unlock_timer(timer, flags);
996         release_posix_timer(timer, IT_ID_SET);
997 }
998 
999 /*
1000  * This is called by do_exit or de_thread, only when there are no more
1001  * references to the shared signal_struct.
1002  */
1003 void exit_itimers(struct signal_struct *sig)
1004 {
1005         struct k_itimer *tmr;
1006 
1007         while (!list_empty(&sig->posix_timers)) {
1008                 tmr = list_entry(sig->posix_timers.next, struct k_itimer, list);
1009                 itimer_delete(tmr);
1010         }
1011 }
1012 
1013 SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock,
1014                 const struct timespec __user *, tp)
1015 {
1016         struct k_clock *kc = clockid_to_kclock(which_clock);
1017         struct timespec new_tp;
1018 
1019         if (!kc || !kc->clock_set)
1020                 return -EINVAL;
1021 
1022         if (copy_from_user(&new_tp, tp, sizeof (*tp)))
1023                 return -EFAULT;
1024 
1025         return kc->clock_set(which_clock, &new_tp);
1026 }
1027 
1028 SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,
1029                 struct timespec __user *,tp)
1030 {
1031         struct k_clock *kc = clockid_to_kclock(which_clock);
1032         struct timespec kernel_tp;
1033         int error;
1034 
1035         if (!kc)
1036                 return -EINVAL;
1037 
1038         error = kc->clock_get(which_clock, &kernel_tp);
1039 
1040         if (!error && copy_to_user(tp, &kernel_tp, sizeof (kernel_tp)))
1041                 error = -EFAULT;
1042 
1043         return error;
1044 }
1045 
1046 SYSCALL_DEFINE2(clock_adjtime, const clockid_t, which_clock,
1047                 struct timex __user *, utx)
1048 {
1049         struct k_clock *kc = clockid_to_kclock(which_clock);
1050         struct timex ktx;
1051         int err;
1052 
1053         if (!kc)
1054                 return -EINVAL;
1055         if (!kc->clock_adj)
1056                 return -EOPNOTSUPP;
1057 
1058         if (copy_from_user(&ktx, utx, sizeof(ktx)))
1059                 return -EFAULT;
1060 
1061         err = kc->clock_adj(which_clock, &ktx);
1062 
1063         if (err >= 0 && copy_to_user(utx, &ktx, sizeof(ktx)))
1064                 return -EFAULT;
1065 
1066         return err;
1067 }
1068 
1069 SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock,
1070                 struct timespec __user *, tp)
1071 {
1072         struct k_clock *kc = clockid_to_kclock(which_clock);
1073         struct timespec rtn_tp;
1074         int error;
1075 
1076         if (!kc)
1077                 return -EINVAL;
1078 
1079         error = kc->clock_getres(which_clock, &rtn_tp);
1080 
1081         if (!error && tp && copy_to_user(tp, &rtn_tp, sizeof (rtn_tp)))
1082                 error = -EFAULT;
1083 
1084         return error;
1085 }
1086 
1087 /*
1088  * nanosleep for monotonic and realtime clocks
1089  */
1090 static int common_nsleep(const clockid_t which_clock, int flags,
1091                          struct timespec *tsave, struct timespec __user *rmtp)
1092 {
1093         return hrtimer_nanosleep(tsave, rmtp, flags & TIMER_ABSTIME ?
1094                                  HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
1095                                  which_clock);
1096 }
1097 
1098 SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
1099                 const struct timespec __user *, rqtp,
1100                 struct timespec __user *, rmtp)
1101 {
1102         struct k_clock *kc = clockid_to_kclock(which_clock);
1103         struct timespec t;
1104 
1105         if (!kc)
1106                 return -EINVAL;
1107         if (!kc->nsleep)
1108                 return -ENANOSLEEP_NOTSUP;
1109 
1110         if (copy_from_user(&t, rqtp, sizeof (struct timespec)))
1111                 return -EFAULT;
1112 
1113         if (!timespec_valid(&t))
1114                 return -EINVAL;
1115 
1116         return kc->nsleep(which_clock, flags, &t, rmtp);
1117 }
1118 
1119 /*
1120  * This will restart clock_nanosleep. This is required only by
1121  * compat_clock_nanosleep_restart for now.
1122  */
1123 long clock_nanosleep_restart(struct restart_block *restart_block)
1124 {
1125         clockid_t which_clock = restart_block->nanosleep.clockid;
1126         struct k_clock *kc = clockid_to_kclock(which_clock);
1127 
1128         if (WARN_ON_ONCE(!kc || !kc->nsleep_restart))
1129                 return -EINVAL;
1130 
1131         return kc->nsleep_restart(restart_block);
1132 }
1133 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp