Server: Create and Use New mem_free Function
Robert Shearman
rob at codeweavers.com
Thu Oct 14 15:01:08 CDT 2004
Hi,
We have our own mem_alloc memory allocator, so this patch adds the a new
free function, mem_free, and replaces instances of free with mem_free.
At the moment, the implementation completely defers to the libc free
function, but it makes sense to have this new function so that we can
easily change memory allocators. The patch also changes a few instances
of malloc to mem_alloc.
Rob
Changelog:
Create and use new mem_free function.
-------------- next part --------------
Index: wine/server/async.c
===================================================================
RCS file: /home/wine/wine/server/async.c,v
retrieving revision 1.18
diff -u -p -r1.18 async.c
--- wine/server/async.c 4 Apr 2003 22:26:34 -0000 1.18
+++ wine/server/async.c 14 Oct 2004 19:20:28 -0000
@@ -58,7 +58,7 @@ void destroy_async( struct async *async
async->next = NULL;
async->prev = NULL;
release_object( async->thread );
- free(async);
+ mem_free( async );
}
void async_notify(struct async *async, int status)
@@ -121,7 +121,7 @@ static void async_callback(void *private
struct async *create_async(struct object *obj, struct thread *thread,
void *overlapped)
{
- struct async *async = (struct async *) malloc(sizeof(struct async));
+ struct async *async = (struct async *)mem_alloc(sizeof(struct async));
if(!async)
{
set_error(STATUS_NO_MEMORY);
Index: wine/server/atom.c
===================================================================
RCS file: /home/wine/wine/server/atom.c,v
retrieving revision 1.17
diff -u -p -r1.17 atom.c
--- wine/server/atom.c 19 Feb 2003 00:33:33 -0000 1.17
+++ wine/server/atom.c 14 Oct 2004 19:20:28 -0000
@@ -106,7 +106,7 @@ static struct atom_table *create_table(i
if ((entries_count < MIN_HASH_SIZE) ||
(entries_count > MAX_HASH_SIZE)) entries_count = HASH_SIZE;
table->entries_count = entries_count;
- if (!(table->entries = malloc( sizeof(*table->entries) * table->entries_count )))
+ if (!(table->entries = mem_alloc( sizeof(*table->entries) * table->entries_count )))
{
set_error( STATUS_NO_MEMORY );
goto fail;
@@ -198,10 +198,10 @@ static void atom_table_destroy( struct o
assert( obj->ops == &atom_table_ops );
if (table->handles)
{
- for (i = 0; i <= table->last; i++) free( table->handles[i] );
- free( table->handles );
+ for (i = 0; i <= table->last; i++) mem_free( table->handles[i] );
+ mem_free( table->handles );
}
- if (table->entries) free( table->entries );
+ if (table->entries) mem_free( table->entries );
}
/* find an atom entry in its hash list */
@@ -251,7 +251,7 @@ static atom_t add_atom( struct atom_tabl
entry->hash = hash;
strcpyW( entry->str, str );
}
- else free( entry );
+ else mem_free( entry );
}
else set_error( STATUS_NO_MEMORY );
return atom;
@@ -267,7 +267,7 @@ static void delete_atom( struct atom_tab
if (entry->prev) entry->prev->next = entry->next;
else table->entries[entry->hash] = entry->next;
table->handles[atom - MIN_STR_ATOM] = NULL;
- free( entry );
+ mem_free( entry );
}
}
Index: wine/server/class.c
===================================================================
RCS file: /home/wine/wine/server/class.c,v
retrieving revision 1.2
diff -u -p -r1.2 class.c
--- wine/server/class.c 11 Dec 2003 05:34:53 -0000 1.2
+++ wine/server/class.c 14 Oct 2004 19:20:28 -0000
@@ -95,7 +95,7 @@ static void destroy_class( struct window
{
list_remove( &class->entry );
release_object( class->process );
- free( class );
+ mem_free( class );
}
void destroy_process_classes( struct process *process )
Index: wine/server/console.c
===================================================================
RCS file: /home/wine/wine/server/console.c,v
retrieving revision 1.53
diff -u -p -r1.53 console.c
--- wine/server/console.c 8 Sep 2004 01:25:05 -0000 1.53
+++ wine/server/console.c 14 Oct 2004 19:20:28 -0000
@@ -128,7 +128,7 @@ static void console_input_events_destroy
{
struct console_input_events *evts = (struct console_input_events *)obj;
assert( obj->ops == &console_input_events_ops );
- free( evts->events );
+ mem_free( evts->events );
}
/* the renderer events list is signaled when it's not empty */
@@ -259,8 +259,8 @@ static struct screen_buffer *create_cons
screen_buffer->prev = NULL;
screen_buffer_list = screen_buffer;
- if (!(screen_buffer->data = malloc( screen_buffer->width * screen_buffer->height *
- sizeof(*screen_buffer->data) )))
+ if (!(screen_buffer->data = mem_alloc( screen_buffer->width * screen_buffer->height *
+ sizeof(*screen_buffer->data) )))
{
release_object( screen_buffer );
return NULL;
@@ -553,7 +553,7 @@ static int read_console_input( obj_handl
}
else
{
- free( console->records );
+ mem_free( console->records );
console->records = NULL;
reset_event( console->event );
}
@@ -601,7 +601,7 @@ static int set_console_input_info( const
{
memcpy( new_title, title, len );
new_title[len / sizeof(WCHAR)] = 0;
- if (console->title) free( console->title );
+ if (console->title) mem_free( console->title );
console->title = new_title;
evt.event = CONSOLE_RENDERER_TITLE_EVENT;
console_input_events_append( console->evt, &evt );
@@ -636,8 +636,8 @@ static int set_console_input_info( const
console->history_index -= delta;
for (i = 0; i < console->history_size; i++)
- if (console->history[i]) free( console->history[i] );
- free( console->history );
+ if (console->history[i]) mem_free( console->history[i] );
+ mem_free( console->history );
console->history = mem;
console->history_size = req->history_size;
}
@@ -659,7 +659,7 @@ static int change_screen_buffer_size( st
int i, old_width, old_height, copy_width, copy_height;
char_info_t *new_data;
- if (!(new_data = malloc( new_width * new_height * sizeof(*new_data) )))
+ if (!(new_data = mem_alloc( new_width * new_height * sizeof(*new_data) )))
{
set_error( STATUS_NO_MEMORY );
return 0;
@@ -697,7 +697,7 @@ static int change_screen_buffer_size( st
memcpy( &new_data[i * new_width], &new_data[old_height * new_width],
new_width * sizeof(char_info_t) );
}
- free( screen_buffer->data );
+ mem_free( screen_buffer->data );
screen_buffer->data = new_data;
screen_buffer->width = new_width;
screen_buffer->height = new_height;
@@ -884,7 +884,7 @@ static void console_input_append_hist( s
* so just free mem and returns
*/
set_error( STATUS_ALIAS_EXISTS );
- free(ptr);
+ mem_free( ptr );
return;
}
@@ -894,7 +894,7 @@ static void console_input_append_hist( s
}
else
{
- free( console->history[0]) ;
+ mem_free( console->history[0]) ;
memmove( &console->history[0], &console->history[1],
(console->history_size - 1) * sizeof(WCHAR*) );
console->history[console->history_size - 1] = ptr;
@@ -931,8 +931,8 @@ static void console_input_destroy( struc
int i;
assert( obj->ops == &console_input_ops );
- if (console_in->title) free( console_in->title );
- if (console_in->records) free( console_in->records );
+ if (console_in->title) mem_free( console_in->title );
+ if (console_in->records) mem_free( console_in->records );
if (console_in->active) release_object( console_in->active );
console_in->active = NULL;
@@ -947,8 +947,8 @@ static void console_input_destroy( struc
release_object( console_in->event );
for (i = 0; i < console_in->history_size; i++)
- if (console_in->history[i]) free( console_in->history[i] );
- if (console_in->history) free( console_in->history );
+ if (console_in->history[i]) mem_free( console_in->history[i] );
+ if (console_in->history) mem_free( console_in->history );
}
static void screen_buffer_dump( struct object *obj, int verbose )
@@ -975,7 +975,7 @@ static void screen_buffer_destroy( struc
for (sb = screen_buffer_list; sb && sb->input != screen_buffer->input; sb = sb->next);
screen_buffer->input->active = sb;
}
- if (screen_buffer->data) free( screen_buffer->data );
+ if (screen_buffer->data) mem_free( screen_buffer->data );
}
/* write data into a screen buffer */
Index: wine/server/fd.c
===================================================================
RCS file: /home/wine/wine/server/fd.c,v
retrieving revision 1.27
diff -u -p -r1.27 fd.c
--- wine/server/fd.c 23 Sep 2004 04:48:24 -0000 1.27
+++ wine/server/fd.c 14 Oct 2004 19:20:29 -0000
@@ -217,7 +217,7 @@ struct timeout_user *add_timeout_user( s
void remove_timeout_user( struct timeout_user *user )
{
list_remove( &user->entry );
- free( user );
+ mem_free( user );
}
/* add a timeout in milliseconds to an absolute time */
@@ -320,7 +320,7 @@ static int add_poll_user( struct fd *fd
if (allocated_users)
poll_users = newusers;
else
- free( newusers );
+ mem_free( newusers );
return -1;
}
poll_users = newusers;
@@ -400,7 +400,7 @@ static int get_next_timeout(void)
struct timeout_user *timeout = LIST_ENTRY( ptr, struct timeout_user, entry );
list_remove( &timeout->entry );
timeout->callback( timeout->private );
- free( timeout );
+ mem_free( timeout );
}
if ((ptr = list_head( &timeout_list )) != NULL)
@@ -502,7 +502,7 @@ static void inode_close_pending( struct
if (!fd->unlink) /* get rid of it unless there's an unlink pending on that file */
{
list_remove( ptr );
- free( fd );
+ mem_free( fd );
}
ptr = next;
}
@@ -544,7 +544,7 @@ static void inode_destroy( struct object
else unlink( fd->unlink );
}
}
- free( fd );
+ mem_free( fd );
}
}
@@ -596,7 +596,7 @@ static void inode_add_closed_fd( struct
else /* no locks on this inode and no unlink, get rid of the fd */
{
close( fd->fd );
- free( fd );
+ mem_free( fd );
}
}
@@ -727,7 +727,7 @@ static void remove_unix_locks( struct fd
/* allocate space for the list of holes */
/* max. number of holes is number of locks + 1 */
- if (!(buffer = malloc( sizeof(*buffer) * (count+1) ))) return;
+ if (!(buffer = mem_alloc( sizeof(*buffer) * (count+1) ))) return;
first = buffer;
first->next = NULL;
first->prev = NULL;
@@ -787,7 +787,7 @@ static void remove_unix_locks( struct fd
set_unix_lock( fd, cur->start, cur->end, F_UNLCK );
done:
- free( buffer );
+ mem_free( buffer );
}
/* create a new lock on a fd */
@@ -1060,7 +1060,7 @@ struct fd *open_fd( struct fd *fd, const
{
file_set_error();
release_object( fd );
- free( closed_fd );
+ mem_free( closed_fd );
return NULL;
}
}
@@ -1070,7 +1070,7 @@ struct fd *open_fd( struct fd *fd, const
{
file_set_error();
release_object( fd );
- free( closed_fd );
+ mem_free( closed_fd );
return NULL;
}
closed_fd->fd = fd->unix_fd;
@@ -1128,13 +1128,13 @@ struct fd *open_fd( struct fd *fd, const
set_error( STATUS_INVALID_PARAMETER );
goto error;
}
- free( closed_fd );
+ mem_free( closed_fd );
}
return fd;
error:
release_object( fd );
- free( closed_fd );
+ mem_free( closed_fd );
return NULL;
}
Index: wine/server/file.c
===================================================================
RCS file: /home/wine/wine/server/file.c,v
retrieving revision 1.88
diff -u -p -r1.88 file.c
--- wine/server/file.c 18 Aug 2004 00:04:58 -0000 1.88
+++ wine/server/file.c 14 Oct 2004 19:20:29 -0000
@@ -169,11 +169,11 @@ static struct object *create_file( const
!(file->fd = open_fd( file->fd, name, flags | O_NONBLOCK | O_LARGEFILE,
&mode, access, sharing, options )))
{
- free( name );
+ mem_free( name );
release_object( file );
return NULL;
}
- free( name );
+ mem_free( name );
/* check for serial port */
if (S_ISCHR(mode) && is_serial_fd( file->fd ))
@@ -186,7 +186,7 @@ static struct object *create_file( const
return &file->obj;
error:
- free( name );
+ mem_free( name );
return NULL;
}
Index: wine/server/handle.c
===================================================================
RCS file: /home/wine/wine/server/handle.c,v
retrieving revision 1.29
diff -u -p -r1.29 handle.c
--- wine/server/handle.c 16 Sep 2003 01:07:21 -0000 1.29
+++ wine/server/handle.c 14 Oct 2004 19:20:29 -0000
@@ -147,7 +147,7 @@ static void handle_table_destroy( struct
entry->ptr = NULL;
if (obj) release_object( obj );
}
- free( table->entries );
+ mem_free( table->entries );
}
/* allocate a new handle table */
Index: wine/server/hook.c
===================================================================
RCS file: /home/wine/wine/server/hook.c,v
retrieving revision 1.10
diff -u -p -r1.10 hook.c
--- wine/server/hook.c 5 Sep 2003 23:15:41 -0000 1.10
+++ wine/server/hook.c 14 Oct 2004 19:20:29 -0000
@@ -109,7 +109,7 @@ static struct hook *add_hook( struct thr
if (!(hook->handle = alloc_user_handle( hook, USER_HOOK )))
{
- free( hook );
+ mem_free( hook );
return NULL;
}
hook->thread = thread ? (struct thread *)grab_object( thread ) : NULL;
@@ -122,10 +122,10 @@ static struct hook *add_hook( struct thr
static void free_hook( struct hook *hook )
{
free_user_handle( hook->handle );
- if (hook->module) free( hook->module );
+ if (hook->module) mem_free( hook->module );
if (hook->thread) release_object( hook->thread );
list_remove( &hook->chain );
- free( hook );
+ mem_free( hook );
}
/* find a hook from its index and proc */
@@ -309,7 +309,7 @@ DECL_HANDLER(set_hook)
hook->module_size = module_size;
reply->handle = hook->handle;
}
- else if (module) free( module );
+ else if (module) mem_free( module );
if (thread) release_object( thread );
}
Index: wine/server/mapping.c
===================================================================
RCS file: /home/wine/wine/server/mapping.c,v
retrieving revision 1.47
diff -u -p -r1.47 mapping.c
--- wine/server/mapping.c 1 May 2004 02:50:06 -0000 1.47
+++ wine/server/mapping.c 14 Oct 2004 19:20:29 -0000
@@ -151,7 +151,7 @@ static int build_shared_mapping( struct
if (!grow_file( mapping->shared_file, 0, total_size )) goto error;
if ((shared_fd = get_file_unix_fd( mapping->shared_file )) == -1) goto error;
- if (!(buffer = malloc( max_size ))) goto error;
+ if (!(buffer = mem_alloc( max_size ))) goto error;
/* copy the shared sections data into the temp file */
@@ -177,13 +177,13 @@ static int build_shared_mapping( struct
if (pwrite( shared_fd, buffer, sec[i].SizeOfRawData, write_pos ) != sec[i].SizeOfRawData)
goto error;
}
- free( buffer );
+ mem_free( buffer );
return 1;
error:
release_object( mapping->shared_file );
mapping->shared_file = NULL;
- if (buffer) free( buffer );
+ if (buffer) mem_free( buffer );
return 0;
}
@@ -221,7 +221,7 @@ static int get_image_params( struct mapp
/* load the section headers */
size = sizeof(*sec) * nt.FileHeader.NumberOfSections;
- if (!(sec = malloc( size ))) goto error;
+ if (!(sec = mem_alloc( size ))) goto error;
if (pread( unix_fd, sec, size, pos ) != size) goto error;
if (!build_shared_mapping( mapping, unix_fd, sec, nt.FileHeader.NumberOfSections )) goto error;
@@ -242,12 +242,12 @@ static int get_image_params( struct mapp
/* sanity check */
if (mapping->header_size > mapping->size_low) goto error;
- free( sec );
+ mem_free( sec );
release_object( fd );
return 1;
error:
- if (sec) free( sec );
+ if (sec) mem_free( sec );
release_object( fd );
set_error( STATUS_INVALID_FILE_FOR_SECTION );
return 0;
Index: wine/server/named_pipe.c
===================================================================
RCS file: /home/wine/wine/server/named_pipe.c,v
retrieving revision 1.31
diff -u -p -r1.31 named_pipe.c
--- wine/server/named_pipe.c 18 Aug 2004 00:04:58 -0000 1.31
+++ wine/server/named_pipe.c 14 Oct 2004 19:20:29 -0000
@@ -240,7 +240,7 @@ static void notify_connect_waiters( stru
notify_waiter( &cw->wait, STATUS_SUCCESS );
release_object( pipe );
*x = cw->next;
- free( cw );
+ mem_free( cw );
}
}
Index: wine/server/object.c
===================================================================
RCS file: /home/wine/wine/server/object.c,v
retrieving revision 1.28
diff -u -p -r1.28 object.c
--- wine/server/object.c 11 Sep 2003 20:45:17 -0000 1.28
+++ wine/server/object.c 14 Oct 2004 19:20:29 -0000
@@ -115,7 +115,7 @@ static void free_name( struct object *ob
{
struct object_name *ptr = obj->name;
list_remove( &ptr->entry );
- free( ptr );
+ mem_free( ptr );
}
/* set the name of an existing object */
@@ -172,7 +172,7 @@ void *create_named_object( struct namesp
set_object_name( namespace, obj, name_ptr );
clear_error();
}
- else free( name_ptr );
+ else mem_free( name_ptr );
return obj;
}
@@ -213,7 +213,7 @@ void release_object( void *ptr )
list_remove( &obj->obj_list );
memset( obj, 0xaa, obj->ops->size );
#endif
- free( obj );
+ mem_free( obj );
}
}
Index: wine/server/object.h
===================================================================
RCS file: /home/wine/wine/server/object.h,v
retrieving revision 1.55
diff -u -p -r1.55 object.h
--- wine/server/object.h 11 Sep 2003 20:45:17 -0000 1.55
+++ wine/server/object.h 14 Oct 2004 19:20:29 -0000
@@ -86,6 +86,10 @@ struct wait_queue_entry
};
extern void *mem_alloc( size_t size ); /* malloc wrapper */
+static inline void mem_free( void * p ) /* free wrapper */
+{
+ free( p );
+}
extern void *memdup( const void *data, size_t len );
extern void *alloc_object( const struct object_ops *ops );
extern void dump_object_name( struct object *obj );
Index: wine/server/process.c
===================================================================
RCS file: /home/wine/wine/server/process.c,v
retrieving revision 1.117
diff -u -p -r1.117 process.c
--- wine/server/process.c 14 Jun 2004 17:02:00 -0000 1.117
+++ wine/server/process.c 14 Oct 2004 19:20:30 -0000
@@ -420,7 +420,7 @@ static void process_destroy( struct obje
if (process->queue) release_object( process->queue );
if (process->atom_table) release_object( process->atom_table );
if (process->exe.file) release_object( process->exe.file );
- if (process->exe.filename) free( process->exe.filename );
+ if (process->exe.filename) mem_free( process->exe.filename );
if (process->id) free_ptid( process->id );
if (process->token) release_object( process->token );
}
@@ -455,7 +455,7 @@ static void startup_info_destroy( struct
struct startup_info *info = (struct startup_info *)obj;
assert( obj->ops == &startup_info_ops );
list_remove( &info->entry );
- if (info->data) free( info->data );
+ if (info->data) mem_free( info->data );
if (info->exe_file) release_object( info->exe_file );
if (info->process) release_object( info->process );
if (info->thread) release_object( info->thread );
@@ -516,7 +516,7 @@ static struct process_dll *process_load_
dll->namelen = name_len;
if (name_len && !(dll->filename = memdup( filename, name_len )))
{
- free( dll );
+ mem_free( dll );
return NULL;
}
if (file) dll->file = (struct file *)grab_object( file );
@@ -538,8 +538,8 @@ static void process_unload_dll( struct p
if (dll->file) release_object( dll->file );
if (dll->next) dll->next->prev = dll->prev;
if (dll->prev) dll->prev->next = dll->next;
- if (dll->filename) free( dll->filename );
- free( dll );
+ if (dll->filename) mem_free( dll->filename );
+ mem_free( dll );
generate_debug_event( current, UNLOAD_DLL_DEBUG_EVENT, base );
return;
}
@@ -596,8 +596,8 @@ static void process_killed( struct proce
struct process_dll *dll = process->exe.next;
process->exe.next = dll->next;
if (dll->file) release_object( dll->file );
- if (dll->filename) free( dll->filename );
- free( dll );
+ if (dll->filename) mem_free( dll->filename );
+ mem_free( dll );
}
destroy_process_classes( process );
set_process_startup_state( process, STARTUP_ABORTED );
Index: wine/server/queue.c
===================================================================
RCS file: /home/wine/wine/server/queue.c,v
retrieving revision 1.44
diff -u -p -r1.44 queue.c
--- wine/server/queue.c 17 Jun 2004 20:00:25 -0000 1.44
+++ wine/server/queue.c 14 Oct 2004 19:20:30 -0000
@@ -380,9 +380,9 @@ static int merge_message( struct thread_
static void free_result( struct message_result *result )
{
if (result->timeout) remove_timeout_user( result->timeout );
- if (result->data) free( result->data );
- if (result->callback_msg) free( result->callback_msg );
- free( result );
+ if (result->data) mem_free( result->data );
+ if (result->callback_msg) mem_free( result->callback_msg );
+ mem_free( result );
}
/* remove the result from the sender list it is on */
@@ -441,8 +441,8 @@ static void free_message( struct message
}
else free_result( result );
}
- if (msg->data) free( msg->data );
- free( msg );
+ if (msg->data) mem_free( msg->data );
+ mem_free( msg );
}
/* remove (and free) a message from a message list */
@@ -494,7 +494,7 @@ static struct message_result *alloc_mess
struct message *callback_msg = mem_alloc( sizeof(*callback_msg) );
if (!callback_msg)
{
- free( result );
+ mem_free( result );
return NULL;
}
callback_msg->type = MSG_CALLBACK_RESULT;
@@ -561,7 +561,7 @@ static void receive_message( struct msg_
result->recv_next = queue->recv_result;
queue->recv_result = result;
}
- free( msg );
+ mem_free( msg );
if (!queue->msg_list[SEND_MESSAGE].first) clear_queue_bits( queue, QS_SENDMESSAGE );
}
@@ -758,7 +758,7 @@ static void msg_queue_destroy( struct ob
while (timer)
{
struct timer *next = timer->next;
- free( timer );
+ mem_free( timer );
timer = next;
}
if (queue->timeout) remove_timeout_user( queue->timeout );
@@ -958,7 +958,7 @@ static int kill_timer( struct msg_queue
{
if (timer->win != win || timer->msg != msg || timer->id != id) continue;
unlink_timer( queue, timer );
- free( timer );
+ mem_free( timer );
return 1;
}
return 0;
@@ -1100,12 +1100,12 @@ static void queue_hardware_message( stru
win = find_hardware_message_window( queue ? queue->input : foreground_input, msg, &msg_code );
if (!win || !(thread = get_window_thread(win)))
{
- free( msg );
+ mem_free( msg );
return;
}
input = thread->queue->input;
- if (msg->msg == WM_MOUSEMOVE && merge_message( input, msg )) free( msg );
+ if (msg->msg == WM_MOUSEMOVE && merge_message( input, msg )) mem_free( msg );
else
{
append_message( &input->msg_list, msg );
@@ -1232,7 +1232,7 @@ void queue_cleanup_window( struct thread
if (timer->win == win)
{
unlink_timer( queue, timer );
- free( timer );
+ mem_free( timer );
}
timer = next;
}
@@ -1381,7 +1381,7 @@ DECL_HANDLER(send_message)
msg->data_size = get_req_data_size();
if (msg->data_size && !(msg->data = memdup( get_req_data(), msg->data_size )))
{
- free( msg );
+ mem_free( msg );
break;
}
/* fall through */
@@ -1404,7 +1404,7 @@ DECL_HANDLER(send_message)
msg->data_size = get_req_data_size();
if (msg->data_size && !(msg->data = memdup( get_req_data(), msg->data_size )))
{
- free( msg );
+ mem_free( msg );
break;
}
append_message( &recv_queue->msg_list[POST_MESSAGE], msg );
@@ -1416,7 +1416,7 @@ DECL_HANDLER(send_message)
case MSG_CALLBACK_RESULT: /* cannot send this one */
default:
set_error( STATUS_INVALID_PARAMETER );
- free( msg );
+ mem_free( msg );
break;
}
}
Index: wine/server/region.c
===================================================================
RCS file: /home/wine/wine/server/region.c,v
retrieving revision 1.6
diff -u -p -r1.6 region.c
--- wine/server/region.c 17 Sep 2004 18:20:11 -0000 1.6
+++ wine/server/region.c 14 Oct 2004 19:20:30 -0000
@@ -329,7 +329,7 @@ static int region_op( struct region *new
}
ret = 1;
done:
- free( old_rects );
+ mem_free( old_rects );
return ret;
}
@@ -571,7 +571,7 @@ struct region *create_region( const rect
if (!(region = mem_alloc( sizeof(*region) ))) return NULL;
if (!(region->rects = mem_alloc( size * sizeof(*region->rects) )))
{
- free( region );
+ mem_free( region );
return NULL;
}
region->size = size;
@@ -595,8 +595,8 @@ struct region *create_region_from_req_da
/* free a region */
void free_region( struct region *region )
{
- free( region->rects );
- free( region );
+ mem_free( region->rects );
+ mem_free( region );
}
/* set region to a simple rectangle */
@@ -645,17 +645,17 @@ rectangle_t *get_region_data_and_free( s
if (max_size >= sizeof(empty_rect))
{
ret = memdup( &empty_rect, sizeof(empty_rect) );
- free( region->rects );
+ mem_free( region->rects );
}
}
if (max_size < *total_size)
{
- free( region->rects );
+ mem_free( region->rects );
set_error( STATUS_BUFFER_OVERFLOW );
ret = NULL;
}
- free( region );
+ mem_free( region );
return ret;
}
Index: wine/server/registry.c
===================================================================
RCS file: /home/wine/wine/server/registry.c,v
retrieving revision 1.60
diff -u -p -r1.60 registry.c
--- wine/server/registry.c 22 Sep 2004 02:46:38 -0000 1.60
+++ wine/server/registry.c 14 Oct 2004 19:20:31 -0000
@@ -291,7 +291,7 @@ static void do_notification( struct key
notify->prev->next = notify->next;
else
key->first_notify = notify->next;
- free( notify );
+ mem_free( notify );
}
static struct notify *find_notify( struct key *key, obj_handle_t hkey)
@@ -324,12 +324,12 @@ static void key_destroy( struct object *
struct key *key = (struct key *)obj;
assert( obj->ops == &key_ops );
- if (key->name) free( key->name );
- if (key->class) free( key->class );
+ if (key->name) mem_free( key->name );
+ if (key->class) mem_free( key->class );
for (i = 0; i <= key->last_value; i++)
{
- free( key->values[i].name );
- if (key->values[i].data) free( key->values[i].data );
+ mem_free( key->values[i].name );
+ if (key->values[i].data) mem_free( key->values[i].data );
}
for (i = 0; i <= key->last_subkey; i++)
{
@@ -878,11 +878,11 @@ static void set_value( struct key *key,
{
if (!(value = insert_value( key, name, index )))
{
- if (ptr) free( ptr );
+ if (ptr) mem_free( ptr );
return;
}
}
- else if (value->data) free( value->data ); /* already existing, free previous data */
+ else if (value->data) mem_free( value->data ); /* already existing, free previous data */
value->type = type;
value->len = len;
@@ -974,8 +974,8 @@ static void delete_value( struct key *ke
return;
}
if (debug_level > 1) dump_operation( key, value, "Delete" );
- free( value->name );
- if (value->data) free( value->data );
+ mem_free( value->name );
+ if (value->data) mem_free( value->data );
for (i = index; i < key->last_value; i++) key->values[i] = key->values[i + 1];
key->last_value--;
touch_key( key, REG_NOTIFY_CHANGE_LAST_SET );
@@ -1291,7 +1291,7 @@ static int load_value( struct key *key,
if (!len) newptr = NULL;
else if (!(newptr = memdup( ptr, len ))) return 0;
- if (value->data) free( value->data );
+ if (value->data) mem_free( value->data );
value->data = newptr;
value->len = len;
value->type = type;
@@ -1347,7 +1347,7 @@ static void load_keys( struct key *key,
if (!(info.buffer = mem_alloc( info.len ))) return;
if (!(info.tmp = mem_alloc( info.tmplen )))
{
- free( info.buffer );
+ mem_free( info.buffer );
return;
}
@@ -1387,8 +1387,8 @@ static void load_keys( struct key *key,
done:
if (subkey) release_object( subkey );
- free( info.buffer );
- free( info.tmp );
+ mem_free( info.buffer );
+ mem_free( info.tmp );
}
/* load a part of the registry from a file */
@@ -1476,7 +1476,7 @@ static void load_user_registries( struct
strcpy( p, "/user.reg" );
load_init_registry_from_file( filename, key_current_user );
- free( filename );
+ mem_free( filename );
}
/* registry initialisation */
@@ -1497,7 +1497,7 @@ void init_registry(void)
assert( root_key );
/* load the config file */
- if (!(filename = malloc( strlen(config) + sizeof("/config") ))) fatal_error( "out of memory\n" );
+ if (!(filename = mem_alloc( strlen(config) + sizeof("/config") ))) fatal_error( "out of memory\n" );
strcpy( filename, config );
strcat( filename, "/config" );
@@ -1509,7 +1509,7 @@ void init_registry(void)
load_init_registry_from_file( filename, key );
release_object( key );
- free( filename );
+ mem_free( filename );
}
/* update the level of the parents of a key (only needed for the old format) */
@@ -1583,10 +1583,10 @@ static int save_branch( struct key *key,
/* get the real path */
by_symlink = (!lstat(path, &st) && S_ISLNK (st.st_mode));
- if (!(real = malloc( PATH_MAX ))) return 0;
+ if (!(real = mem_alloc( PATH_MAX ))) return 0;
if (!realpath( path, real ))
{
- free( real );
+ mem_free( real );
real = NULL;
}
else path = real;
@@ -1608,7 +1608,7 @@ static int save_branch( struct key *key,
/* create a temp file in the same directory */
- if (!(tmp = malloc( strlen(path) + 20 ))) goto done;
+ if (!(tmp = mem_alloc( strlen(path) + 20 ))) goto done;
strcpy( tmp, path );
if ((p = strrchr( tmp, '/' ))) p++;
else p = tmp;
@@ -1644,11 +1644,11 @@ static int save_branch( struct key *key,
/* if successfully written, rename to final name */
if (ret) ret = !rename( tmp, path );
if (!ret) unlink( tmp );
- free( tmp );
+ mem_free( tmp );
}
done:
- if (real) free( real );
+ if (real) mem_free( real );
if (ret) make_clean( key );
return ret;
}
@@ -1714,7 +1714,7 @@ DECL_HANDLER(create_key)
if ((class = req_strdupW( req, class_ptr, get_req_data_size() - req->namelen )))
{
key = create_key( parent, name, class, flags, req->modif, &reply->created );
- free( class );
+ mem_free( class );
}
}
if (key)
@@ -1837,7 +1837,7 @@ DECL_HANDLER(delete_key_value)
if ((name = req_strdupW( req, get_req_data(), get_req_data_size() )))
{
delete_value( key, name );
- free( name );
+ mem_free( name );
}
release_object( key );
}
@@ -1931,7 +1931,7 @@ DECL_HANDLER(set_registry_notification)
}
else
{
- notify = (struct notify *) malloc (sizeof(*notify));
+ notify = (struct notify *) mem_alloc (sizeof(*notify));
if( notify )
{
grab_object( event );
Index: wine/server/snapshot.c
===================================================================
RCS file: /home/wine/wine/server/snapshot.c,v
retrieving revision 1.22
diff -u -p -r1.22 snapshot.c
--- wine/server/snapshot.c 16 Sep 2003 01:07:21 -0000 1.22
+++ wine/server/snapshot.c 14 Oct 2004 19:20:31 -0000
@@ -205,19 +205,19 @@ static void snapshot_destroy( struct obj
{
for (i = 0; i < snapshot->process_count; i++)
release_object( snapshot->processes[i].process );
- free( snapshot->processes );
+ mem_free( snapshot->processes );
}
if (snapshot->thread_count)
{
for (i = 0; i < snapshot->thread_count; i++)
release_object( snapshot->threads[i].thread );
- free( snapshot->threads );
+ mem_free( snapshot->threads );
}
if (snapshot->module_count)
{
for (i = 0; i < snapshot->module_count; i++)
- free( snapshot->modules[i].filename );
- free( snapshot->modules );
+ mem_free( snapshot->modules[i].filename );
+ mem_free( snapshot->modules );
}
if (snapshot->process) release_object( snapshot->process );
}
Index: wine/server/thread.c
===================================================================
RCS file: /home/wine/wine/server/thread.c,v
retrieving revision 1.103
diff -u -p -r1.103 thread.c
--- wine/server/thread.c 27 Oct 2003 22:10:22 -0000 1.103
+++ wine/server/thread.c 14 Oct 2004 19:20:31 -0000
@@ -204,9 +204,9 @@ static void cleanup_thread( struct threa
int i;
struct thread_apc *apc;
- while ((apc = thread_dequeue_apc( thread, 0 ))) free( apc );
- if (thread->req_data) free( thread->req_data );
- if (thread->reply_data) free( thread->reply_data );
+ while ((apc = thread_dequeue_apc( thread, 0 ))) mem_free( apc );
+ if (thread->req_data) mem_free( thread->req_data );
+ if (thread->reply_data) mem_free( thread->reply_data );
if (thread->request_fd) release_object( thread->request_fd );
if (thread->reply_fd) release_object( thread->reply_fd );
if (thread->wait_fd) release_object( thread->wait_fd );
@@ -245,7 +245,7 @@ static void destroy_thread( struct objec
if (thread->next) thread->next->prev = thread->prev;
if (thread->prev) thread->prev->next = thread->next;
else first_thread = thread->next;
- while ((apc = thread_dequeue_apc( thread, 0 ))) free( apc );
+ while ((apc = thread_dequeue_apc( thread, 0 ))) mem_free( apc );
cleanup_thread( thread );
release_object( thread->process );
if (thread->id) free_ptid( thread->id );
@@ -373,7 +373,7 @@ static void end_wait( struct thread *thr
entry->obj->ops->remove_queue( entry->obj, entry );
if (wait->user) remove_timeout_user( wait->user );
thread->wait = wait->next;
- free( wait );
+ mem_free( wait );
}
/* build the thread wait structure */
@@ -625,7 +625,7 @@ void thread_cancel_apc( struct thread *t
else queue->tail = apc->prev;
if (apc->prev) apc->prev->next = apc->next;
else queue->head = apc->next;
- free( apc );
+ mem_free( apc );
return;
}
}
@@ -1002,14 +1002,14 @@ DECL_HANDLER(get_apc)
* Exception: for APC_ASYNC_IO, func == NULL is legal.
*/
if (apc->func || apc->type == APC_ASYNC_IO) break;
- free( apc );
+ mem_free( apc );
}
reply->func = apc->func;
reply->type = apc->type;
reply->arg1 = apc->arg1;
reply->arg2 = apc->arg2;
reply->arg3 = apc->arg3;
- free( apc );
+ mem_free( apc );
}
/* fetch a selector entry for a thread */
Index: wine/server/window.c
===================================================================
RCS file: /home/wine/wine/server/window.c,v
retrieving revision 1.34
diff -u -p -r1.34 window.c
--- wine/server/window.c 17 Sep 2004 18:20:11 -0000 1.34
+++ wine/server/window.c 14 Oct 2004 19:20:32 -0000
@@ -162,7 +162,7 @@ static int add_handle_to_array( struct u
user_handle_t *new_array = realloc( array->handles, new_total * sizeof(*new_array) );
if (!new_array)
{
- free( array->handles );
+ mem_free( array->handles );
set_error( STATUS_NO_MEMORY );
return 0;
}
@@ -265,7 +265,7 @@ inline static void destroy_properties( s
if (win->properties[i].type == PROP_TYPE_FREE) continue;
release_global_atom( win->properties[i].atom );
}
- free( win->properties );
+ mem_free( win->properties );
}
/* destroy a window */
@@ -292,9 +292,9 @@ static void destroy_window( struct windo
unlink_window( win );
if (win->win_region) free_region( win->win_region );
release_class( win->class );
- if (win->text) free( win->text );
+ if (win->text) mem_free( win->text );
memset( win, 0x55, sizeof(*win) );
- free( win );
+ mem_free( win );
}
/* create a new window structure (note: the window is not linked in the window tree) */
@@ -317,7 +317,7 @@ static struct window *create_window( str
if (!(win->handle = alloc_user_handle( win, USER_WINDOW )))
{
release_class( class );
- free( win );
+ mem_free( win );
return NULL;
}
win->parent = parent;
@@ -933,7 +933,7 @@ DECL_HANDLER(get_window_children_from_po
reply->count = array.count;
len = min( get_reply_max_size(), array.count * sizeof(user_handle_t) );
if (len) set_reply_data_ptr( array.handles, len );
- else free( array.handles );
+ else mem_free( array.handles );
}
@@ -1023,7 +1023,7 @@ DECL_HANDLER(set_window_text)
memcpy( text, get_req_data(), len * sizeof(WCHAR) );
text[len] = 0;
}
- if (win->text) free( win->text );
+ if (win->text) mem_free( win->text );
win->text = text;
}
}
More information about the wine-patches
mailing list