1 | /* |
---|
2 | ********************************************************************** |
---|
3 | * |
---|
4 | * Component: RDBG servers |
---|
5 | * Module: remdeb.x |
---|
6 | * |
---|
7 | * Synopsis: XDR definitions for remote debug server RPC calls. |
---|
8 | * XDR definitions for RPCGEN to build remote debug server. |
---|
9 | * |
---|
10 | * $Id$ |
---|
11 | * |
---|
12 | ********************************************************************** |
---|
13 | */ |
---|
14 | |
---|
15 | #ifdef RPC_SVC |
---|
16 | %/*HEADER_START*/ |
---|
17 | #endif |
---|
18 | |
---|
19 | %#define RTEMS_PORT 2071 |
---|
20 | %#define RTEMS_BACK_PORT 2073 |
---|
21 | |
---|
22 | #ifdef RPC_HDR |
---|
23 | %#ifndef REMDEB_H |
---|
24 | %#define RPCGENSRVNAME(a) a |
---|
25 | #endif |
---|
26 | |
---|
27 | enum rpc_type { |
---|
28 | SUNRPC = 0, |
---|
29 | BADRPCTYPE = 25 |
---|
30 | }; |
---|
31 | |
---|
32 | |
---|
33 | const NET_SAFE = 1400; /* this is safe for UDP messages */ |
---|
34 | |
---|
35 | struct UDP_MSG |
---|
36 | { /* format of UDP messages (should be in .h) */ |
---|
37 | unsigned char type; /* type of message (BMSG_xx) */ |
---|
38 | unsigned char msg_num; /* ringed number for resend detect */ |
---|
39 | unsigned short spec; /* specific information for type */ |
---|
40 | long pid; /* process this affects */ |
---|
41 | unsigned long context; /* specific information to request */ |
---|
42 | }; |
---|
43 | |
---|
44 | /* First we support the overhead structures and types needed for RPC |
---|
45 | requests. Then, we have all RPC routines input/output args. */ |
---|
46 | |
---|
47 | %/* |
---|
48 | % * Sun request values for the remote ptrace system call |
---|
49 | % */ |
---|
50 | % |
---|
51 | enum ptracereq |
---|
52 | { /* these match PTRACE_xxx numbers */ |
---|
53 | RPT_TRACEME = 0, /* 0, by tracee to begin tracing */ |
---|
54 | RPT_CHILDDONE = 0, /* 0, tracee is done with his half */ |
---|
55 | RPT_PEEKTEXT, /* 1, read word from text segment */ |
---|
56 | RPT_PEEKDATA, /* 2, read word from data segment */ |
---|
57 | RPT_PEEKUSER, /* 3, read word from user struct */ |
---|
58 | RPT_POKETEXT, /* 4, write word into text segment */ |
---|
59 | RPT_POKEDATA, /* 5, write word into data segment */ |
---|
60 | RPT_POKEUSER, /* 6, write word into user struct */ |
---|
61 | RPT_CONT, /* 7, continue process */ |
---|
62 | RPT_KILL, /* 8, terminate process */ |
---|
63 | RPT_SINGLESTEP, /* 9, single step process */ |
---|
64 | RPT_ATTACH, /* 10, attach to an existing process (returns 2 if not primary)*/ |
---|
65 | RPT_DETACH, /* 11, detach from a process */ |
---|
66 | RPT_GETREGS, /* 12, get all registers */ |
---|
67 | RPT_SETREGS, /* 13, set all registers */ |
---|
68 | RPT_GETFPREGS, /* 14, get all floating point regs */ |
---|
69 | RPT_SETFPREGS, /* 15, set all floating point regs */ |
---|
70 | RPT_READDATA, /* 16, read data segment */ |
---|
71 | RPT_WRITEDATA, /* 17, write data segment */ |
---|
72 | RPT_READTEXT, /* 18, read text segment */ |
---|
73 | RPT_WRITETEXT, /* 19, write text segment */ |
---|
74 | RPT_GETFPAREGS, /* 20, get all fpa regs */ |
---|
75 | RPT_SETFPAREGS, /* 21, set all fpa regs */ |
---|
76 | RPT_22, /* 22, filler */ |
---|
77 | RPT_23, /* 23, filler */ |
---|
78 | RPT_SYSCALL, /* 24, trap next sys call */ |
---|
79 | RPT_DUMPCORE, /* 25, dump process core */ |
---|
80 | RPT_26, /* 26, filler */ |
---|
81 | RPT_27, /* 27, filler */ |
---|
82 | RPT_28, /* 28, filler */ |
---|
83 | RPT_GETUCODE, /* 29, get u.u_code */ |
---|
84 | /* Begin specific ptrace options */ |
---|
85 | RPT_GETTARGETTHREAD = 50, /* get PM target thread identifier */ |
---|
86 | RPT_SETTARGETTHREAD = 51, /* set PM target thread identifier */ |
---|
87 | RPT_THREADSUSPEND = 52, /* suspend a thread */ |
---|
88 | RPT_THREADRESUME = 53, /* resume a thread */ |
---|
89 | RPT_THREADLIST = 54, /* get list of process's threads */ |
---|
90 | RPT_GETTHREADNAME = 55, /* get the name of the thread */ |
---|
91 | RPT_SETTHREADNAME = 56, /* set the name of the thread */ |
---|
92 | RPT_SETTHREADREGS = 57, /* set all registers for a specific thread*/ |
---|
93 | RPT_GETTHREADREGS = 58, /* get all registers for a specific thread*/ |
---|
94 | /* Begin extended ptrace options for remote debug server */ |
---|
95 | RPT_STEPRANGE = 75, /* step while in range (addr=start, data=len) */ |
---|
96 | RPT_CONTTO = 76, /* cont from PC to temp break in addr */ |
---|
97 | RPT_SETBREAK = 77, /* set a breakpoint (addr=break) */ |
---|
98 | RPT_CLRBREAK = 78, /* clear a breakpoint (data=handle or 0 for all) */ |
---|
99 | RPT_GETBREAK = 79, /* get breakpoint (data=handle, addr=buffer to |
---|
100 | fill). Returns next break. If data=0, |
---|
101 | returns number of breaks. */ |
---|
102 | RPT_GETNAME = 80, /* get name of process (data 0=name, 1=path |
---|
103 | as started, 2=fullpath). Return in addr |
---|
104 | as mem) */ |
---|
105 | RPT_STOP = 81, /* (C-actors) Stop the C-actor */ |
---|
106 | RPT_PGETREGS = 82, /* portable version */ |
---|
107 | RPT_PSETREGS = 83, /* portable version */ |
---|
108 | RPT_PSETTHREADREGS = 84, /* portable version */ |
---|
109 | RPT_PGETTHREADREGS = 85 /* portable version */ |
---|
110 | }; |
---|
111 | |
---|
112 | #include FRONTEND |
---|
113 | |
---|
114 | const MAXDEBUGGEE= 150; |
---|
115 | const NAMEMAX = 17; |
---|
116 | |
---|
117 | % /* |
---|
118 | % * Memory data for read/write text or data. The size is in data. The target |
---|
119 | % * addr is in the addr field. |
---|
120 | % * Be careful before modifying because this value goes into internal |
---|
121 | % * pipes and is allocated on stack too. Pipes and/or the stack could |
---|
122 | % * become too small if this value gets incremented. |
---|
123 | % */ |
---|
124 | |
---|
125 | const MEM_DATA_MAX = 256; |
---|
126 | |
---|
127 | #ifndef RPC_XDR |
---|
128 | |
---|
129 | struct xdr_mem { |
---|
130 | u_long addr; |
---|
131 | u_int dataNb; |
---|
132 | unsigned char data[MEM_DATA_MAX]; |
---|
133 | }; |
---|
134 | |
---|
135 | #else |
---|
136 | /* manually define best XDR function for this */ |
---|
137 | %bool_t xdr_xdr_mem(xdrs, objp) |
---|
138 | % XDR *xdrs; |
---|
139 | % struct xdr_mem *objp; |
---|
140 | %{ |
---|
141 | % if (!xdr_u_long(xdrs, &objp->addr)) { |
---|
142 | % return (FALSE); |
---|
143 | % } |
---|
144 | % if (!xdr_u_int(xdrs, &objp->dataNb)) { |
---|
145 | % return(FALSE); |
---|
146 | % } |
---|
147 | % return (xdr_opaque(xdrs, objp->data, objp->dataNb)); |
---|
148 | %} |
---|
149 | |
---|
150 | #endif |
---|
151 | |
---|
152 | /* Breakpoint structure maps to same structure on host. Do not change one |
---|
153 | without changing the other. */ |
---|
154 | |
---|
155 | enum break_type |
---|
156 | { /* types of breakpoints */ |
---|
157 | BRKT_NONE, /* unused entry */ |
---|
158 | BRKT_INSTR, /* general instruction break */ |
---|
159 | BRKT_READ, /* read break */ |
---|
160 | BRKT_WRITE, /* write breakpoint */ |
---|
161 | BRKT_ACCESS, /* read-or-write break */ |
---|
162 | BRKT_EXEC, /* execution HW breakpoint */ |
---|
163 | BRKT_OS_CALL, /* break on OS call, addr is call number */ |
---|
164 | BRKT_OS_SWITCH, /* dispatch breakpoint */ |
---|
165 | BRKT_STEPEMUL /* emulate hardware single-step */ |
---|
166 | }; |
---|
167 | const MAX_THRD_BRK = 4; /* enough for 128 threads per process */ |
---|
168 | struct xdr_break |
---|
169 | { /* one per process local breakpoint */ |
---|
170 | u_char type; /* BRKT_xxx type of break */ |
---|
171 | u_char thread_spec; /* 0=all, else count of threads it affects */ |
---|
172 | u_short handle; /* handle of breakpoint returned */ |
---|
173 | u_long ee_loc; /* address of start */ |
---|
174 | u_long ee_type; /* type/method of address */ |
---|
175 | u_short length; /* length of break if range, else 0 */ |
---|
176 | u_char pass_count; /* pass count to initialize to (0=none) */ |
---|
177 | u_char curr_pass; /* pass count current value */ |
---|
178 | u_long thread_list[MAX_THRD_BRK]; /* bit map for thread list */ |
---|
179 | }; /* 20 bytes+4 per thread_list (4x4=16) = 36 */ |
---|
180 | |
---|
181 | const UTHREAD_MAX = 64; |
---|
182 | |
---|
183 | const THREADNAMEMAX = 16; |
---|
184 | typedef string thread_name <THREADNAMEMAX>; |
---|
185 | |
---|
186 | struct KernThread { |
---|
187 | unsigned int threadLi; |
---|
188 | }; |
---|
189 | |
---|
190 | #ifndef RPC_XDR |
---|
191 | |
---|
192 | #ifdef RPC_HDR |
---|
193 | %typedef KernThread *ptThreadList; |
---|
194 | #endif |
---|
195 | |
---|
196 | struct thread_list { |
---|
197 | unsigned int nbThread; |
---|
198 | ptThreadList threads; |
---|
199 | }; |
---|
200 | |
---|
201 | #else /* RPC_XDR */ |
---|
202 | |
---|
203 | /* must write this function by hand */ |
---|
204 | |
---|
205 | %bool_t xdr_thread_list(xdrs, objp) |
---|
206 | % XDR *xdrs; |
---|
207 | % struct thread_list *objp; |
---|
208 | %{ |
---|
209 | % return (xdr_array(xdrs, (char**)&objp->threads, &objp->nbThread, |
---|
210 | % UTHREAD_MAX, sizeof(KernThread), xdr_KernThread)); |
---|
211 | %} |
---|
212 | |
---|
213 | #endif /* not RPC_XDR */ |
---|
214 | |
---|
215 | |
---|
216 | union ptrace_addr_data_in switch (ptracereq req) { |
---|
217 | /* |
---|
218 | * due to rpcgen poor features, we cannot put RPC_SETREGS |
---|
219 | * AND RPC_SETTHREADREGS in the case list. So we use a hack (FIX rpcgen). |
---|
220 | */ |
---|
221 | #ifndef RPC_HDR |
---|
222 | case RPT_SETTHREADREGS : |
---|
223 | xdr_regs regs; |
---|
224 | #endif |
---|
225 | case RPT_SETREGS: |
---|
226 | |
---|
227 | xdr_regs regs; |
---|
228 | |
---|
229 | #ifndef RPC_HDR |
---|
230 | case RPT_PSETTHREADREGS: |
---|
231 | u_int pregs<>; |
---|
232 | #endif |
---|
233 | case RPT_PSETREGS: |
---|
234 | u_int pregs<>; |
---|
235 | |
---|
236 | #ifdef LATER |
---|
237 | case RPT_SETFPREGS: |
---|
238 | xdr_fp_status fpregs; |
---|
239 | #endif |
---|
240 | case RPT_SETTHREADNAME: |
---|
241 | thread_name name; |
---|
242 | #ifndef RPC_HDR |
---|
243 | case RPT_WRITETEXT: |
---|
244 | xdr_mem mem; |
---|
245 | #endif |
---|
246 | case RPT_WRITEDATA: |
---|
247 | xdr_mem mem; |
---|
248 | case RPT_SETBREAK: |
---|
249 | xdr_break breakp; |
---|
250 | default: |
---|
251 | u_int address; |
---|
252 | }; |
---|
253 | |
---|
254 | union ptrace_addr_data_out switch (ptracereq req) { |
---|
255 | case RPT_GETREGS: |
---|
256 | xdr_regs regs; |
---|
257 | #ifndef RPC_HDR |
---|
258 | case RPT_GETTHREADREGS: |
---|
259 | xdr_regs regs; |
---|
260 | #endif |
---|
261 | |
---|
262 | case RPT_PGETREGS: |
---|
263 | u_int pregs<>; |
---|
264 | |
---|
265 | #ifndef RPC_HDR |
---|
266 | case RPT_PGETTHREADREGS: |
---|
267 | u_int pregs<>; |
---|
268 | #endif |
---|
269 | |
---|
270 | #ifdef LATER |
---|
271 | case RPT_GETFPREGS: |
---|
272 | xdr_fp_status fpregs; |
---|
273 | #endif |
---|
274 | case RPT_THREADLIST: |
---|
275 | thread_list threads; |
---|
276 | case RPT_GETTHREADNAME: |
---|
277 | thread_name name; |
---|
278 | #ifndef RPC_HDR |
---|
279 | case RPT_READTEXT: |
---|
280 | xdr_mem mem; |
---|
281 | case RPT_GETNAME: |
---|
282 | xdr_mem mem; |
---|
283 | #endif |
---|
284 | case RPT_READDATA: |
---|
285 | xdr_mem mem; |
---|
286 | case RPT_GETBREAK: |
---|
287 | xdr_break breakp; |
---|
288 | default: |
---|
289 | u_int addr; |
---|
290 | }; |
---|
291 | |
---|
292 | typedef opaque CHAR_DATA <NET_SAFE>; /* variable sized data */ |
---|
293 | |
---|
294 | const XRY_MAX_INST_BUFF = 128; |
---|
295 | const XRY_MAX_INSTANCES = 16; |
---|
296 | %#ifndef XRY_MAX_CMD_STR |
---|
297 | const XRY_MAX_CMD_STR = 320; /* XRY_MAX_INST_BUFF+(XRY_MAX_INSTANCES*12) */ |
---|
298 | %#endif /* REMDEB_H */ |
---|
299 | |
---|
300 | |
---|
301 | struct xry_inst |
---|
302 | { |
---|
303 | unsigned char flags; /* value2 interp, etc. INFL_xxx */ |
---|
304 | unsigned char type; /* base type of data (str, val, etc) INST_xxx */ |
---|
305 | unsigned char sub_type; /* specific type (task, res, etc). This is |
---|
306 | set and defined by the user defined instance |
---|
307 | processor and not the auto-processor */ |
---|
308 | unsigned char res_type; |
---|
309 | u_long value; /* pointer to value or value itself */ |
---|
310 | u_long value2; /* second value (optional - based on flags) */ |
---|
311 | }; |
---|
312 | |
---|
313 | struct instance |
---|
314 | { |
---|
315 | struct xry_inst instances[XRY_MAX_INSTANCES]; |
---|
316 | unsigned char buffer[XRY_MAX_INST_BUFF]; |
---|
317 | }; |
---|
318 | |
---|
319 | union instance_union switch (bool instances) |
---|
320 | { |
---|
321 | case TRUE: |
---|
322 | instance inst; |
---|
323 | case FALSE: |
---|
324 | string buffer <XRY_MAX_CMD_STR>; |
---|
325 | }; |
---|
326 | |
---|
327 | typedef string one_arg <NET_SAFE>; |
---|
328 | |
---|
329 | const XRY_MAX_OBJ_NAME = 32; /* objname in some commands */ |
---|
330 | |
---|
331 | % /* now open_connex() routine which establishes a connection to server */ |
---|
332 | |
---|
333 | enum debug_type |
---|
334 | { /* type of connection requested */ |
---|
335 | DEBTYP_PROCESS = 0, /* process connection */ |
---|
336 | DEBTYP_C_ACTOR = 1, /* C-Actor connection */ |
---|
337 | DEBTYP_KERNEL = 2, /* kernel debug connection */ |
---|
338 | DEBTYP_OTHER = 3 /* other subsystem */ |
---|
339 | }; |
---|
340 | |
---|
341 | %#define DEBUGGER_IS_GDB 0x2 /* */ |
---|
342 | |
---|
343 | struct open_in |
---|
344 | { /* input args to open a connection */ |
---|
345 | u_char back_port[16]; /* opaque NET address format */ |
---|
346 | u_short debug_type; /* type of process DEBTYP_xxx */ |
---|
347 | u_short flags; /* connection information OPNFLG_xxx */ |
---|
348 | u_char destination[16];/* opaque address if to router */ |
---|
349 | one_arg user_name; /* name of user on host */ |
---|
350 | }; |
---|
351 | |
---|
352 | struct open_out |
---|
353 | { /* return from open_connex */ |
---|
354 | u_long port; /* connection number to server or -1 if error */ |
---|
355 | u_int pad[4]; /* Planned to be KnIpcDest. Never used */ |
---|
356 | u_int fp; /* True if floating point processor. If error, |
---|
357 | set to errno for open error. */ |
---|
358 | u_char cmd_table_num; /* command table used */ |
---|
359 | u_char cmd_table_vers; /* version of command table */ |
---|
360 | u_short server_vers; /* version number of server itself */ |
---|
361 | }; |
---|
362 | |
---|
363 | % /* now close_connex() routine which detaches from server */ |
---|
364 | |
---|
365 | enum close_control |
---|
366 | { /* choice of how to handle owned processes */ |
---|
367 | CLOSE_IGNORE = 0, /* ignore all controlled pids on close */ |
---|
368 | CLOSE_KILL = 1, /* kill all controlled pids on close */ |
---|
369 | CLOSE_DETACH = 2 /* detach free running all controlled pids */ |
---|
370 | }; |
---|
371 | |
---|
372 | struct close_in |
---|
373 | { /* arg to close connection */ |
---|
374 | close_control control; /* shutdown of owned processes control */ |
---|
375 | }; |
---|
376 | |
---|
377 | % /* now send_signal() routine which sends signals to processes like kill(2) */ |
---|
378 | |
---|
379 | struct signal_in |
---|
380 | { /* input to send_signal */ |
---|
381 | int pid; /* process/actor to send signal to */ |
---|
382 | int sig; /* signal to send (from /usr/include/signal.h) */ |
---|
383 | }; |
---|
384 | |
---|
385 | struct signal_out |
---|
386 | { /* return from send_signal */ |
---|
387 | int kill_return; /* return code from kill(2) call */ |
---|
388 | int errNo; /* error code if failed */ |
---|
389 | }; |
---|
390 | |
---|
391 | |
---|
392 | % /* now wait_info() routine which returns results of polling the wait status |
---|
393 | % of a process/actor. It may return 0 if running, else pid or -1 */ |
---|
394 | |
---|
395 | enum stop_code |
---|
396 | { /* stop code information */ |
---|
397 | STOP_ERROR = 0, /* error, errno set */ |
---|
398 | STOP_NONE = 1, /* not stopped */ |
---|
399 | STOP_UNKNOWN = 2, /* unknown stop reason */ |
---|
400 | STOP_BREAK = 3, /* stopped on breakpoint */ |
---|
401 | STOP_STEP = 4, /* stopped on step */ |
---|
402 | STOP_SIGNAL = 5, /* stopped on signal receieve */ |
---|
403 | STOP_TERM_EXIT = 6, /* terminated normally */ |
---|
404 | STOP_TERM_SIG = 7, /* terminated by signal */ |
---|
405 | STOP_DETACHED = 8, /* detached from server */ |
---|
406 | STOP_KILLED = 9, /* killed by ptrace KILL */ |
---|
407 | STOP_SPAWN_FAILED = 10 /* spawn failed in exec part, handle=errno */ |
---|
408 | }; |
---|
409 | |
---|
410 | struct wait_in |
---|
411 | { /* input arg to wait is process */ |
---|
412 | int pid; /* process/actor id */ |
---|
413 | }; |
---|
414 | |
---|
415 | struct wait_out |
---|
416 | { /* result of wait_info call */ |
---|
417 | int wait_return; /* -1=error,0=running,pid=stopped */ |
---|
418 | int errNo; /* error code if error */ |
---|
419 | int status; /* wait(2) status if stopped */ |
---|
420 | stop_code reason; /* reason in more abstracted terms */ |
---|
421 | int handle; /* handle of break if stopped on break, |
---|
422 | or signal number or exit code */ |
---|
423 | u_long PC; /* program counter if stopped */ |
---|
424 | u_long SP; /* stack pointer if stopped */ |
---|
425 | u_long FP; /* frame pointer if stopped */ |
---|
426 | u_long thread; /* thread that stopped if applies (else -1) */ |
---|
427 | }; |
---|
428 | |
---|
429 | % /* now ptrace() routine. This matches the Sun UNIX ptrace as well as |
---|
430 | % some additions */ |
---|
431 | |
---|
432 | const PTRFLG_FORCE = 1; /* when set and process running, forces process |
---|
433 | to stop, make the request, then start again. |
---|
434 | This is used for breakpoints and the like */ |
---|
435 | const PTRFLG_NON_OWNER = 2; /* do request even if not primary owner (will |
---|
436 | notify all owners including caller if owns) */ |
---|
437 | const PTRFLG_FREE = 4; /* free pid_list after KILL/DETACH */ |
---|
438 | |
---|
439 | const PTRDET_UNOWN = 0x100; /* data value in RPT_DETACH just disconnects |
---|
440 | caller as an owner of process. */ |
---|
441 | |
---|
442 | struct ptrace_in |
---|
443 | { /* input args matches ptrace but for XDR */ |
---|
444 | int pid; /* process to act on */ |
---|
445 | ptrace_addr_data_in addr; /* mappings for addr and addr2 */ |
---|
446 | u_int data; /* simple data arg of ptrace */ |
---|
447 | u_int flags; /* mask of PTRFLG_xxx flags. */ |
---|
448 | }; |
---|
449 | |
---|
450 | struct ptrace_out |
---|
451 | { /* return information from ptrace */ |
---|
452 | ptrace_addr_data_out addr; /* return through addr/addr2 */ |
---|
453 | int result; /* result of ptrace call (return value) */ |
---|
454 | int errNo; /* error code if error */ |
---|
455 | }; |
---|
456 | |
---|
457 | /* Data for GET_GLOBAL_SYMBOLS */ |
---|
458 | struct one_symbol { /* Must match common/src/lib/ctx/ctx.h */ |
---|
459 | string symbolName<>; |
---|
460 | long symbolValue; |
---|
461 | }; |
---|
462 | |
---|
463 | typedef one_symbol all_symbols<>; |
---|
464 | |
---|
465 | struct get_global_symbols_out { |
---|
466 | all_symbols symbols; |
---|
467 | }; |
---|
468 | |
---|
469 | /* Data for GET_TEXT_DATA */ |
---|
470 | struct get_text_data_in { |
---|
471 | int pid; /* process/actor id if non-zero */ |
---|
472 | string actorName<16>; /* actor name for system mode */ |
---|
473 | }; |
---|
474 | |
---|
475 | struct get_text_data_out { |
---|
476 | int result; |
---|
477 | int errNo; |
---|
478 | u_long textStart; |
---|
479 | u_long textSize; |
---|
480 | u_long dataStart; |
---|
481 | u_long dataSize; |
---|
482 | }; |
---|
483 | |
---|
484 | /* Data for GET_SIGNAL_NAMES */ |
---|
485 | struct one_signal { |
---|
486 | u_int number; |
---|
487 | string name<>; |
---|
488 | }; |
---|
489 | |
---|
490 | typedef one_signal all_signals<>; |
---|
491 | |
---|
492 | struct get_signal_names_out { |
---|
493 | all_signals signals; |
---|
494 | }; |
---|
495 | |
---|
496 | % /* now define the actual calls we support */ |
---|
497 | |
---|
498 | program REMOTEDEB { |
---|
499 | version REMOTEVERS { |
---|
500 | |
---|
501 | /* open a connection to server or router */ |
---|
502 | open_out |
---|
503 | OPEN_CONNEX(open_in) = 1; |
---|
504 | |
---|
505 | /* send a signal to a process */ |
---|
506 | signal_out |
---|
507 | SEND_SIGNAL(signal_in) = 2; |
---|
508 | |
---|
509 | /* all routines below require a connection first */ |
---|
510 | |
---|
511 | /* close the connection to the server */ |
---|
512 | void |
---|
513 | CLOSE_CONNEX(close_in) = 10; |
---|
514 | |
---|
515 | /* process ptrace request */ |
---|
516 | ptrace_out |
---|
517 | PTRACE(ptrace_in) = 11; |
---|
518 | |
---|
519 | /* poll for status of process */ |
---|
520 | wait_out |
---|
521 | WAIT_INFO(wait_in) = 13; |
---|
522 | |
---|
523 | get_signal_names_out |
---|
524 | GET_SIGNAL_NAMES(void) = 17; |
---|
525 | |
---|
526 | } = 2; /* now version 2 */ |
---|
527 | } = 0x20000fff; |
---|
528 | |
---|
529 | #ifdef RPC_HDR |
---|
530 | %#define REMDEB_H |
---|
531 | %#endif |
---|
532 | #endif |
---|
533 | |
---|
534 | #ifdef RPC_SVC |
---|
535 | |
---|
536 | %const char* names [] = { |
---|
537 | % "NULLPROC", "OPEN_CONNEX", "SEND_SIGNAL", "name3", |
---|
538 | % "name4", "name5", "name6", "name7", |
---|
539 | % "name8", "name9", "CLOSE_CONNEX", "PTRACE", |
---|
540 | % "name12", "WAIT_INFO", "name14", "name15", |
---|
541 | % "name16", "GET_SIGNAL_NAMES", "name18" |
---|
542 | %}; |
---|
543 | % |
---|
544 | |
---|
545 | %/*HEADER_END*/ |
---|
546 | #endif |
---|