2 * Server-side async I/O support
4 * Copyright (C) 2007 Alexandre Julliard
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.
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.
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
27 #define WIN32_NO_STATUS
39 struct object obj
; /* object header */
40 struct thread
*thread
; /* owning thread */
41 struct list queue_entry
; /* entry in async queue list */
42 struct list process_entry
; /* entry in process list */
43 struct async_queue
*queue
; /* queue containing this async */
44 unsigned int status
; /* current status */
45 struct timeout_user
*timeout
;
46 unsigned int timeout_status
; /* status to report upon timeout */
49 async_data_t data
; /* data for async I/O call */
50 struct iosb
*iosb
; /* I/O status block */
53 static void async_dump( struct object
*obj
, int verbose
);
54 static int async_signaled( struct object
*obj
, struct wait_queue_entry
*entry
);
55 static void async_destroy( struct object
*obj
);
57 static const struct object_ops async_ops
=
59 sizeof(struct async
), /* size */
60 async_dump
, /* dump */
61 no_get_type
, /* get_type */
62 add_queue
, /* add_queue */
63 remove_queue
, /* remove_queue */
64 async_signaled
, /* signaled */
65 no_satisfied
, /* satisfied */
66 no_signal
, /* signal */
67 no_get_fd
, /* get_fd */
68 no_map_access
, /* map_access */
69 default_get_sd
, /* get_sd */
70 default_set_sd
, /* set_sd */
71 no_lookup_name
, /* lookup_name */
72 no_link_name
, /* link_name */
73 NULL
, /* unlink_name */
74 no_open_file
, /* open_file */
75 no_close_handle
, /* close_handle */
76 async_destroy
/* destroy */
82 struct object obj
; /* object header */
83 struct fd
*fd
; /* file descriptor owning this queue */
84 struct completion
*completion
; /* completion associated with a recently closed file descriptor */
85 apc_param_t comp_key
; /* completion key associated with a recently closed file descriptor */
86 struct list queue
; /* queue of async objects */
89 static void async_queue_dump( struct object
*obj
, int verbose
);
90 static void async_queue_destroy( struct object
*obj
);
92 static const struct object_ops async_queue_ops
=
94 sizeof(struct async_queue
), /* size */
95 async_queue_dump
, /* dump */
96 no_get_type
, /* get_type */
97 no_add_queue
, /* add_queue */
98 NULL
, /* remove_queue */
100 NULL
, /* satisfied */
101 no_signal
, /* signal */
102 no_get_fd
, /* get_fd */
103 no_map_access
, /* map_access */
104 default_get_sd
, /* get_sd */
105 default_set_sd
, /* set_sd */
106 no_lookup_name
, /* lookup_name */
107 no_link_name
, /* link_name */
108 NULL
, /* unlink_name */
109 no_open_file
, /* open_file */
110 no_close_handle
, /* close_handle */
111 async_queue_destroy
/* destroy */
115 static inline void async_reselect( struct async
*async
)
117 if (async
->queue
&& async
->queue
->fd
) fd_reselect_async( async
->queue
->fd
, async
->queue
);
120 static void async_dump( struct object
*obj
, int verbose
)
122 struct async
*async
= (struct async
*)obj
;
123 assert( obj
->ops
== &async_ops
);
124 fprintf( stderr
, "Async thread=%p\n", async
->thread
);
127 static int async_signaled( struct object
*obj
, struct wait_queue_entry
*entry
)
129 struct async
*async
= (struct async
*)obj
;
130 assert( obj
->ops
== &async_ops
);
131 return async
->signaled
;
134 static void async_destroy( struct object
*obj
)
136 struct async
*async
= (struct async
*)obj
;
137 assert( obj
->ops
== &async_ops
);
139 list_remove( &async
->process_entry
);
143 list_remove( &async
->queue_entry
);
144 async_reselect( async
);
145 release_object( async
->queue
);
148 if (async
->timeout
) remove_timeout_user( async
->timeout
);
149 if (async
->event
) release_object( async
->event
);
150 if (async
->iosb
) release_object( async
->iosb
);
151 release_object( async
->thread
);
154 static void async_queue_dump( struct object
*obj
, int verbose
)
156 struct async_queue
*async_queue
= (struct async_queue
*)obj
;
157 assert( obj
->ops
== &async_queue_ops
);
158 fprintf( stderr
, "Async queue fd=%p\n", async_queue
->fd
);
161 static void async_queue_destroy( struct object
*obj
)
163 struct async_queue
*async_queue
= (struct async_queue
*)obj
;
164 assert( obj
->ops
== &async_queue_ops
);
165 if (async_queue
->completion
) release_object( async_queue
->completion
);
168 /* notifies client thread of new status of its async request */
169 void async_terminate( struct async
*async
, unsigned int status
)
171 assert( status
!= STATUS_PENDING
);
173 if (async
->status
!= STATUS_PENDING
)
175 /* already terminated, just update status */
176 async
->status
= status
;
180 async
->status
= status
;
181 if (async
->iosb
&& async
->iosb
->status
== STATUS_PENDING
) async
->iosb
->status
= status
;
183 if (async
->data
.callback
)
187 memset( &data
, 0, sizeof(data
) );
188 data
.type
= APC_ASYNC_IO
;
189 data
.async_io
.func
= async
->data
.callback
;
190 data
.async_io
.user
= async
->data
.arg
;
191 data
.async_io
.sb
= async
->data
.iosb
;
192 data
.async_io
.status
= status
;
193 thread_queue_apc( async
->thread
, &async
->obj
, &data
);
195 else async_set_result( &async
->obj
, STATUS_SUCCESS
, 0, 0, 0 );
197 async_reselect( async
);
198 if (async
->queue
) release_object( async
); /* so that it gets destroyed when the async is done */
201 /* callback for timeout on an async request */
202 static void async_timeout( void *private )
204 struct async
*async
= private;
206 async
->timeout
= NULL
;
207 async_terminate( async
, async
->timeout_status
);
210 /* create a new async queue for a given fd */
211 struct async_queue
*create_async_queue( struct fd
*fd
)
213 struct async_queue
*queue
= alloc_object( &async_queue_ops
);
218 queue
->completion
= NULL
;
219 list_init( &queue
->queue
);
224 /* free an async queue, cancelling all async operations */
225 void free_async_queue( struct async_queue
*queue
)
228 if (queue
->fd
) queue
->completion
= fd_get_completion( queue
->fd
, &queue
->comp_key
);
230 async_wake_up( queue
, STATUS_HANDLES_CLOSED
);
231 release_object( queue
);
234 void queue_async( struct async_queue
*queue
, struct async
*async
)
236 async
->queue
= (struct async_queue
*)grab_object( queue
);
238 grab_object( async
);
239 list_add_tail( &queue
->queue
, &async
->queue_entry
);
241 if (queue
->fd
) set_fd_signaled( queue
->fd
, 0 );
244 /* create an async on a given queue of a fd */
245 struct async
*create_async( struct thread
*thread
, const async_data_t
*data
, struct iosb
*iosb
)
247 struct event
*event
= NULL
;
250 if (data
->event
&& !(event
= get_event_obj( thread
->process
, data
->event
, EVENT_MODIFY_STATE
)))
253 if (!(async
= alloc_object( &async_ops
)))
255 if (event
) release_object( event
);
259 async
->thread
= (struct thread
*)grab_object( thread
);
260 async
->event
= event
;
261 async
->status
= STATUS_PENDING
;
263 async
->timeout
= NULL
;
267 if (iosb
) async
->iosb
= (struct iosb
*)grab_object( iosb
);
268 else async
->iosb
= NULL
;
270 list_add_head( &thread
->process
->asyncs
, &async
->process_entry
);
271 if (event
) reset_event( event
);
276 /* set the timeout of an async operation */
277 void async_set_timeout( struct async
*async
, timeout_t timeout
, unsigned int status
)
279 if (async
->timeout
) remove_timeout_user( async
->timeout
);
280 if (timeout
!= TIMEOUT_INFINITE
) async
->timeout
= add_timeout_user( timeout
, async_timeout
, async
);
281 else async
->timeout
= NULL
;
282 async
->timeout_status
= status
;
285 static void add_async_completion( struct async_queue
*queue
, apc_param_t cvalue
, unsigned int status
,
286 apc_param_t information
)
291 struct completion
*completion
= fd_get_completion( queue
->fd
, &ckey
);
295 add_completion( completion
, ckey
, cvalue
, status
, information
);
296 release_object( completion
);
299 else if (queue
->completion
) add_completion( queue
->completion
, queue
->comp_key
,
300 cvalue
, status
, information
);
303 /* store the result of the client-side async callback */
304 void async_set_result( struct object
*obj
, unsigned int status
, apc_param_t total
,
305 client_ptr_t apc
, client_ptr_t apc_arg
)
307 struct async
*async
= (struct async
*)obj
;
309 if (obj
->ops
!= &async_ops
) return; /* in case the client messed up the APC results */
311 assert( async
->status
!= STATUS_PENDING
); /* it must have been woken up if we get a result */
313 if (status
== STATUS_PENDING
) /* restart it */
315 status
= async
->status
;
316 async
->status
= STATUS_PENDING
;
317 grab_object( async
);
319 if (status
!= STATUS_ALERTED
) /* it was terminated in the meantime */
320 async_terminate( async
, status
);
322 async_reselect( async
);
326 if (async
->timeout
) remove_timeout_user( async
->timeout
);
327 async
->timeout
= NULL
;
328 async
->status
= status
;
329 if (status
== STATUS_MORE_PROCESSING_REQUIRED
) return; /* don't report the completion */
331 if (async
->queue
&& async
->data
.cvalue
)
332 add_async_completion( async
->queue
, async
->data
.cvalue
, status
, total
);
336 memset( &data
, 0, sizeof(data
) );
337 data
.type
= APC_USER
;
338 data
.user
.func
= apc
;
339 data
.user
.args
[0] = apc_arg
;
340 data
.user
.args
[1] = async
->data
.iosb
;
341 data
.user
.args
[2] = 0;
342 thread_queue_apc( async
->thread
, NULL
, &data
);
344 if (async
->event
) set_event( async
->event
);
345 else if (async
->queue
&& async
->queue
->fd
) set_fd_signaled( async
->queue
->fd
, 1 );
347 wake_up( &async
->obj
, 0 );
351 /* check if there are any queued async operations */
352 int async_queued( struct async_queue
*queue
)
354 return queue
&& list_head( &queue
->queue
);
357 /* check if an async operation is waiting to be alerted */
358 int async_waiting( struct async_queue
*queue
)
363 if (!queue
) return 0;
364 if (!(ptr
= list_head( &queue
->queue
))) return 0;
365 async
= LIST_ENTRY( ptr
, struct async
, queue_entry
);
366 return async
->status
== STATUS_PENDING
;
369 static int cancel_async( struct process
*process
, struct object
*obj
, struct thread
*thread
, client_ptr_t iosb
)
375 LIST_FOR_EACH_ENTRY( async
, &process
->asyncs
, struct async
, process_entry
)
377 if (async
->status
== STATUS_CANCELLED
) continue;
378 if ((!obj
|| (async
->queue
&& async
->queue
->fd
&& get_fd_user( async
->queue
->fd
) == obj
)) &&
379 (!thread
|| async
->thread
== thread
) &&
380 (!iosb
|| async
->data
.iosb
== iosb
))
382 async_terminate( async
, STATUS_CANCELLED
);
390 void cancel_process_asyncs( struct process
*process
)
392 cancel_async( process
, NULL
, NULL
, 0 );
395 /* wake up async operations on the queue */
396 void async_wake_up( struct async_queue
*queue
, unsigned int status
)
398 struct list
*ptr
, *next
;
402 LIST_FOR_EACH_SAFE( ptr
, next
, &queue
->queue
)
404 struct async
*async
= LIST_ENTRY( ptr
, struct async
, queue_entry
);
405 async_terminate( async
, status
);
406 if (status
== STATUS_ALERTED
) break; /* only wake up the first one */
410 static void iosb_dump( struct object
*obj
, int verbose
);
411 static void iosb_destroy( struct object
*obj
);
413 static const struct object_ops iosb_ops
=
415 sizeof(struct iosb
), /* size */
416 iosb_dump
, /* dump */
417 no_get_type
, /* get_type */
418 no_add_queue
, /* add_queue */
419 NULL
, /* remove_queue */
421 NULL
, /* satisfied */
422 no_signal
, /* signal */
423 no_get_fd
, /* get_fd */
424 no_map_access
, /* map_access */
425 default_get_sd
, /* get_sd */
426 default_set_sd
, /* set_sd */
427 no_lookup_name
, /* lookup_name */
428 no_link_name
, /* link_name */
429 NULL
, /* unlink_name */
430 no_open_file
, /* open_file */
431 no_close_handle
, /* close_handle */
432 iosb_destroy
/* destroy */
435 static void iosb_dump( struct object
*obj
, int verbose
)
437 assert( obj
->ops
== &iosb_ops
);
438 fprintf( stderr
, "I/O status block\n" );
441 static void iosb_destroy( struct object
*obj
)
443 struct iosb
*iosb
= (struct iosb
*)obj
;
445 free( iosb
->in_data
);
446 free( iosb
->out_data
);
449 /* allocate iosb struct */
450 struct iosb
*create_iosb( const void *in_data
, data_size_t in_size
, data_size_t out_size
)
454 if (!(iosb
= alloc_object( &iosb_ops
))) return NULL
;
456 iosb
->status
= STATUS_PENDING
;
458 iosb
->in_size
= in_size
;
459 iosb
->in_data
= NULL
;
460 iosb
->out_size
= out_size
;
461 iosb
->out_data
= NULL
;
463 if (in_size
&& !(iosb
->in_data
= memdup( in_data
, in_size
)))
465 release_object( iosb
);
472 struct iosb
*async_get_iosb( struct async
*async
)
474 return async
->iosb
? (struct iosb
*)grab_object( async
->iosb
) : NULL
;
477 /* cancels all async I/O */
478 DECL_HANDLER(cancel_async
)
480 struct object
*obj
= get_handle_obj( current
->process
, req
->handle
, 0, NULL
);
481 struct thread
*thread
= req
->only_thread
? current
: NULL
;
485 int count
= cancel_async( current
->process
, obj
, thread
, req
->iosb
);
486 if (!count
&& req
->iosb
) set_error( STATUS_NOT_FOUND
);
487 release_object( obj
);
491 /* get async result from associated iosb */
492 DECL_HANDLER(get_async_result
)
494 struct iosb
*iosb
= NULL
;
497 LIST_FOR_EACH_ENTRY( async
, ¤t
->process
->asyncs
, struct async
, process_entry
)
498 if (async
->data
.arg
== req
->user_arg
)
506 set_error( STATUS_INVALID_PARAMETER
);
512 data_size_t size
= min( iosb
->out_size
, get_reply_max_size() );
515 set_reply_data_ptr( iosb
->out_data
, size
);
516 iosb
->out_data
= NULL
;
519 reply
->size
= iosb
->result
;
520 set_error( iosb
->status
);