Skip to content

W
wine-winehq
Commit 1ff8fe20 authored by Zebediah Figura's avatar Zebediah Figura Committed by Alexandre Julliard
Browse files
Options

server: Remove no longer used snapshot requests.

Signed-off-by: 's avatarZebediah Figura <zfigura@codeweavers.com> Signed-off-by: 's avatarAlexandre Julliard <julliard@winehq.org>
parent 747573f1
Hide whitespace changes
Inline Side-by-side
Showing with 1 addition and 495 deletions
include/wine/server_protocol.h
View file @ 1ff8fe20
......@@ -2420,67 +2420,6 @@ struct is_same_mapping_reply
};
#define SNAP_PROCESS 0x00000001
#define SNAP_THREAD 0x00000002
struct create_snapshot_request
{
struct request_header __header;
unsigned int attributes;
unsigned int flags;
char __pad_20[4];
};
struct create_snapshot_reply
{
struct reply_header __header;
obj_handle_t handle;
char __pad_12[4];
};
struct next_process_request
{
struct request_header __header;
obj_handle_t handle;
int reset;
char __pad_20[4];
};
struct next_process_reply
{
struct reply_header __header;
int count;
process_id_t pid;
process_id_t ppid;
int threads;
int priority;
int handles;
int unix_pid;
/* VARARG(filename,unicode_str); */
char __pad_36[4];
};
struct next_thread_request
{
struct request_header __header;
obj_handle_t handle;
int reset;
char __pad_20[4];
};
struct next_thread_reply
{
struct reply_header __header;
int count;
process_id_t pid;
thread_id_t tid;
int base_pri;
int delta_pri;
int unix_tid;
};
struct thread_info
{
thread_id_t tid;
......@@ -5926,9 +5865,6 @@ enum request
REQ_get_mapping_committed_range,
REQ_add_mapping_committed_range,
REQ_is_same_mapping,
REQ_create_snapshot,
REQ_next_process,
REQ_next_thread,
REQ_list_processes,
REQ_wait_debug_event,
REQ_queue_exception_event,
......@@ -6230,9 +6166,6 @@ union generic_request
struct get_mapping_committed_range_request get_mapping_committed_range_request;
struct add_mapping_committed_range_request add_mapping_committed_range_request;
struct is_same_mapping_request is_same_mapping_request;
struct create_snapshot_request create_snapshot_request;
struct next_process_request next_process_request;
struct next_thread_request next_thread_request;
struct list_processes_request list_processes_request;
struct wait_debug_event_request wait_debug_event_request;
struct queue_exception_event_request queue_exception_event_request;
......@@ -6532,9 +6465,6 @@ union generic_reply
struct get_mapping_committed_range_reply get_mapping_committed_range_reply;
struct add_mapping_committed_range_reply add_mapping_committed_range_reply;
struct is_same_mapping_reply is_same_mapping_reply;
struct create_snapshot_reply create_snapshot_reply;
struct next_process_reply next_process_reply;
struct next_thread_reply next_thread_reply;
struct list_processes_reply list_processes_reply;
struct wait_debug_event_reply wait_debug_event_reply;
struct queue_exception_event_reply queue_exception_event_reply;
......@@ -6741,7 +6671,7 @@ union generic_reply
/* ### protocol_version begin ### */
#define SERVER_PROTOCOL_VERSION 615
#define SERVER_PROTOCOL_VERSION 616
/* ### protocol_version end ### */
......
server/Makefile.in
View file @ 1ff8fe20
......@@ -33,7 +33,6 @@ C_SRCS = \
semaphore.c \
serial.c \
signal.c \
snapshot.c \
sock.c \
symlink.c \
thread.c \
......
server/process.c
View file @ 1ff8fe20
......@@ -1086,36 +1086,6 @@ int set_process_debug_flag( struct process *process, int flag )
return write_process_memory( process, process->peb + 2, 1, &data );
}
/* take a snapshot of currently running processes */
struct process_snapshot *process_snap( int *count )
{
struct process_snapshot *snapshot, *ptr;
struct process *process;
if (!running_processes) return NULL;
if (!(snapshot = mem_alloc( sizeof(*snapshot) * running_processes )))
return NULL;
ptr = snapshot;
LIST_FOR_EACH_ENTRY( process, &process_list, struct process, entry )
{
if (!process->running_threads) continue;
ptr->process = process;
ptr->threads = process->running_threads;
ptr->count = process->obj.refcount;
ptr->priority = process->priority;
ptr->handles = get_handle_table_count(process);
grab_object( process );
ptr++;
}
if (!(*count = ptr - snapshot))
{
free( snapshot );
snapshot = NULL;
}
return snapshot;
}
/* create a new process */
DECL_HANDLER(new_process)
{
......
server/process.h
View file @ 1ff8fe20
......@@ -100,15 +100,6 @@ struct process
struct list kernel_object; /* list of kernel object pointers */
};
struct process_snapshot
{
struct process *process; /* process ptr */
int count; /* process refcount */
int threads; /* number of threads */
int priority; /* priority class */
int handles; /* number of handles */
};
#define CPU_FLAG(cpu) (1 << (cpu))
#define CPU_64BIT_MASK (CPU_FLAG(CPU_x86_64) | CPU_FLAG(CPU_ARM64))
......@@ -137,7 +128,6 @@ extern void kill_process( struct process *process, int violent_death );
extern void kill_console_processes( struct thread *renderer, int exit_code );
extern void kill_debugged_processes( struct thread *debugger, int exit_code );
extern void detach_debugged_processes( struct thread *debugger );
extern struct process_snapshot *process_snap( int *count );
extern void enum_processes( int (*cb)(struct process*, void*), void *user);
/* console functions */
......
server/protocol.def
View file @ 1ff8fe20
......@@ -1868,47 +1868,6 @@ enum char_info_mode
@END
#define SNAP_PROCESS 0x00000001
#define SNAP_THREAD 0x00000002
/* Create a snapshot */
@REQ(create_snapshot)
unsigned int attributes; /* object attributes */
unsigned int flags; /* snapshot flags (SNAP_*) */
@REPLY
obj_handle_t handle; /* handle to the snapshot */
@END
/* Get the next process from a snapshot */
@REQ(next_process)
obj_handle_t handle; /* handle to the snapshot */
int reset; /* reset snapshot position? */
@REPLY
int count; /* process usage count */
process_id_t pid; /* process id */
process_id_t ppid; /* parent process id */
int threads; /* number of threads */
int priority; /* process priority */
int handles; /* number of handles */
int unix_pid; /* Unix pid */
VARARG(filename,unicode_str); /* file name of main exe */
@END
/* Get the next thread from a snapshot */
@REQ(next_thread)
obj_handle_t handle; /* handle to the snapshot */
int reset; /* reset snapshot position? */
@REPLY
int count; /* thread usage count */
process_id_t pid; /* process id */
thread_id_t tid; /* thread id */
int base_pri; /* base priority */
int delta_pri; /* delta priority */
int unix_tid; /* thread native pid */
@END
struct thread_info
{
thread_id_t tid;
......
server/request.h
View file @ 1ff8fe20
......@@ -211,9 +211,6 @@ DECL_HANDLER(unmap_view);
DECL_HANDLER(get_mapping_committed_range);
DECL_HANDLER(add_mapping_committed_range);
DECL_HANDLER(is_same_mapping);
DECL_HANDLER(create_snapshot);
DECL_HANDLER(next_process);
DECL_HANDLER(next_thread);
DECL_HANDLER(list_processes);
DECL_HANDLER(wait_debug_event);
DECL_HANDLER(queue_exception_event);
......@@ -514,9 +511,6 @@ static const req_handler req_handlers[REQ_NB_REQUESTS] =
(req_handler)req_get_mapping_committed_range,
(req_handler)req_add_mapping_committed_range,
(req_handler)req_is_same_mapping,
(req_handler)req_create_snapshot,
(req_handler)req_next_process,
(req_handler)req_next_thread,
(req_handler)req_list_processes,
(req_handler)req_wait_debug_event,
(req_handler)req_queue_exception_event,
......@@ -1336,32 +1330,6 @@ C_ASSERT( sizeof(struct add_mapping_committed_range_request) == 40 );
C_ASSERT( FIELD_OFFSET(struct is_same_mapping_request, base1) == 16 );
C_ASSERT( FIELD_OFFSET(struct is_same_mapping_request, base2) == 24 );
C_ASSERT( sizeof(struct is_same_mapping_request) == 32 );
C_ASSERT( FIELD_OFFSET(struct create_snapshot_request, attributes) == 12 );
C_ASSERT( FIELD_OFFSET(struct create_snapshot_request, flags) == 16 );
C_ASSERT( sizeof(struct create_snapshot_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct create_snapshot_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_snapshot_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct next_process_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct next_process_request, reset) == 16 );
C_ASSERT( sizeof(struct next_process_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct next_process_reply, count) == 8 );
C_ASSERT( FIELD_OFFSET(struct next_process_reply, pid) == 12 );
C_ASSERT( FIELD_OFFSET(struct next_process_reply, ppid) == 16 );
C_ASSERT( FIELD_OFFSET(struct next_process_reply, threads) == 20 );
C_ASSERT( FIELD_OFFSET(struct next_process_reply, priority) == 24 );
C_ASSERT( FIELD_OFFSET(struct next_process_reply, handles) == 28 );
C_ASSERT( FIELD_OFFSET(struct next_process_reply, unix_pid) == 32 );
C_ASSERT( sizeof(struct next_process_reply) == 40 );
C_ASSERT( FIELD_OFFSET(struct next_thread_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct next_thread_request, reset) == 16 );
C_ASSERT( sizeof(struct next_thread_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct next_thread_reply, count) == 8 );
C_ASSERT( FIELD_OFFSET(struct next_thread_reply, pid) == 12 );
C_ASSERT( FIELD_OFFSET(struct next_thread_reply, tid) == 16 );
C_ASSERT( FIELD_OFFSET(struct next_thread_reply, base_pri) == 20 );
C_ASSERT( FIELD_OFFSET(struct next_thread_reply, delta_pri) == 24 );
C_ASSERT( FIELD_OFFSET(struct next_thread_reply, unix_tid) == 28 );
C_ASSERT( sizeof(struct next_thread_reply) == 32 );
C_ASSERT( sizeof(struct list_processes_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct list_processes_reply, info_size) == 8 );
C_ASSERT( FIELD_OFFSET(struct list_processes_reply, process_count) == 12 );
......
server/snapshot.c deleted 100644 → 0
View file @ 747573f1
/*
* Server-side snapshots
*
* Copyright (C) 1999 Alexandre Julliard
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*
* FIXME: heap snapshots not implemented
*/
#include "config.h"
#include "wine/port.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include "ntstatus.h"
#define WIN32_NO_STATUS
#include "windef.h"
#include "winternl.h"
#include "handle.h"
#include "process.h"
#include "thread.h"
#include "request.h"
struct snapshot
{
struct object obj; /* object header */
struct process_snapshot *processes; /* processes snapshot */
int process_count; /* count of processes */
int process_pos; /* current position in proc snapshot */
struct thread_snapshot *threads; /* threads snapshot */
int thread_count; /* count of threads */
int thread_pos; /* current position in thread snapshot */
};
static void snapshot_dump( struct object *obj, int verbose );
static void snapshot_destroy( struct object *obj );
static const struct object_ops snapshot_ops =
{
sizeof(struct snapshot), /* size */
snapshot_dump, /* dump */
no_get_type, /* get_type */
no_add_queue, /* add_queue */
NULL, /* remove_queue */
NULL, /* signaled */
NULL, /* satisfied */
no_signal, /* signal */
no_get_fd, /* get_fd */
no_map_access, /* map_access */
default_get_sd, /* get_sd */
default_set_sd, /* set_sd */
no_lookup_name, /* lookup_name */
no_link_name, /* link_name */
NULL, /* unlink_name */
no_open_file, /* open_file */
no_kernel_obj_list, /* get_kernel_obj_list */
no_close_handle, /* close_handle */
snapshot_destroy /* destroy */
};
/* create a new snapshot */
static struct snapshot *create_snapshot( unsigned int flags )
{
struct snapshot *snapshot;
if (!(snapshot = alloc_object( &snapshot_ops ))) return NULL;
snapshot->process_pos = 0;
snapshot->process_count = 0;
if (flags & SNAP_PROCESS)
snapshot->processes = process_snap( &snapshot->process_count );
snapshot->thread_pos = 0;
snapshot->thread_count = 0;
if (flags & SNAP_THREAD)
snapshot->threads = thread_snap( &snapshot->thread_count );
return snapshot;
}
/* get the next process in the snapshot */
static int snapshot_next_process( struct snapshot *snapshot, struct next_process_reply *reply )
{
struct process_snapshot *ptr;
struct process_dll *exe_module;
if (!snapshot->process_count)
{
set_error( STATUS_INVALID_PARAMETER ); /* FIXME */
return 0;
}
if (snapshot->process_pos >= snapshot->process_count)
{
set_error( STATUS_NO_MORE_FILES );
return 0;
}
ptr = &snapshot->processes[snapshot->process_pos++];
reply->count = ptr->count;
reply->pid = get_process_id( ptr->process );
reply->ppid = ptr->process->parent_id;
reply->threads = ptr->threads;
reply->priority = ptr->priority;
reply->handles = ptr->handles;
reply->unix_pid = ptr->process->unix_pid;
if ((exe_module = get_process_exe_module( ptr->process )) && exe_module->filename)
{
data_size_t len = min( exe_module->namelen, get_reply_max_size() );
set_reply_data( exe_module->filename, len );
}
return 1;
}
/* get the next thread in the snapshot */
static int snapshot_next_thread( struct snapshot *snapshot, struct next_thread_reply *reply )
{
struct thread_snapshot *ptr;
if (!snapshot->thread_count)
{
set_error( STATUS_INVALID_PARAMETER ); /* FIXME */
return 0;
}
if (snapshot->thread_pos >= snapshot->thread_count)
{
set_error( STATUS_NO_MORE_FILES );
return 0;
}
ptr = &snapshot->threads[snapshot->thread_pos++];
reply->count = ptr->count;
reply->pid = get_process_id( ptr->thread->process );
reply->tid = get_thread_id( ptr->thread );
reply->base_pri = ptr->priority;
reply->delta_pri = 0; /* FIXME */
reply->unix_tid = ptr->thread->unix_tid;
return 1;
}
static void snapshot_dump( struct object *obj, int verbose )
{
struct snapshot *snapshot = (struct snapshot *)obj;
assert( obj->ops == &snapshot_ops );
fprintf( stderr, "Snapshot: %d procs %d threads\n",
snapshot->process_count, snapshot->thread_count );
}
static void snapshot_destroy( struct object *obj )
{
int i;
struct snapshot *snapshot = (struct snapshot *)obj;
assert( obj->ops == &snapshot_ops );
if (snapshot->process_count)
{
for (i = 0; i < snapshot->process_count; i++)
release_object( snapshot->processes[i].process );
free( snapshot->processes );
}
if (snapshot->thread_count)
{
for (i = 0; i < snapshot->thread_count; i++)
release_object( snapshot->threads[i].thread );
free( snapshot->threads );
}
}
/* create a snapshot */
DECL_HANDLER(create_snapshot)
{
struct snapshot *snapshot;
reply->handle = 0;
if ((snapshot = create_snapshot( req->flags )))
{
reply->handle = alloc_handle( current->process, snapshot, 0, req->attributes );
release_object( snapshot );
}
}
/* get the next process from a snapshot */
DECL_HANDLER(next_process)
{
struct snapshot *snapshot;
if ((snapshot = (struct snapshot *)get_handle_obj( current->process, req->handle,
0, &snapshot_ops )))
{
if (req->reset) snapshot->process_pos = 0;
snapshot_next_process( snapshot, reply );
release_object( snapshot );
}
}
/* get the next thread from a snapshot */
DECL_HANDLER(next_thread)
{
struct snapshot *snapshot;
if ((snapshot = (struct snapshot *)get_handle_obj( current->process, req->handle,
0, &snapshot_ops )))
{
if (req->reset) snapshot->thread_pos = 0;
snapshot_next_thread( snapshot, reply );
release_object( snapshot );
}
}
server/thread.c
View file @ 1ff8fe20
......@@ -1299,30 +1299,6 @@ static unsigned int get_context_system_regs( enum cpu_type cpu )
return 0;
}
/* take a snapshot of currently running threads */
struct thread_snapshot *thread_snap( int *count )
{
struct thread_snapshot *snapshot, *ptr;
struct thread *thread;
int total = 0;
LIST_FOR_EACH_ENTRY( thread, &thread_list, struct thread, entry )
if (thread->state != TERMINATED) total++;
if (!total || !(snapshot = mem_alloc( sizeof(*snapshot) * total ))) return NULL;
ptr = snapshot;
LIST_FOR_EACH_ENTRY( thread, &thread_list, struct thread, entry )
{
if (thread->state == TERMINATED) continue;
ptr->thread = thread;
ptr->count = thread->obj.refcount;
ptr->priority = thread->priority;
grab_object( thread );
ptr++;
}
*count = total;
return snapshot;
}
/* gets the current impersonation token */
struct token *thread_get_impersonation_token( struct thread *thread )
{
......
server/thread.h
View file @ 1ff8fe20
......@@ -93,13 +93,6 @@ struct thread
WCHAR *desc; /* thread description string */
};
struct thread_snapshot
{
struct thread *thread; /* thread ptr */
int count; /* thread refcount */
int priority; /* priority class */
};
extern struct thread *current;
/* thread functions */
......@@ -125,7 +118,6 @@ extern int thread_queue_apc( struct process *process, struct thread *thread, str
extern void thread_cancel_apc( struct thread *thread, struct object *owner, enum apc_type type );
extern int thread_add_inflight_fd( struct thread *thread, int client, int server );
extern int thread_get_inflight_fd( struct thread *thread, int client );
extern struct thread_snapshot *thread_snap( int *count );
extern struct token *thread_get_impersonation_token( struct thread *thread );
extern int set_thread_affinity( struct thread *thread, affinity_t affinity );
extern int is_cpu_supported( enum cpu_type cpu );
......
server/trace.c
View file @ 1ff8fe20
......@@ -2397,51 +2397,6 @@ static void dump_is_same_mapping_request( const struct is_same_mapping_request *
dump_uint64( ", base2=", &req->base2 );
}
static void dump_create_snapshot_request( const struct create_snapshot_request *req )
{
fprintf( stderr, " attributes=%08x", req->attributes );
fprintf( stderr, ", flags=%08x", req->flags );
}
static void dump_create_snapshot_reply( const struct create_snapshot_reply *req )
{
fprintf( stderr, " handle=%04x", req->handle );
}
static void dump_next_process_request( const struct next_process_request *req )
{
fprintf( stderr, " handle=%04x", req->handle );
fprintf( stderr, ", reset=%d", req->reset );
}
static void dump_next_process_reply( const struct next_process_reply *req )
{
fprintf( stderr, " count=%d", req->count );
fprintf( stderr, ", pid=%04x", req->pid );
fprintf( stderr, ", ppid=%04x", req->ppid );
fprintf( stderr, ", threads=%d", req->threads );
fprintf( stderr, ", priority=%d", req->priority );
fprintf( stderr, ", handles=%d", req->handles );
fprintf( stderr, ", unix_pid=%d", req->unix_pid );
dump_varargs_unicode_str( ", filename=", cur_size );
}
static void dump_next_thread_request( const struct next_thread_request *req )
{
fprintf( stderr, " handle=%04x", req->handle );
fprintf( stderr, ", reset=%d", req->reset );
}
static void dump_next_thread_reply( const struct next_thread_reply *req )
{
fprintf( stderr, " count=%d", req->count );
fprintf( stderr, ", pid=%04x", req->pid );
fprintf( stderr, ", tid=%04x", req->tid );
fprintf( stderr, ", base_pri=%d", req->base_pri );
fprintf( stderr, ", delta_pri=%d", req->delta_pri );
fprintf( stderr, ", unix_tid=%d", req->unix_tid );
}
static void dump_list_processes_request( const struct list_processes_request *req )
{
}
......@@ -4752,9 +4707,6 @@ static const dump_func req_dumpers[REQ_NB_REQUESTS] = {
(dump_func)dump_get_mapping_committed_range_request,
(dump_func)dump_add_mapping_committed_range_request,
(dump_func)dump_is_same_mapping_request,
(dump_func)dump_create_snapshot_request,
(dump_func)dump_next_process_request,
(dump_func)dump_next_thread_request,
(dump_func)dump_list_processes_request,
(dump_func)dump_wait_debug_event_request,
(dump_func)dump_queue_exception_event_request,
......@@ -5052,9 +5004,6 @@ static const dump_func reply_dumpers[REQ_NB_REQUESTS] = {
(dump_func)dump_get_mapping_committed_range_reply,
NULL,
NULL,
(dump_func)dump_create_snapshot_reply,
(dump_func)dump_next_process_reply,
(dump_func)dump_next_thread_reply,
(dump_func)dump_list_processes_reply,
(dump_func)dump_wait_debug_event_reply,
(dump_func)dump_queue_exception_event_reply,
......@@ -5352,9 +5301,6 @@ static const char * const req_names[REQ_NB_REQUESTS] = {
"get_mapping_committed_range",
"add_mapping_committed_range",
"is_same_mapping",
"create_snapshot",
"next_process",
"next_thread",
"list_processes",
"wait_debug_event",
"queue_exception_event",
......@@ -5649,7 +5595,6 @@ static const struct
{ "NO_IMPERSONATION_TOKEN", STATUS_NO_IMPERSONATION_TOKEN },
{ "NO_MEMORY", STATUS_NO_MEMORY },
{ "NO_MORE_ENTRIES", STATUS_NO_MORE_ENTRIES },
{ "NO_MORE_FILES", STATUS_NO_MORE_FILES },
{ "NO_SUCH_DEVICE", STATUS_NO_SUCH_DEVICE },
{ "NO_SUCH_FILE", STATUS_NO_SUCH_FILE },
{ "NO_TOKEN", STATUS_NO_TOKEN },
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment