2 * Server-side snapshots
4 * Copyright (C) 1999 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 * FIXME: heap snapshots not implemented
24 #include "wine/port.h"
40 struct object obj
; /* object header */
41 struct process
*process
; /* process of this snapshot (for modules and heaps) */
42 struct process_snapshot
*processes
; /* processes snapshot */
43 int process_count
; /* count of processes */
44 int process_pos
; /* current position in proc snapshot */
45 struct thread_snapshot
*threads
; /* threads snapshot */
46 int thread_count
; /* count of threads */
47 int thread_pos
; /* current position in thread snapshot */
48 struct module_snapshot
*modules
; /* modules snapshot */
49 int module_count
; /* count of modules */
50 int module_pos
; /* current position in module snapshot */
53 static void snapshot_dump( struct object
*obj
, int verbose
);
54 static void snapshot_destroy( struct object
*obj
);
56 static const struct object_ops snapshot_ops
=
58 sizeof(struct snapshot
), /* size */
59 snapshot_dump
, /* dump */
60 no_add_queue
, /* add_queue */
61 NULL
, /* remove_queue */
64 NULL
, /* get_poll_events */
65 NULL
, /* poll_event */
66 no_get_fd
, /* get_fd */
68 no_get_file_info
, /* get_file_info */
69 NULL
, /* queue_async */
70 snapshot_destroy
/* destroy */
74 /* create a new snapshot */
75 static struct snapshot
*create_snapshot( process_id_t pid
, int flags
)
77 struct process
*process
= NULL
;
78 struct snapshot
*snapshot
;
80 /* need a process for modules and heaps */
81 if (flags
& (SNAP_MODULE
|SNAP_HEAPLIST
))
83 if (!pid
) process
= (struct process
*)grab_object( current
->process
);
84 else if (!(process
= get_process_from_id( pid
))) return NULL
;
87 if (!(snapshot
= alloc_object( &snapshot_ops
, -1 )))
89 if (process
) release_object( process
);
93 snapshot
->process
= process
;
95 snapshot
->process_pos
= 0;
96 snapshot
->process_count
= 0;
97 if (flags
& SNAP_PROCESS
)
98 snapshot
->processes
= process_snap( &snapshot
->process_count
);
100 snapshot
->thread_pos
= 0;
101 snapshot
->thread_count
= 0;
102 if (flags
& SNAP_THREAD
)
103 snapshot
->threads
= thread_snap( &snapshot
->thread_count
);
105 snapshot
->module_pos
= 0;
106 snapshot
->module_count
= 0;
107 if (flags
& SNAP_MODULE
)
108 snapshot
->modules
= module_snap( process
, &snapshot
->module_count
);
113 /* get the next process in the snapshot */
114 static int snapshot_next_process( struct snapshot
*snapshot
, struct next_process_reply
*reply
)
116 struct process_snapshot
*ptr
;
118 if (!snapshot
->process_count
)
120 set_error( STATUS_INVALID_PARAMETER
); /* FIXME */
123 if (snapshot
->process_pos
>= snapshot
->process_count
)
125 set_error( STATUS_NO_MORE_FILES
);
128 ptr
= &snapshot
->processes
[snapshot
->process_pos
++];
129 reply
->count
= ptr
->count
;
130 reply
->pid
= get_process_id( ptr
->process
);
131 reply
->ppid
= get_process_id( ptr
->process
->parent
);
132 reply
->heap
= 0; /* FIXME */
133 reply
->module
= 0; /* FIXME */
134 reply
->threads
= ptr
->threads
;
135 reply
->priority
= ptr
->priority
;
136 if (ptr
->process
->exe
.filename
)
138 size_t len
= min( ptr
->process
->exe
.namelen
, get_reply_max_size() );
139 set_reply_data( ptr
->process
->exe
.filename
, len
);
144 /* get the next thread in the snapshot */
145 static int snapshot_next_thread( struct snapshot
*snapshot
, struct next_thread_reply
*reply
)
147 struct thread_snapshot
*ptr
;
149 if (!snapshot
->thread_count
)
151 set_error( STATUS_INVALID_PARAMETER
); /* FIXME */
154 if (snapshot
->thread_pos
>= snapshot
->thread_count
)
156 set_error( STATUS_NO_MORE_FILES
);
159 ptr
= &snapshot
->threads
[snapshot
->thread_pos
++];
160 reply
->count
= ptr
->count
;
161 reply
->pid
= get_process_id( ptr
->thread
->process
);
162 reply
->tid
= get_thread_id( ptr
->thread
);
163 reply
->base_pri
= ptr
->priority
;
164 reply
->delta_pri
= 0; /* FIXME */
168 /* get the next module in the snapshot */
169 static int snapshot_next_module( struct snapshot
*snapshot
, struct next_module_reply
*reply
)
171 struct module_snapshot
*ptr
;
173 if (!snapshot
->module_count
)
175 set_error( STATUS_INVALID_PARAMETER
); /* FIXME */
178 if (snapshot
->module_pos
>= snapshot
->module_count
)
180 set_error( STATUS_NO_MORE_FILES
);
183 ptr
= &snapshot
->modules
[snapshot
->module_pos
++];
184 reply
->pid
= get_process_id( snapshot
->process
);
185 reply
->base
= ptr
->base
;
186 reply
->size
= ptr
->size
;
189 size_t len
= min( ptr
->namelen
, get_reply_max_size() );
190 set_reply_data( ptr
->filename
, len
);
195 static void snapshot_dump( struct object
*obj
, int verbose
)
197 struct snapshot
*snapshot
= (struct snapshot
*)obj
;
198 assert( obj
->ops
== &snapshot_ops
);
199 fprintf( stderr
, "Snapshot: %d procs %d threads %d modules\n",
200 snapshot
->process_count
, snapshot
->thread_count
, snapshot
->module_count
);
203 static void snapshot_destroy( struct object
*obj
)
206 struct snapshot
*snapshot
= (struct snapshot
*)obj
;
207 assert( obj
->ops
== &snapshot_ops
);
208 if (snapshot
->process_count
)
210 for (i
= 0; i
< snapshot
->process_count
; i
++)
211 release_object( snapshot
->processes
[i
].process
);
212 free( snapshot
->processes
);
214 if (snapshot
->thread_count
)
216 for (i
= 0; i
< snapshot
->thread_count
; i
++)
217 release_object( snapshot
->threads
[i
].thread
);
218 free( snapshot
->threads
);
220 if (snapshot
->module_count
)
222 for (i
= 0; i
< snapshot
->module_count
; i
++)
223 free( snapshot
->modules
[i
].filename
);
224 free( snapshot
->modules
);
226 if (snapshot
->process
) release_object( snapshot
->process
);
229 /* create a snapshot */
230 DECL_HANDLER(create_snapshot
)
232 struct snapshot
*snapshot
;
235 if ((snapshot
= create_snapshot( req
->pid
, req
->flags
)))
237 reply
->handle
= alloc_handle( current
->process
, snapshot
, 0, req
->inherit
);
238 release_object( snapshot
);
242 /* get the next process from a snapshot */
243 DECL_HANDLER(next_process
)
245 struct snapshot
*snapshot
;
247 if ((snapshot
= (struct snapshot
*)get_handle_obj( current
->process
, req
->handle
,
250 if (req
->reset
) snapshot
->process_pos
= 0;
251 snapshot_next_process( snapshot
, reply
);
252 release_object( snapshot
);
256 /* get the next thread from a snapshot */
257 DECL_HANDLER(next_thread
)
259 struct snapshot
*snapshot
;
261 if ((snapshot
= (struct snapshot
*)get_handle_obj( current
->process
, req
->handle
,
264 if (req
->reset
) snapshot
->thread_pos
= 0;
265 snapshot_next_thread( snapshot
, reply
);
266 release_object( snapshot
);
270 /* get the next module from a snapshot */
271 DECL_HANDLER(next_module
)
273 struct snapshot
*snapshot
;
275 if ((snapshot
= (struct snapshot
*)get_handle_obj( current
->process
, req
->handle
,
278 if (req
->reset
) snapshot
->module_pos
= 0;
279 snapshot_next_module( snapshot
, reply
);
280 release_object( snapshot
);