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
38 struct object obj
; /* object header */
39 struct process
*process
; /* process of this snapshot (for modules and heaps) */
40 struct process_snapshot
*processes
; /* processes snapshot */
41 int process_count
; /* count of processes */
42 int process_pos
; /* current position in proc snapshot */
43 struct thread_snapshot
*threads
; /* threads snapshot */
44 int thread_count
; /* count of threads */
45 int thread_pos
; /* current position in thread snapshot */
46 struct module_snapshot
*modules
; /* modules snapshot */
47 int module_count
; /* count of modules */
48 int module_pos
; /* current position in module snapshot */
51 static void snapshot_dump( struct object
*obj
, int verbose
);
52 static void snapshot_destroy( struct object
*obj
);
54 static const struct object_ops snapshot_ops
=
56 sizeof(struct snapshot
), /* size */
57 snapshot_dump
, /* dump */
58 no_add_queue
, /* add_queue */
59 NULL
, /* remove_queue */
62 NULL
, /* get_poll_events */
63 NULL
, /* poll_event */
64 no_get_fd
, /* get_fd */
66 no_get_file_info
, /* get_file_info */
67 NULL
, /* queue_async */
68 snapshot_destroy
/* destroy */
72 /* create a new snapshot */
73 static struct snapshot
*create_snapshot( void *pid
, int flags
)
75 struct process
*process
= NULL
;
76 struct snapshot
*snapshot
;
78 /* need a process for modules and heaps */
79 if (flags
& (TH32CS_SNAPMODULE
|TH32CS_SNAPHEAPLIST
))
81 if (!pid
) process
= (struct process
*)grab_object( current
->process
);
82 else if (!(process
= get_process_from_id( pid
))) return NULL
;
85 if (!(snapshot
= alloc_object( &snapshot_ops
, -1 )))
87 if (process
) release_object( process
);
91 snapshot
->process
= process
;
93 snapshot
->process_pos
= 0;
94 snapshot
->process_count
= 0;
95 if (flags
& TH32CS_SNAPPROCESS
)
96 snapshot
->processes
= process_snap( &snapshot
->process_count
);
98 snapshot
->thread_pos
= 0;
99 snapshot
->thread_count
= 0;
100 if (flags
& TH32CS_SNAPTHREAD
)
101 snapshot
->threads
= thread_snap( &snapshot
->thread_count
);
103 snapshot
->module_pos
= 0;
104 snapshot
->module_count
= 0;
105 if (flags
& TH32CS_SNAPMODULE
)
106 snapshot
->modules
= module_snap( process
, &snapshot
->module_count
);
111 /* get the next process in the snapshot */
112 static int snapshot_next_process( struct snapshot
*snapshot
, struct next_process_reply
*reply
)
114 struct process_snapshot
*ptr
;
116 if (!snapshot
->process_count
)
118 set_error( STATUS_INVALID_PARAMETER
); /* FIXME */
121 if (snapshot
->process_pos
>= snapshot
->process_count
)
123 set_error( STATUS_NO_MORE_FILES
);
126 ptr
= &snapshot
->processes
[snapshot
->process_pos
++];
127 reply
->count
= ptr
->count
;
128 reply
->pid
= get_process_id( ptr
->process
);
129 reply
->ppid
= get_process_id( ptr
->process
->parent
);
130 reply
->heap
= 0; /* FIXME */
131 reply
->module
= 0; /* FIXME */
132 reply
->threads
= ptr
->threads
;
133 reply
->priority
= ptr
->priority
;
134 if (ptr
->process
->exe
.filename
)
136 size_t len
= min( ptr
->process
->exe
.namelen
, get_reply_max_size() );
137 set_reply_data( ptr
->process
->exe
.filename
, len
);
142 /* get the next thread in the snapshot */
143 static int snapshot_next_thread( struct snapshot
*snapshot
, struct next_thread_reply
*reply
)
145 struct thread_snapshot
*ptr
;
147 if (!snapshot
->thread_count
)
149 set_error( STATUS_INVALID_PARAMETER
); /* FIXME */
152 if (snapshot
->thread_pos
>= snapshot
->thread_count
)
154 set_error( STATUS_NO_MORE_FILES
);
157 ptr
= &snapshot
->threads
[snapshot
->thread_pos
++];
158 reply
->count
= ptr
->count
;
159 reply
->pid
= get_process_id( ptr
->thread
->process
);
160 reply
->tid
= get_thread_id( ptr
->thread
);
161 reply
->base_pri
= ptr
->priority
;
162 reply
->delta_pri
= 0; /* FIXME */
166 /* get the next module in the snapshot */
167 static int snapshot_next_module( struct snapshot
*snapshot
, struct next_module_reply
*reply
)
169 struct module_snapshot
*ptr
;
171 if (!snapshot
->module_count
)
173 set_error( STATUS_INVALID_PARAMETER
); /* FIXME */
176 if (snapshot
->module_pos
>= snapshot
->module_count
)
178 set_error( STATUS_NO_MORE_FILES
);
181 ptr
= &snapshot
->modules
[snapshot
->module_pos
++];
182 reply
->pid
= get_process_id( snapshot
->process
);
183 reply
->base
= ptr
->base
;
184 reply
->size
= ptr
->size
;
187 size_t len
= min( ptr
->namelen
, get_reply_max_size() );
188 set_reply_data( ptr
->filename
, len
);
193 static void snapshot_dump( struct object
*obj
, int verbose
)
195 struct snapshot
*snapshot
= (struct snapshot
*)obj
;
196 assert( obj
->ops
== &snapshot_ops
);
197 fprintf( stderr
, "Snapshot: %d procs %d threads %d modules\n",
198 snapshot
->process_count
, snapshot
->thread_count
, snapshot
->module_count
);
201 static void snapshot_destroy( struct object
*obj
)
204 struct snapshot
*snapshot
= (struct snapshot
*)obj
;
205 assert( obj
->ops
== &snapshot_ops
);
206 if (snapshot
->process_count
)
208 for (i
= 0; i
< snapshot
->process_count
; i
++)
209 release_object( snapshot
->processes
[i
].process
);
210 free( snapshot
->processes
);
212 if (snapshot
->thread_count
)
214 for (i
= 0; i
< snapshot
->thread_count
; i
++)
215 release_object( snapshot
->threads
[i
].thread
);
216 free( snapshot
->threads
);
218 if (snapshot
->module_count
)
220 for (i
= 0; i
< snapshot
->module_count
; i
++)
221 free( snapshot
->modules
[i
].filename
);
222 free( snapshot
->modules
);
224 if (snapshot
->process
) release_object( snapshot
->process
);
227 /* create a snapshot */
228 DECL_HANDLER(create_snapshot
)
230 struct snapshot
*snapshot
;
233 if ((snapshot
= create_snapshot( req
->pid
, req
->flags
)))
235 reply
->handle
= alloc_handle( current
->process
, snapshot
, 0, req
->inherit
);
236 release_object( snapshot
);
240 /* get the next process from a snapshot */
241 DECL_HANDLER(next_process
)
243 struct snapshot
*snapshot
;
245 if ((snapshot
= (struct snapshot
*)get_handle_obj( current
->process
, req
->handle
,
248 if (req
->reset
) snapshot
->process_pos
= 0;
249 snapshot_next_process( snapshot
, reply
);
250 release_object( snapshot
);
254 /* get the next thread from a snapshot */
255 DECL_HANDLER(next_thread
)
257 struct snapshot
*snapshot
;
259 if ((snapshot
= (struct snapshot
*)get_handle_obj( current
->process
, req
->handle
,
262 if (req
->reset
) snapshot
->thread_pos
= 0;
263 snapshot_next_thread( snapshot
, reply
);
264 release_object( snapshot
);
268 /* get the next module from a snapshot */
269 DECL_HANDLER(next_module
)
271 struct snapshot
*snapshot
;
273 if ((snapshot
= (struct snapshot
*)get_handle_obj( current
->process
, req
->handle
,
276 if (req
->reset
) snapshot
->module_pos
= 0;
277 snapshot_next_module( snapshot
, reply
);
278 release_object( snapshot
);