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