1 /*
2 * Waitable timers management
3 *
4 * Copyright (C) 1999 Alexandre Julliard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <assert.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <sys/time.h>
28 #include <sys/types.h>
29 #include <stdarg.h>
30
31 #include "ntstatus.h"
32 #define WIN32_NO_STATUS
33 #include "windef.h"
34 #include "winternl.h"
35
36 #include "file.h"
37 #include "handle.h"
38 #include "request.h"
39
40 struct timer
41 {
42 struct object obj; /* object header */
43 int manual; /* manual reset */
44 int signaled; /* current signaled state */
45 unsigned int period; /* timer period in ms */
46 timeout_t when; /* next expiration */
47 struct timeout_user *timeout; /* timeout user */
48 struct thread *thread; /* thread that set the APC function */
49 void *callback; /* callback APC function */
50 void *arg; /* callback argument */
51 };
52
53 static void timer_dump( struct object *obj, int verbose );
54 static struct object_type *timer_get_type( struct object *obj );
55 static int timer_signaled( struct object *obj, struct thread *thread );
56 static int timer_satisfied( struct object *obj, struct thread *thread );
57 static unsigned int timer_map_access( struct object *obj, unsigned int access );
58 static void timer_destroy( struct object *obj );
59
60 static const struct object_ops timer_ops =
61 {
62 sizeof(struct timer), /* size */
63 timer_dump, /* dump */
64 timer_get_type, /* get_type */
65 add_queue, /* add_queue */
66 remove_queue, /* remove_queue */
67 timer_signaled, /* signaled */
68 timer_satisfied, /* satisfied */
69 no_signal, /* signal */
70 no_get_fd, /* get_fd */
71 timer_map_access, /* map_access */
72 default_get_sd, /* get_sd */
73 default_set_sd, /* set_sd */
74 no_lookup_name, /* lookup_name */
75 no_open_file, /* open_file */
76 no_close_handle, /* close_handle */
77 timer_destroy /* destroy */
78 };
79
80
81 /* create a timer object */
82 static struct timer *create_timer( struct directory *root, const struct unicode_str *name,
83 unsigned int attr, int manual )
84 {
85 struct timer *timer;
86
87 if ((timer = create_named_object_dir( root, name, attr, &timer_ops )))
88 {
89 if (get_error() != STATUS_OBJECT_NAME_EXISTS)
90 {
91 /* initialize it if it didn't already exist */
92 timer->manual = manual;
93 timer->signaled = 0;
94 timer->when = 0;
95 timer->period = 0;
96 timer->timeout = NULL;
97 timer->thread = NULL;
98 }
99 }
100 return timer;
101 }
102
103 /* callback on timer expiration */
104 static void timer_callback( void *private )
105 {
106 struct timer *timer = (struct timer *)private;
107
108 /* queue an APC */
109 if (timer->thread)
110 {
111 apc_call_t data;
112
113 memset( &data, 0, sizeof(data) );
114 if (timer->callback)
115 {
116 data.type = APC_TIMER;
117 data.timer.func = timer->callback;
118 data.timer.time = timer->when;
119 data.timer.arg = timer->arg;
120 }
121 else data.type = APC_NONE; /* wake up only */
122
123 if (!thread_queue_apc( timer->thread, &timer->obj, &data ))
124 {
125 release_object( timer->thread );
126 timer->thread = NULL;
127 }
128 }
129
130 if (timer->period) /* schedule the next expiration */
131 {
132 timer->when += (timeout_t)timer->period * 10000;
133 timer->timeout = add_timeout_user( timer->when, timer_callback, timer );
134 }
135 else timer->timeout = NULL;
136
137 /* wake up waiters */
138 timer->signaled = 1;
139 wake_up( &timer->obj, 0 );
140 }
141
142 /* cancel a running timer */
143 static int cancel_timer( struct timer *timer )
144 {
145 int signaled = timer->signaled;
146
147 if (timer->timeout)
148 {
149 remove_timeout_user( timer->timeout );
150 timer->timeout = NULL;
151 }
152 if (timer->thread)
153 {
154 thread_cancel_apc( timer->thread, &timer->obj, APC_TIMER );
155 release_object( timer->thread );
156 timer->thread = NULL;
157 }
158 return signaled;
159 }
160
161 /* set the timer expiration and period */
162 static int set_timer( struct timer *timer, timeout_t expire, unsigned int period,
163 void *callback, void *arg )
164 {
165 int signaled = cancel_timer( timer );
166 if (timer->manual)
167 {
168 period = 0; /* period doesn't make any sense for a manual timer */
169 timer->signaled = 0;
170 }
171 timer->when = (expire <= 0) ? current_time - expire : max( expire, current_time );
172 timer->period = period;
173 timer->callback = callback;
174 timer->arg = arg;
175 if (callback) timer->thread = (struct thread *)grab_object( current );
176 timer->timeout = add_timeout_user( timer->when, timer_callback, timer );
177 return signaled;
178 }
179
180 static void timer_dump( struct object *obj, int verbose )
181 {
182 struct timer *timer = (struct timer *)obj;
183 assert( obj->ops == &timer_ops );
184 fprintf( stderr, "Timer manual=%d when=%s period=%u ",
185 timer->manual, get_timeout_str(timer->when), timer->period );
186 dump_object_name( &timer->obj );
187 fputc( '\n', stderr );
188 }
189
190 static struct object_type *timer_get_type( struct object *obj )
191 {
192 static const WCHAR name[] = {'T','i','m','e','r'};
193 static const struct unicode_str str = { name, sizeof(name) };
194 return get_object_type( &str );
195 }
196
197 static int timer_signaled( struct object *obj, struct thread *thread )
198 {
199 struct timer *timer = (struct timer *)obj;
200 assert( obj->ops == &timer_ops );
201 return timer->signaled;
202 }
203
204 static int timer_satisfied( struct object *obj, struct thread *thread )
205 {
206 struct timer *timer = (struct timer *)obj;
207 assert( obj->ops == &timer_ops );
208 if (!timer->manual) timer->signaled = 0;
209 return 0;
210 }
211
212 static unsigned int timer_map_access( struct object *obj, unsigned int access )
213 {
214 if (access & GENERIC_READ) access |= STANDARD_RIGHTS_READ | SYNCHRONIZE | TIMER_QUERY_STATE;
215 if (access & GENERIC_WRITE) access |= STANDARD_RIGHTS_WRITE | TIMER_MODIFY_STATE;
216 if (access & GENERIC_EXECUTE) access |= STANDARD_RIGHTS_EXECUTE;
217 if (access & GENERIC_ALL) access |= TIMER_ALL_ACCESS;
218 return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
219 }
220
221 static void timer_destroy( struct object *obj )
222 {
223 struct timer *timer = (struct timer *)obj;
224 assert( obj->ops == &timer_ops );
225
226 if (timer->timeout) remove_timeout_user( timer->timeout );
227 if (timer->thread) release_object( timer->thread );
228 }
229
230 /* create a timer */
231 DECL_HANDLER(create_timer)
232 {
233 struct timer *timer;
234 struct unicode_str name;
235 struct directory *root = NULL;
236
237 reply->handle = 0;
238 get_req_unicode_str( &name );
239 if (req->rootdir && !(root = get_directory_obj( current->process, req->rootdir, 0 )))
240 return;
241
242 if ((timer = create_timer( root, &name, req->attributes, req->manual )))
243 {
244 reply->handle = alloc_handle( current->process, timer, req->access, req->attributes );
245 release_object( timer );
246 }
247
248 if (root) release_object( root );
249 }
250
251 /* open a handle to a timer */
252 DECL_HANDLER(open_timer)
253 {
254 struct unicode_str name;
255 struct directory *root = NULL;
256 struct timer *timer;
257
258 get_req_unicode_str( &name );
259 if (req->rootdir && !(root = get_directory_obj( current->process, req->rootdir, 0 )))
260 return;
261
262 if ((timer = open_object_dir( root, &name, req->attributes, &timer_ops )))
263 {
264 reply->handle = alloc_handle( current->process, &timer->obj, req->access, req->attributes );
265 release_object( timer );
266 }
267
268 if (root) release_object( root );
269 }
270
271 /* set a waitable timer */
272 DECL_HANDLER(set_timer)
273 {
274 struct timer *timer;
275
276 if ((timer = (struct timer *)get_handle_obj( current->process, req->handle,
277 TIMER_MODIFY_STATE, &timer_ops )))
278 {
279 reply->signaled = set_timer( timer, req->expire, req->period, req->callback, req->arg );
280 release_object( timer );
281 }
282 }
283
284 /* cancel a waitable timer */
285 DECL_HANDLER(cancel_timer)
286 {
287 struct timer *timer;
288
289 if ((timer = (struct timer *)get_handle_obj( current->process, req->handle,
290 TIMER_MODIFY_STATE, &timer_ops )))
291 {
292 reply->signaled = cancel_timer( timer );
293 release_object( timer );
294 }
295 }
296
297 /* Get information on a waitable timer */
298 DECL_HANDLER(get_timer_info)
299 {
300 struct timer *timer;
301
302 if ((timer = (struct timer *)get_handle_obj( current->process, req->handle,
303 TIMER_QUERY_STATE, &timer_ops )))
304 {
305 reply->when = timer->when;
306 reply->signaled = timer->signaled;
307 release_object( timer );
308 }
309 }
310
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.