projects / deliverable / binutils-gdb.git / blob
? search:


6692ec1f27cb36687f0770ab0cec46b775a198fd
[deliverable/binutils-gdb.git] / gdb / linux-record.c
1 /* Process record and replay target code for GNU/Linux.
2
3 Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 #include "defs.h"
21 #include "target.h"
22 #include "gdbtypes.h"
23 #include "regcache.h"
24 #include "record.h"
25 #include "linux-record.h"
26
27 /* These macros are the values of the first argument of system call
28 "sys_ptrace". The values of these macros were obtained from Linux
29 Kernel source. */
30
31 #define RECORD_PTRACE_PEEKTEXT 1
32 #define RECORD_PTRACE_PEEKDATA 2
33 #define RECORD_PTRACE_PEEKUSR 3
34
35 /* These macros are the values of the first argument of system call
36 "sys_socketcall". The values of these macros were obtained from
37 Linux Kernel source. */
38
39 #define RECORD_SYS_SOCKET 1
40 #define RECORD_SYS_BIND 2
41 #define RECORD_SYS_CONNECT 3
42 #define RECORD_SYS_LISTEN 4
43 #define RECORD_SYS_ACCEPT 5
44 #define RECORD_SYS_GETSOCKNAME 6
45 #define RECORD_SYS_GETPEERNAME 7
46 #define RECORD_SYS_SOCKETPAIR 8
47 #define RECORD_SYS_SEND 9
48 #define RECORD_SYS_RECV 10
49 #define RECORD_SYS_SENDTO 11
50 #define RECORD_SYS_RECVFROM 12
51 #define RECORD_SYS_SHUTDOWN 13
52 #define RECORD_SYS_SETSOCKOPT 14
53 #define RECORD_SYS_GETSOCKOPT 15
54 #define RECORD_SYS_SENDMSG 16
55 #define RECORD_SYS_RECVMSG 17
56
57 /* These macros are the values of the first argument of system call
58 "sys_ipc". The values of these macros were obtained from Linux
59 Kernel source. */
60
61 #define RECORD_SEMOP 1
62 #define RECORD_SEMGET 2
63 #define RECORD_SEMCTL 3
64 #define RECORD_SEMTIMEDOP 4
65 #define RECORD_MSGSND 11
66 #define RECORD_MSGRCV 12
67 #define RECORD_MSGGET 13
68 #define RECORD_MSGCTL 14
69 #define RECORD_SHMAT 21
70 #define RECORD_SHMDT 22
71 #define RECORD_SHMGET 23
72 #define RECORD_SHMCTL 24
73
74 /* These macros are the values of the first argument of system call
75 "sys_quotactl". The values of these macros were obtained from Linux
76 Kernel source. */
77
78 #define RECORD_Q_GETFMT 0x800004
79 #define RECORD_Q_GETINFO 0x800005
80 #define RECORD_Q_GETQUOTA 0x800007
81 #define RECORD_Q_XGETQSTAT (('5' << 8) + 5)
82 #define RECORD_Q_XGETQUOTA (('3' << 8) + 3)
83
84 #define OUTPUT_REG(val, num) phex_nz ((val), \
85 TYPE_LENGTH (gdbarch_register_type (get_regcache_arch (regcache), (num))))
86
87 static int
88 record_linux_sockaddr (struct regcache *regcache,
89 struct linux_record_tdep *tdep, ULONGEST addr,
90 ULONGEST len)
91 {
92 gdb_byte *a;
93 int addrlen;
94 struct gdbarch *gdbarch = get_regcache_arch (regcache);
95 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
96
97 if (!addr)
98 return 0;
99
100 a = alloca (tdep->size_int);
101
102 if (record_arch_list_add_mem ((CORE_ADDR) len, tdep->size_int))
103 return -1;
104
105 /* Get the addrlen. */
106 if (target_read_memory ((CORE_ADDR) len, a, tdep->size_int))
107 {
108 if (record_debug)
109 fprintf_unfiltered (gdb_stdlog,
110 "Process record: error reading "
111 "memory at addr = 0x%s len = %d.\n",
112 phex_nz (len, tdep->size_pointer),
113 tdep->size_int);
114 return -1;
115 }
116 addrlen = (int) extract_unsigned_integer (a, tdep->size_int, byte_order);
117 if (addrlen <= 0 || addrlen > tdep->size_sockaddr)
118 addrlen = tdep->size_sockaddr;
119
120 if (record_arch_list_add_mem ((CORE_ADDR) addr, addrlen))
121 return -1;
122
123 return 0;
124 }
125
126 static int
127 record_linux_msghdr (struct regcache *regcache,
128 struct linux_record_tdep *tdep, ULONGEST addr)
129 {
130 gdb_byte *a;
131 struct gdbarch *gdbarch = get_regcache_arch (regcache);
132 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
133 CORE_ADDR tmpaddr;
134 int tmpint;
135
136 if (!addr)
137 return 0;
138
139 if (record_arch_list_add_mem ((CORE_ADDR) addr, tdep->size_msghdr))
140 return -1;
141
142 a = alloca (tdep->size_msghdr);
143 if (target_read_memory ((CORE_ADDR) addr, a, tdep->size_msghdr))
144 {
145 if (record_debug)
146 fprintf_unfiltered (gdb_stdlog,
147 "Process record: error reading "
148 "memory at addr = 0x%s "
149 "len = %d.\n",
150 phex_nz (addr, tdep->size_pointer),
151 tdep->size_msghdr);
152 return -1;
153 }
154
155 /* msg_name msg_namelen */
156 addr = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
157 a += tdep->size_pointer;
158 if (record_arch_list_add_mem ((CORE_ADDR) addr,
159 (int) extract_unsigned_integer (a,
160 tdep->size_int,
161 byte_order)))
162 return -1;
163 a += tdep->size_int;
164
165 /* msg_iov msg_iovlen */
166 addr = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
167 a += tdep->size_pointer;
168 if (addr)
169 {
170 ULONGEST i;
171 ULONGEST len = extract_unsigned_integer (a, tdep->size_size_t,
172 byte_order);
173 gdb_byte *iov = alloca (tdep->size_iovec);
174
175 for (i = 0; i < len; i++)
176 {
177 if (target_read_memory ((CORE_ADDR) addr, iov, tdep->size_iovec))
178 {
179 if (record_debug)
180 fprintf_unfiltered (gdb_stdlog,
181 "Process record: error "
182 "reading memory at "
183 "addr = 0x%s "
184 "len = %d.\n",
185 phex_nz (addr,tdep->size_pointer),
186 tdep->size_iovec);
187 return -1;
188 }
189 tmpaddr = (CORE_ADDR) extract_unsigned_integer (iov,
190 tdep->size_pointer,
191 byte_order);
192 tmpint = (int) extract_unsigned_integer (iov + tdep->size_pointer,
193 tdep->size_size_t,
194 byte_order);
195 if (record_arch_list_add_mem (tmpaddr, tmpint))
196 return -1;
197 addr += tdep->size_iovec;
198 }
199 }
200 a += tdep->size_size_t;
201
202 /* msg_control msg_controllen */
203 addr = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
204 a += tdep->size_pointer;
205 tmpint = (int) extract_unsigned_integer (a, tdep->size_size_t, byte_order);
206 if (record_arch_list_add_mem ((CORE_ADDR) addr, tmpint))
207 return -1;
208
209 return 0;
210 }
211
212 /* When the architecture process record get a Linux syscall
213 instruction, it will get a Linux syscall number of this
214 architecture and convert it to the Linux syscall number "num" which
215 is internal to GDB. Most Linux syscalls across architectures in
216 Linux would be similar and mostly differ by sizes of types and
217 structures. This sizes are put to "tdep".
218
219 Record the values of the registers and memory that will be changed
220 in current system call.
221
222 Return -1 if something wrong. */
223
224 int
225 record_linux_system_call (enum gdb_syscall syscall,
226 struct regcache *regcache,
227 struct linux_record_tdep *tdep)
228 {
229 struct gdbarch *gdbarch = get_regcache_arch (regcache);
230 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
231 ULONGEST tmpulongest;
232 CORE_ADDR tmpaddr;
233 int tmpint;
234
235 switch (syscall)
236 {
237 case gdb_sys_restart_syscall:
238 break;
239
240 case gdb_sys_exit:
241 {
242 int q;
243 target_terminal_ours ();
244 q = yquery (_("The next instruction is syscall exit. "
245 "It will make the program exit. "
246 "Do you want to stop the program?"));
247 target_terminal_inferior ();
248 if (q)
249 return 1;
250 }
251 break;
252
253 case gdb_sys_fork:
254 break;
255
256 case gdb_sys_read:
257 {
258 ULONGEST addr, count;
259 regcache_raw_read_unsigned (regcache, tdep->arg2, &addr);
260 regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
261 if (record_arch_list_add_mem ((CORE_ADDR) addr, (int) count))
262 return -1;
263 }
264 break;
265
266 case gdb_sys_write:
267 case gdb_sys_open:
268 case gdb_sys_close:
269 case gdb_sys_waitpid:
270 case gdb_sys_creat:
271 case gdb_sys_link:
272 case gdb_sys_unlink:
273 case gdb_sys_execve:
274 case gdb_sys_chdir:
275 case gdb_sys_time:
276 case gdb_sys_mknod:
277 case gdb_sys_chmod:
278 case gdb_sys_lchown16:
279 case gdb_sys_ni_syscall17:
280 break;
281
282 case gdb_sys_stat:
283 case gdb_sys_fstat:
284 case gdb_sys_lstat:
285 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
286 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
287 tdep->size__old_kernel_stat))
288 return -1;
289 break;
290
291 case gdb_sys_lseek:
292 case gdb_sys_getpid:
293 case gdb_sys_mount:
294 case gdb_sys_oldumount:
295 case gdb_sys_setuid16:
296 case gdb_sys_getuid16:
297 case gdb_sys_stime:
298 break;
299
300 case gdb_sys_ptrace:
301 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
302 if (tmpulongest == RECORD_PTRACE_PEEKTEXT
303 || tmpulongest == RECORD_PTRACE_PEEKDATA
304 || tmpulongest == RECORD_PTRACE_PEEKUSR)
305 {
306 regcache_raw_read_unsigned (regcache, tdep->arg4,
307 &tmpulongest);
308 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 4))
309 return -1;
310 }
311 break;
312
313 case gdb_sys_alarm:
314 case gdb_sys_pause:
315 case gdb_sys_utime:
316 case gdb_sys_ni_syscall31:
317 case gdb_sys_ni_syscall32:
318 case gdb_sys_access:
319 case gdb_sys_nice:
320 case gdb_sys_ni_syscall35:
321 case gdb_sys_sync:
322 case gdb_sys_kill:
323 case gdb_sys_rename:
324 case gdb_sys_mkdir:
325 case gdb_sys_rmdir:
326 case gdb_sys_dup:
327 case gdb_sys_pipe:
328 break;
329
330 case gdb_sys_times:
331 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
332 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_tms))
333 return -1;
334 break;
335
336 case gdb_sys_ni_syscall44:
337 case gdb_sys_brk:
338 case gdb_sys_setgid16:
339 case gdb_sys_getgid16:
340 case gdb_sys_signal:
341 case gdb_sys_geteuid16:
342 case gdb_sys_getegid16:
343 case gdb_sys_acct:
344 case gdb_sys_umount:
345 case gdb_sys_ni_syscall53:
346 break;
347
348 case gdb_sys_ioctl:
349 /* XXX Need to add a lot of support of other ioctl requests. */
350 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
351 if (tmpulongest == tdep->ioctl_FIOCLEX
352 || tmpulongest == tdep->ioctl_FIONCLEX
353 || tmpulongest == tdep->ioctl_FIONBIO
354 || tmpulongest == tdep->ioctl_FIOASYNC
355 || tmpulongest == tdep->ioctl_TCSETS
356 || tmpulongest == tdep->ioctl_TCSETSW
357 || tmpulongest == tdep->ioctl_TCSETSF
358 || tmpulongest == tdep->ioctl_TCSETA
359 || tmpulongest == tdep->ioctl_TCSETAW
360 || tmpulongest == tdep->ioctl_TCSETAF
361 || tmpulongest == tdep->ioctl_TCSBRK
362 || tmpulongest == tdep->ioctl_TCXONC
363 || tmpulongest == tdep->ioctl_TCFLSH
364 || tmpulongest == tdep->ioctl_TIOCEXCL
365 || tmpulongest == tdep->ioctl_TIOCNXCL
366 || tmpulongest == tdep->ioctl_TIOCSCTTY
367 || tmpulongest == tdep->ioctl_TIOCSPGRP
368 || tmpulongest == tdep->ioctl_TIOCSTI
369 || tmpulongest == tdep->ioctl_TIOCSWINSZ
370 || tmpulongest == tdep->ioctl_TIOCMBIS
371 || tmpulongest == tdep->ioctl_TIOCMBIC
372 || tmpulongest == tdep->ioctl_TIOCMSET
373 || tmpulongest == tdep->ioctl_TIOCSSOFTCAR
374 || tmpulongest == tdep->ioctl_TIOCCONS
375 || tmpulongest == tdep->ioctl_TIOCSSERIAL
376 || tmpulongest == tdep->ioctl_TIOCPKT
377 || tmpulongest == tdep->ioctl_TIOCNOTTY
378 || tmpulongest == tdep->ioctl_TIOCSETD
379 || tmpulongest == tdep->ioctl_TCSBRKP
380 || tmpulongest == tdep->ioctl_TIOCTTYGSTRUCT
381 || tmpulongest == tdep->ioctl_TIOCSBRK
382 || tmpulongest == tdep->ioctl_TIOCCBRK
383 || tmpulongest == tdep->ioctl_TCSETS2
384 || tmpulongest == tdep->ioctl_TCSETSW2
385 || tmpulongest == tdep->ioctl_TCSETSF2
386 || tmpulongest == tdep->ioctl_TIOCSPTLCK
387 || tmpulongest == tdep->ioctl_TIOCSERCONFIG
388 || tmpulongest == tdep->ioctl_TIOCSERGWILD
389 || tmpulongest == tdep->ioctl_TIOCSERSWILD
390 || tmpulongest == tdep->ioctl_TIOCSLCKTRMIOS
391 || tmpulongest == tdep->ioctl_TIOCSERGETMULTI
392 || tmpulongest == tdep->ioctl_TIOCSERSETMULTI
393 || tmpulongest == tdep->ioctl_TIOCMIWAIT
394 || tmpulongest == tdep->ioctl_TIOCSHAYESESP)
395 {
396 /* Nothing to do. */
397 }
398 else if (tmpulongest == tdep->ioctl_TCGETS
399 || tmpulongest == tdep->ioctl_TCGETA
400 || tmpulongest == tdep->ioctl_TIOCGLCKTRMIOS)
401 {
402 regcache_raw_read_unsigned (regcache, tdep->arg3,
403 &tmpulongest);
404 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
405 tdep->size_termios))
406 return -1;
407 }
408 else if (tmpulongest == tdep->ioctl_TIOCGPGRP
409 || tmpulongest == tdep->ioctl_TIOCGSID)
410 {
411 regcache_raw_read_unsigned (regcache, tdep->arg3,
412 &tmpulongest);
413 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
414 tdep->size_pid_t))
415 return -1;
416 }
417 else if (tmpulongest == tdep->ioctl_TIOCOUTQ
418 || tmpulongest == tdep->ioctl_TIOCMGET
419 || tmpulongest == tdep->ioctl_TIOCGSOFTCAR
420 || tmpulongest == tdep->ioctl_FIONREAD
421 || tmpulongest == tdep->ioctl_TIOCINQ
422 || tmpulongest == tdep->ioctl_TIOCGETD
423 || tmpulongest == tdep->ioctl_TIOCGPTN
424 || tmpulongest == tdep->ioctl_TIOCSERGETLSR)
425 {
426 regcache_raw_read_unsigned (regcache, tdep->arg3,
427 &tmpulongest);
428 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
429 tdep->size_int))
430 return -1;
431 }
432 else if (tmpulongest == tdep->ioctl_TIOCGWINSZ)
433 {
434 regcache_raw_read_unsigned (regcache, tdep->arg3,
435 &tmpulongest);
436 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
437 tdep->size_winsize))
438 return -1;
439 }
440 else if (tmpulongest == tdep->ioctl_TIOCLINUX)
441 {
442 regcache_raw_read_unsigned (regcache, tdep->arg3,
443 &tmpulongest);
444 /* This syscall affects a char-size memory. */
445 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1))
446 return -1;
447 }
448 else if (tmpulongest == tdep->ioctl_TIOCGSERIAL)
449 {
450 regcache_raw_read_unsigned (regcache, tdep->arg3,
451 &tmpulongest);
452 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
453 tdep->size_serial_struct))
454 return -1;
455 }
456 else if (tmpulongest == tdep->ioctl_TCGETS2)
457 {
458 regcache_raw_read_unsigned (regcache, tdep->arg3,
459 &tmpulongest);
460 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
461 tdep->size_termios2))
462 return -1;
463 }
464 else if (tmpulongest == tdep->ioctl_FIOQSIZE)
465 {
466 regcache_raw_read_unsigned (regcache, tdep->arg3,
467 &tmpulongest);
468 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
469 tdep->size_loff_t))
470 return -1;
471 }
472 else if (tmpulongest == tdep->ioctl_TIOCGICOUNT)
473 {
474 regcache_raw_read_unsigned (regcache, tdep->arg3,
475 &tmpulongest);
476 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
477 tdep->size_serial_icounter_struct))
478 return -1;
479 }
480 else if (tmpulongest == tdep->ioctl_TIOCGHAYESESP)
481 {
482 regcache_raw_read_unsigned (regcache, tdep->arg3,
483 &tmpulongest);
484 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
485 tdep->size_hayes_esp_config))
486 return -1;
487 }
488 else if (tmpulongest == tdep->ioctl_TIOCSERGSTRUCT)
489 {
490 printf_unfiltered (_("Process record and replay target doesn't "
491 "support ioctl request TIOCSERGSTRUCT\n"));
492 return 1;
493 }
494 else
495 {
496 printf_unfiltered (_("Process record and replay target doesn't "
497 "support ioctl request 0x%s.\n"),
498 OUTPUT_REG (tmpulongest, tdep->arg2));
499 return 1;
500 }
501 break;
502
503 case gdb_sys_fcntl:
504 /* XXX */
505 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
506 sys_fcntl:
507 if (tmpulongest == tdep->fcntl_F_GETLK)
508 {
509 regcache_raw_read_unsigned (regcache, tdep->arg3,
510 &tmpulongest);
511 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
512 tdep->size_flock))
513 return -1;
514 }
515 break;
516
517 case gdb_sys_ni_syscall56:
518 case gdb_sys_setpgid:
519 case gdb_sys_ni_syscall58:
520 break;
521
522 case gdb_sys_olduname:
523 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
524 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
525 tdep->size_oldold_utsname))
526 return -1;
527 break;
528
529 case gdb_sys_umask:
530 case gdb_sys_chroot:
531 break;
532
533 case gdb_sys_ustat:
534 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
535 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
536 tdep->size_ustat))
537 return -1;
538 break;
539
540 case gdb_sys_dup2:
541 case gdb_sys_getppid:
542 case gdb_sys_getpgrp:
543 case gdb_sys_setsid:
544 break;
545
546 case gdb_sys_sigaction:
547 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
548 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
549 tdep->size_old_sigaction))
550 return -1;
551 break;
552
553 case gdb_sys_sgetmask:
554 case gdb_sys_ssetmask:
555 case gdb_sys_setreuid16:
556 case gdb_sys_setregid16:
557 case gdb_sys_sigsuspend:
558 break;
559
560 case gdb_sys_sigpending:
561 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
562 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
563 tdep->size_old_sigset_t))
564 return -1;
565 break;
566
567 case gdb_sys_sethostname:
568 case gdb_sys_setrlimit:
569 break;
570
571 case gdb_sys_old_getrlimit:
572 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
573 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
574 tdep->size_rlimit))
575 return -1;
576 break;
577
578 case gdb_sys_getrusage:
579 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
580 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
581 tdep->size_rusage))
582 return -1;
583 break;
584
585 case gdb_sys_gettimeofday:
586 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
587 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
588 tdep->size_timeval))
589 return -1;
590 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
591 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
592 tdep->size_timezone))
593 return -1;
594 break;
595
596 case gdb_sys_settimeofday:
597 break;
598
599 case gdb_sys_getgroups16:
600 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
601 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
602 tdep->size_old_gid_t))
603 return -1;
604 break;
605
606 case gdb_sys_setgroups16:
607 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
608 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
609 tdep->size_old_gid_t))
610 return -1;
611 break;
612
613 case gdb_old_select:
614 {
615 struct sel_arg_struct
616 {
617 CORE_ADDR n;
618 CORE_ADDR inp;
619 CORE_ADDR outp;
620 CORE_ADDR exp;
621 CORE_ADDR tvp;
622 } sel;
623
624 regcache_raw_read_unsigned (regcache, tdep->arg1,
625 &tmpulongest);
626 if (tmpulongest)
627 {
628 if (target_read_memory (tmpulongest, (gdb_byte *) &sel,
629 sizeof(sel)))
630 {
631 if (record_debug)
632 fprintf_unfiltered (gdb_stdlog,
633 "Process record: error reading memory "
634 "at addr = 0x%s len = %lu.\n",
635 OUTPUT_REG (tmpulongest, tdep->arg1),
636 (unsigned long) sizeof (sel));
637 return -1;
638 }
639 if (record_arch_list_add_mem (sel.inp, tdep->size_fd_set))
640 return -1;
641 if (record_arch_list_add_mem (sel.outp, tdep->size_fd_set))
642 return -1;
643 if (record_arch_list_add_mem (sel.exp, tdep->size_fd_set))
644 return -1;
645 if (record_arch_list_add_mem (sel.tvp, tdep->size_timeval))
646 return -1;
647 }
648 }
649 break;
650
651 case gdb_sys_symlink:
652 break;
653
654 case gdb_sys_readlink:
655 {
656 ULONGEST len;
657 regcache_raw_read_unsigned (regcache, tdep->arg2,
658 &tmpulongest);
659 regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
660 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) len))
661 return -1;
662 }
663 break;
664
665 case gdb_sys_uselib:
666 case gdb_sys_swapon:
667 break;
668
669 case gdb_sys_reboot:
670 {
671 int q;
672 target_terminal_ours ();
673 q =
674 yquery (_("The next instruction is syscall reboot. "
675 "It will restart the computer. "
676 "Do you want to stop the program?"));
677 target_terminal_inferior ();
678 if (q)
679 return 1;
680 }
681 break;
682
683 case gdb_old_readdir:
684 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
685 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
686 tdep->size_dirent))
687 return -1;
688 break;
689
690 case gdb_old_mmap:
691 break;
692
693 case gdb_sys_munmap:
694 {
695 int q;
696 ULONGEST len;
697
698 regcache_raw_read_unsigned (regcache, tdep->arg1,
699 &tmpulongest);
700 regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
701 target_terminal_ours ();
702 q = yquery (_("The next instruction is syscall munmap. "
703 "It will free the memory addr = 0x%s len = %u. "
704 "It will make record target get error. "
705 "Do you want to stop the program?"),
706 OUTPUT_REG (tmpulongest, tdep->arg1), (int) len);
707 target_terminal_inferior ();
708 if (q)
709 return 1;
710 }
711 break;
712
713 case gdb_sys_truncate:
714 case gdb_sys_ftruncate:
715 case gdb_sys_fchmod:
716 case gdb_sys_fchown16:
717 case gdb_sys_getpriority:
718 case gdb_sys_setpriority:
719 case gdb_sys_ni_syscall98:
720 break;
721
722 case gdb_sys_statfs:
723 case gdb_sys_fstatfs:
724 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
725 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
726 tdep->size_statfs))
727 return -1;
728 break;
729
730 case gdb_sys_ioperm:
731 break;
732
733 case gdb_sys_socket:
734 case gdb_sys_sendto:
735 case gdb_sys_sendmsg:
736 case gdb_sys_shutdown:
737 case gdb_sys_bind:
738 case gdb_sys_connect:
739 case gdb_sys_listen:
740 case gdb_sys_setsockopt:
741 break;
742
743 case gdb_sys_accept:
744 case gdb_sys_getsockname:
745 case gdb_sys_getpeername:
746 {
747 ULONGEST len;
748 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
749 regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
750 if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
751 return -1;
752 }
753 break;
754
755 case gdb_sys_recvfrom:
756 {
757 ULONGEST len;
758 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
759 regcache_raw_read_unsigned (regcache, tdep->arg5, &len);
760 if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
761 return -1;
762 }
763 case gdb_sys_recv:
764 {
765 ULONGEST size;
766 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
767 regcache_raw_read_unsigned (regcache, tdep->arg3, &size);
768 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size))
769 return -1;
770 }
771 break;
772
773 case gdb_sys_recvmsg:
774 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
775 if (record_linux_msghdr (regcache, tdep, tmpulongest))
776 return -1;
777 break;
778
779 case gdb_sys_socketpair:
780 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
781 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
782 return -1;
783 break;
784
785 case gdb_sys_getsockopt:
786 regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
787 if (tmpulongest)
788 {
789 ULONGEST optvalp;
790 gdb_byte *optlenp = alloca (tdep->size_int);
791 if (target_read_memory ((CORE_ADDR) tmpulongest, optlenp,
792 tdep->size_int))
793 {
794 if (record_debug)
795 fprintf_unfiltered (gdb_stdlog,
796 "Process record: error reading "
797 "memory at addr = 0x%s "
798 "len = %d.\n",
799 OUTPUT_REG (tmpulongest, tdep->arg5),
800 tdep->size_int);
801 return -1;
802 }
803 regcache_raw_read_unsigned (regcache, tdep->arg4, &optvalp);
804 tmpint = (int) extract_signed_integer (optlenp, tdep->size_int,
805 byte_order);
806 if (record_arch_list_add_mem ((CORE_ADDR) optvalp, tmpint))
807 return -1;
808 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
809 tdep->size_int))
810 return -1;
811 }
812 break;
813
814 case gdb_sys_socketcall:
815 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
816 switch (tmpulongest)
817 {
818 case RECORD_SYS_SOCKET:
819 case RECORD_SYS_BIND:
820 case RECORD_SYS_CONNECT:
821 case RECORD_SYS_LISTEN:
822 break;
823 case RECORD_SYS_ACCEPT:
824 case RECORD_SYS_GETSOCKNAME:
825 case RECORD_SYS_GETPEERNAME:
826 {
827 regcache_raw_read_unsigned (regcache, tdep->arg2,
828 &tmpulongest);
829 if (tmpulongest)
830 {
831 gdb_byte *a = alloca (tdep->size_ulong * 2);
832 ULONGEST len;
833
834 tmpulongest += tdep->size_ulong;
835 if (target_read_memory ((CORE_ADDR) tmpulongest, a,
836 tdep->size_ulong * 2))
837 {
838 if (record_debug)
839 fprintf_unfiltered (gdb_stdlog,
840 "Process record: error reading "
841 "memory at addr = 0x%s len = %d.\n",
842 OUTPUT_REG (tmpulongest, tdep->arg2),
843 tdep->size_ulong * 2);
844 return -1;
845 }
846 tmpulongest = extract_unsigned_integer (a,
847 tdep->size_ulong,
848 byte_order);
849 len = extract_unsigned_integer (a + tdep->size_ulong,
850 tdep->size_ulong, byte_order);
851 if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
852 return -1;
853 }
854 }
855 break;
856
857 case RECORD_SYS_SOCKETPAIR:
858 {
859 gdb_byte *a = alloca (tdep->size_ulong);
860 regcache_raw_read_unsigned (regcache, tdep->arg2,
861 &tmpulongest);
862 if (tmpulongest)
863 {
864 tmpulongest += tdep->size_ulong * 3;
865 if (target_read_memory ((CORE_ADDR) tmpulongest, a,
866 tdep->size_ulong))
867 {
868 if (record_debug)
869 fprintf_unfiltered (gdb_stdlog,
870 "Process record: error reading "
871 "memory at addr = 0x%s len = %d.\n",
872 OUTPUT_REG (tmpulongest, tdep->arg2),
873 tdep->size_ulong);
874 return -1;
875 }
876 tmpaddr
877 = (CORE_ADDR) extract_unsigned_integer (a, tdep->size_ulong,
878 byte_order);
879 if (record_arch_list_add_mem (tmpaddr, tdep->size_int))
880 return -1;
881 }
882 }
883 break;
884 case RECORD_SYS_SEND:
885 case RECORD_SYS_SENDTO:
886 break;
887 case RECORD_SYS_RECVFROM:
888 regcache_raw_read_unsigned (regcache, tdep->arg2,
889 &tmpulongest);
890 if (tmpulongest)
891 {
892 gdb_byte *a = alloca (tdep->size_ulong * 2);
893 ULONGEST len;
894
895 tmpulongest += tdep->size_ulong * 4;
896 if (target_read_memory ((CORE_ADDR) tmpulongest, a,
897 tdep->size_ulong * 2))
898 {
899 if (record_debug)
900 fprintf_unfiltered (gdb_stdlog,
901 "Process record: error reading "
902 "memory at addr = 0x%s len = %d.\n",
903 OUTPUT_REG (tmpulongest, tdep->arg2),
904 tdep->size_ulong * 2);
905 return -1;
906 }
907 tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
908 byte_order);
909 len = extract_unsigned_integer (a + tdep->size_ulong,
910 tdep->size_ulong, byte_order);
911 if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
912 return -1;
913 }
914 case RECORD_SYS_RECV:
915 regcache_raw_read_unsigned (regcache, tdep->arg2,
916 &tmpulongest);
917 if (tmpulongest)
918 {
919 gdb_byte *a = alloca (tdep->size_ulong * 2);
920
921 tmpulongest += tdep->size_ulong;
922 if (target_read_memory ((CORE_ADDR) tmpulongest, a,
923 tdep->size_ulong))
924 {
925 if (record_debug)
926 fprintf_unfiltered (gdb_stdlog,
927 "Process record: error reading "
928 "memory at addr = 0x%s len = %d.\n",
929 OUTPUT_REG (tmpulongest, tdep->arg2),
930 tdep->size_ulong);
931 return -1;
932 }
933 tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
934 byte_order);
935 if (tmpulongest)
936 {
937 a += tdep->size_ulong;
938 tmpint = (int) extract_unsigned_integer (a, tdep->size_ulong,
939 byte_order);
940 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
941 tmpint))
942 return -1;
943 }
944 }
945 break;
946 case RECORD_SYS_SHUTDOWN:
947 case RECORD_SYS_SETSOCKOPT:
948 break;
949 case RECORD_SYS_GETSOCKOPT:
950 {
951 gdb_byte *a = alloca (tdep->size_ulong * 2);
952 gdb_byte *av = alloca (tdep->size_int);
953
954 regcache_raw_read_unsigned (regcache, tdep->arg2,
955 &tmpulongest);
956 if (tmpulongest)
957 {
958 tmpulongest += tdep->size_ulong * 3;
959 if (target_read_memory ((CORE_ADDR) tmpulongest, a,
960 tdep->size_ulong * 2))
961 {
962 if (record_debug)
963 fprintf_unfiltered (gdb_stdlog,
964 "Process record: error reading "
965 "memory at addr = 0x%s len = %d.\n",
966 OUTPUT_REG (tmpulongest, tdep->arg2),
967 tdep->size_ulong * 2);
968 return -1;
969 }
970 tmpulongest = extract_unsigned_integer (a + tdep->size_ulong,
971 tdep->size_ulong,
972 byte_order);
973 if (tmpulongest)
974 {
975 if (target_read_memory ((CORE_ADDR) tmpulongest, av,
976 tdep->size_int))
977 {
978 if (record_debug)
979 fprintf_unfiltered (gdb_stdlog,
980 "Process record: error reading "
981 "memory at addr = 0x%s "
982 "len = %d.\n",
983 phex_nz (tmpulongest,
984 tdep->size_ulong),
985 tdep->size_int);
986 return -1;
987 }
988 tmpaddr
989 = (CORE_ADDR) extract_unsigned_integer (a,
990 tdep->size_ulong,
991 byte_order);
992 tmpint = (int) extract_unsigned_integer (av,
993 tdep->size_int,
994 byte_order);
995 if (record_arch_list_add_mem (tmpaddr, tmpint))
996 return -1;
997 a += tdep->size_ulong;
998 tmpaddr
999 = (CORE_ADDR) extract_unsigned_integer (a,
1000 tdep->size_ulong,
1001 byte_order);
1002 if (record_arch_list_add_mem (tmpaddr, tdep->size_int))
1003 return -1;
1004 }
1005 }
1006 }
1007 break;
1008 case RECORD_SYS_SENDMSG:
1009 break;
1010 case RECORD_SYS_RECVMSG:
1011 {
1012 gdb_byte *a = alloca (tdep->size_ulong);
1013
1014 regcache_raw_read_unsigned (regcache, tdep->arg2,
1015 &tmpulongest);
1016 if (tmpulongest)
1017 {
1018 tmpulongest += tdep->size_ulong;
1019 if (target_read_memory ((CORE_ADDR) tmpulongest, a,
1020 tdep->size_ulong))
1021 {
1022 if (record_debug)
1023 fprintf_unfiltered (gdb_stdlog,
1024 "Process record: error reading "
1025 "memory at addr = 0x%s len = %d.\n",
1026 OUTPUT_REG (tmpulongest, tdep->arg2),
1027 tdep->size_ulong);
1028 return -1;
1029 }
1030 tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
1031 byte_order);
1032 if (record_linux_msghdr (regcache, tdep, tmpulongest))
1033 return -1;
1034 }
1035 }
1036 break;
1037 default:
1038 printf_unfiltered (_("Process record and replay target "
1039 "doesn't support socketcall call 0x%s\n"),
1040 OUTPUT_REG (tmpulongest, tdep->arg1));
1041 return -1;
1042 break;
1043 }
1044 break;
1045
1046 case gdb_sys_syslog:
1047 break;
1048
1049 case gdb_sys_setitimer:
1050 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1051 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1052 tdep->size_itimerval))
1053 return -1;
1054 break;
1055
1056 case gdb_sys_getitimer:
1057 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1058 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1059 tdep->size_itimerval))
1060 return -1;
1061 break;
1062
1063 case gdb_sys_newstat:
1064 case gdb_sys_newlstat:
1065 case gdb_sys_newfstat:
1066 case gdb_sys_newfstatat:
1067 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1068 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_stat))
1069 return -1;
1070 break;
1071
1072 case gdb_sys_uname:
1073 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1074 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1075 tdep->size_old_utsname))
1076 return -1;
1077 break;
1078
1079 case gdb_sys_iopl:
1080 case gdb_sys_vhangup:
1081 case gdb_sys_ni_syscall112:
1082 case gdb_sys_vm86old:
1083 break;
1084
1085 case gdb_sys_wait4:
1086 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1087 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1088 tdep->size_int))
1089 return -1;
1090 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1091 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1092 tdep->size_rusage))
1093 return -1;
1094 break;
1095
1096 case gdb_sys_swapoff:
1097 break;
1098
1099 case gdb_sys_sysinfo:
1100 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1101 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1102 tdep->size_sysinfo))
1103 return -1;
1104 break;
1105
1106 case gdb_sys_shmget:
1107 case gdb_sys_semget:
1108 case gdb_sys_semop:
1109 case gdb_sys_msgget:
1110 /* XXX maybe need do some record works with sys_shmdt. */
1111 case gdb_sys_shmdt:
1112 case gdb_sys_msgsnd:
1113 case gdb_sys_semtimedop:
1114 break;
1115
1116 case gdb_sys_shmat:
1117 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1118 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1119 tdep->size_ulong))
1120 return -1;
1121 break;
1122
1123 case gdb_sys_shmctl:
1124 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1125 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1126 tdep->size_shmid_ds))
1127 return -1;
1128 break;
1129
1130 /* XXX sys_semctl 525 still not supported. */
1131 /* sys_semctl */
1132
1133 case gdb_sys_msgrcv:
1134 {
1135 ULONGEST msgp;
1136 regcache_raw_read_signed (regcache, tdep->arg3, &tmpulongest);
1137 regcache_raw_read_unsigned (regcache, tdep->arg2, &msgp);
1138 tmpint = (int) tmpulongest + tdep->size_long;
1139 if (record_arch_list_add_mem ((CORE_ADDR) msgp, tmpint))
1140 return -1;
1141 }
1142 break;
1143
1144 case gdb_sys_msgctl:
1145 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1146 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1147 tdep->size_msqid_ds))
1148 return -1;
1149 break;
1150
1151 case gdb_sys_ipc:
1152 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1153 tmpulongest &= 0xffff;
1154 switch (tmpulongest)
1155 {
1156 case RECORD_SEMOP:
1157 case RECORD_SEMGET:
1158 case RECORD_SEMTIMEDOP:
1159 case RECORD_MSGSND:
1160 case RECORD_MSGGET:
1161 /* XXX maybe need do some record works with RECORD_SHMDT. */
1162 case RECORD_SHMDT:
1163 case RECORD_SHMGET:
1164 break;
1165 case RECORD_MSGRCV:
1166 {
1167 ULONGEST second;
1168 ULONGEST ptr;
1169 regcache_raw_read_signed (regcache, tdep->arg3, &second);
1170 regcache_raw_read_unsigned (regcache, tdep->arg5, &ptr);
1171 tmpint = (int) second + tdep->size_long;
1172 if (record_arch_list_add_mem ((CORE_ADDR) ptr, tmpint))
1173 return -1;
1174 }
1175 break;
1176 case RECORD_MSGCTL:
1177 regcache_raw_read_unsigned (regcache, tdep->arg5,
1178 &tmpulongest);
1179 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1180 tdep->size_msqid_ds))
1181 return -1;
1182 break;
1183 case RECORD_SHMAT:
1184 regcache_raw_read_unsigned (regcache, tdep->arg4,
1185 &tmpulongest);
1186 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1187 tdep->size_ulong))
1188 return -1;
1189 break;
1190 case RECORD_SHMCTL:
1191 regcache_raw_read_unsigned (regcache, tdep->arg5,
1192 &tmpulongest);
1193 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1194 tdep->size_shmid_ds))
1195 return -1;
1196 break;
1197 default:
1198 /* XXX RECORD_SEMCTL still not supported. */
1199 printf_unfiltered (_("Process record and replay target doesn't "
1200 "support ipc number %s\n"),
1201 pulongest (tmpulongest));
1202 break;
1203 }
1204 break;
1205
1206 case gdb_sys_fsync:
1207 case gdb_sys_sigreturn:
1208 case gdb_sys_clone:
1209 case gdb_sys_setdomainname:
1210 break;
1211
1212 case gdb_sys_newuname:
1213 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1214 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1215 tdep->size_new_utsname))
1216 return -1;
1217 break;
1218
1219 case gdb_sys_modify_ldt:
1220 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1221 if (tmpulongest == 0 || tmpulongest == 2)
1222 {
1223 ULONGEST ptr, bytecount;
1224 regcache_raw_read_unsigned (regcache, tdep->arg2, &ptr);
1225 regcache_raw_read_unsigned (regcache, tdep->arg3, &bytecount);
1226 if (record_arch_list_add_mem ((CORE_ADDR) ptr, (int) bytecount))
1227 return -1;
1228 }
1229 break;
1230
1231 case gdb_sys_adjtimex:
1232 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1233 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_timex))
1234 return -1;
1235 break;
1236
1237 case gdb_sys_mprotect:
1238 break;
1239
1240 case gdb_sys_sigprocmask:
1241 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1242 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1243 tdep->size_old_sigset_t))
1244 return -1;
1245 break;
1246
1247 case gdb_sys_ni_syscall127:
1248 case gdb_sys_init_module:
1249 case gdb_sys_delete_module:
1250 case gdb_sys_ni_syscall130:
1251 break;
1252
1253 case gdb_sys_quotactl:
1254 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1255 switch (tmpulongest)
1256 {
1257 case RECORD_Q_GETFMT:
1258 regcache_raw_read_unsigned (regcache, tdep->arg4,
1259 &tmpulongest);
1260 /* __u32 */
1261 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 4))
1262 return -1;
1263 break;
1264 case RECORD_Q_GETINFO:
1265 regcache_raw_read_unsigned (regcache, tdep->arg4,
1266 &tmpulongest);
1267 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1268 tdep->size_mem_dqinfo))
1269 return -1;
1270 break;
1271 case RECORD_Q_GETQUOTA:
1272 regcache_raw_read_unsigned (regcache, tdep->arg4,
1273 &tmpulongest);
1274 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1275 tdep->size_if_dqblk))
1276 return -1;
1277 break;
1278 case RECORD_Q_XGETQSTAT:
1279 case RECORD_Q_XGETQUOTA:
1280 regcache_raw_read_unsigned (regcache, tdep->arg4,
1281 &tmpulongest);
1282 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1283 tdep->size_fs_quota_stat))
1284 return -1;
1285 break;
1286 }
1287 break;
1288
1289 case gdb_sys_getpgid:
1290 case gdb_sys_fchdir:
1291 case gdb_sys_bdflush:
1292 break;
1293
1294 case gdb_sys_sysfs:
1295 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1296 if (tmpulongest == 2)
1297 {
1298 regcache_raw_read_unsigned (regcache, tdep->arg3,
1299 &tmpulongest);
1300 /*XXX the size of memory is not very clear. */
1301 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 10))
1302 return -1;
1303 }
1304 break;
1305
1306 case gdb_sys_personality:
1307 case gdb_sys_ni_syscall137:
1308 case gdb_sys_setfsuid16:
1309 case gdb_sys_setfsgid16:
1310 break;
1311
1312 case gdb_sys_llseek:
1313 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1314 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1315 tdep->size_loff_t))
1316 return -1;
1317 break;
1318
1319 case gdb_sys_getdents:
1320 {
1321 ULONGEST count;
1322 regcache_raw_read_unsigned (regcache, tdep->arg2,
1323 &tmpulongest);
1324 regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
1325 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1326 tdep->size_dirent * count))
1327 return -1;
1328 }
1329 break;
1330
1331 case gdb_sys_select:
1332 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1333 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1334 tdep->size_fd_set))
1335 return -1;
1336 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1337 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1338 tdep->size_fd_set))
1339 return -1;
1340 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1341 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1342 tdep->size_fd_set))
1343 return -1;
1344 regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
1345 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1346 tdep->size_timeval))
1347 return -1;
1348 break;
1349
1350 case gdb_sys_flock:
1351 case gdb_sys_msync:
1352 break;
1353
1354 case gdb_sys_readv:
1355 {
1356 ULONGEST vec, vlen;
1357
1358 regcache_raw_read_unsigned (regcache, tdep->arg2, &vec);
1359 if (vec)
1360 {
1361 gdb_byte *iov = alloca (tdep->size_iovec);
1362
1363 regcache_raw_read_unsigned (regcache, tdep->arg3, &vlen);
1364 for (tmpulongest = 0; tmpulongest < vlen; tmpulongest++)
1365 {
1366 if (target_read_memory ((CORE_ADDR) vec, iov,
1367 tdep->size_iovec))
1368 {
1369 if (record_debug)
1370 fprintf_unfiltered (gdb_stdlog,
1371 "Process record: error reading "
1372 "memory at addr = 0x%s len = %d.\n",
1373 OUTPUT_REG (vec, tdep->arg2),
1374 tdep->size_iovec);
1375 return -1;
1376 }
1377 tmpaddr
1378 = (CORE_ADDR) extract_unsigned_integer (iov,
1379 tdep->size_pointer,
1380 byte_order);
1381 tmpint
1382 = (int) extract_unsigned_integer (iov + tdep->size_pointer,
1383 tdep->size_size_t,
1384 byte_order);
1385 if (record_arch_list_add_mem (tmpaddr, tmpint))
1386 return -1;
1387 vec += tdep->size_iovec;
1388 }
1389 }
1390 }
1391 break;
1392
1393 case gdb_sys_writev:
1394 case gdb_sys_getsid:
1395 case gdb_sys_fdatasync:
1396 case gdb_sys_sysctl:
1397 case gdb_sys_mlock:
1398 case gdb_sys_munlock:
1399 case gdb_sys_mlockall:
1400 case gdb_sys_munlockall:
1401 case gdb_sys_sched_setparam:
1402 break;
1403
1404 case gdb_sys_sched_getparam:
1405 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1406 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
1407 return -1;
1408 break;
1409
1410 case gdb_sys_sched_setscheduler:
1411 case gdb_sys_sched_getscheduler:
1412 case gdb_sys_sched_yield:
1413 case gdb_sys_sched_get_priority_max:
1414 case gdb_sys_sched_get_priority_min:
1415 break;
1416
1417 case gdb_sys_sched_rr_get_interval:
1418 case gdb_sys_nanosleep:
1419 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1420 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1421 tdep->size_timespec))
1422 return -1;
1423 break;
1424
1425 case gdb_sys_mremap:
1426 case gdb_sys_setresuid16:
1427 break;
1428
1429 case gdb_sys_getresuid16:
1430 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1431 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1432 tdep->size_old_uid_t))
1433 return -1;
1434 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1435 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1436 tdep->size_old_uid_t))
1437 return -1;
1438 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1439 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1440 tdep->size_old_uid_t))
1441 return -1;
1442 break;
1443
1444 case gdb_sys_vm86:
1445 case gdb_sys_ni_syscall167:
1446 break;
1447
1448 case gdb_sys_poll:
1449 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1450 if (tmpulongest)
1451 {
1452 ULONGEST nfds;
1453 regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
1454 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1455 tdep->size_pollfd * nfds))
1456 return -1;
1457 }
1458 break;
1459
1460 case gdb_sys_nfsservctl:
1461 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1462 if (tmpulongest == 7 || tmpulongest == 8)
1463 {
1464 int rsize;
1465 if (tmpulongest == 7)
1466 rsize = tdep->size_NFS_FHSIZE;
1467 else
1468 rsize = tdep->size_knfsd_fh;
1469 regcache_raw_read_unsigned (regcache, tdep->arg3,
1470 &tmpulongest);
1471 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, rsize))
1472 return -1;
1473 }
1474 break;
1475
1476 case gdb_sys_setresgid16:
1477 break;
1478
1479 case gdb_sys_getresgid16:
1480 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1481 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1482 tdep->size_old_gid_t))
1483 return -1;
1484 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1485 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1486 tdep->size_old_gid_t))
1487 return -1;
1488 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1489 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1490 tdep->size_old_gid_t))
1491 return -1;
1492 break;
1493
1494 case gdb_sys_prctl:
1495 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1496 switch (tmpulongest)
1497 {
1498 case 2:
1499 regcache_raw_read_unsigned (regcache, tdep->arg2,
1500 &tmpulongest);
1501 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1502 tdep->size_int))
1503 return -1;
1504 break;
1505 case 16:
1506 regcache_raw_read_unsigned (regcache, tdep->arg2,
1507 &tmpulongest);
1508 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1509 tdep->size_TASK_COMM_LEN))
1510 return -1;
1511 break;
1512 }
1513 break;
1514
1515 case gdb_sys_rt_sigreturn:
1516 break;
1517
1518 case gdb_sys_rt_sigaction:
1519 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1520 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1521 tdep->size_sigaction))
1522 return -1;
1523 break;
1524
1525 case gdb_sys_rt_sigprocmask:
1526 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1527 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1528 tdep->size_sigset_t))
1529 return -1;
1530 break;
1531
1532 case gdb_sys_rt_sigpending:
1533 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1534 if (tmpulongest)
1535 {
1536 ULONGEST sigsetsize;
1537 regcache_raw_read_unsigned (regcache, tdep->arg2,&sigsetsize);
1538 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1539 (int) sigsetsize))
1540 return -1;
1541 }
1542 break;
1543
1544 case gdb_sys_rt_sigtimedwait:
1545 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1546 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1547 tdep->size_siginfo_t))
1548 return -1;
1549 break;
1550
1551 case gdb_sys_rt_sigqueueinfo:
1552 case gdb_sys_rt_sigsuspend:
1553 break;
1554
1555 case gdb_sys_pread64:
1556 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1557 if (tmpulongest)
1558 {
1559 ULONGEST count;
1560 regcache_raw_read_unsigned (regcache, tdep->arg3,&count);
1561 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) count))
1562 return -1;
1563 }
1564 break;
1565
1566 case gdb_sys_pwrite64:
1567 case gdb_sys_chown16:
1568 break;
1569
1570 case gdb_sys_getcwd:
1571 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1572 if (tmpulongest)
1573 {
1574 ULONGEST size;
1575 regcache_raw_read_unsigned (regcache, tdep->arg2, &size);
1576 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size))
1577 return -1;
1578 }
1579 break;
1580
1581 case gdb_sys_capget:
1582 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1583 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1584 tdep->size_cap_user_data_t))
1585 return -1;
1586 break;
1587
1588 case gdb_sys_capset:
1589 break;
1590
1591 case gdb_sys_sigaltstack:
1592 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1593 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1594 tdep->size_stack_t))
1595 return -1;
1596 break;
1597
1598 case gdb_sys_sendfile:
1599 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1600 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1601 tdep->size_off_t))
1602 return -1;
1603 break;
1604
1605 case gdb_sys_ni_syscall188:
1606 case gdb_sys_ni_syscall189:
1607 case gdb_sys_vfork:
1608 break;
1609
1610 case gdb_sys_getrlimit:
1611 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1612 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1613 tdep->size_rlimit))
1614 return -1;
1615 break;
1616
1617 case gdb_sys_mmap2:
1618 break;
1619
1620 case gdb_sys_truncate64:
1621 case gdb_sys_ftruncate64:
1622 break;
1623
1624 case gdb_sys_stat64:
1625 case gdb_sys_lstat64:
1626 case gdb_sys_fstat64:
1627 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1628 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1629 tdep->size_stat64))
1630 return -1;
1631 break;
1632
1633 case gdb_sys_lchown:
1634 case gdb_sys_getuid:
1635 case gdb_sys_getgid:
1636 case gdb_sys_geteuid:
1637 case gdb_sys_getegid:
1638 case gdb_sys_setreuid:
1639 case gdb_sys_setregid:
1640 break;
1641
1642 case gdb_sys_getgroups:
1643 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1644 if (tmpulongest)
1645 {
1646 ULONGEST gidsetsize;
1647 regcache_raw_read_unsigned (regcache, tdep->arg1,
1648 &gidsetsize);
1649 tmpint = tdep->size_gid_t * (int) gidsetsize;
1650 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
1651 return -1;
1652 }
1653 break;
1654
1655 case gdb_sys_setgroups:
1656 case gdb_sys_fchown:
1657 case gdb_sys_setresuid:
1658 break;
1659
1660 case gdb_sys_getresuid:
1661 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1662 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_uid_t))
1663 return -1;
1664 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1665 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_uid_t))
1666 return -1;
1667 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1668 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_uid_t))
1669 return -1;
1670 break;
1671
1672 case gdb_sys_setresgid:
1673 break;
1674
1675 case gdb_sys_getresgid:
1676 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1677 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_gid_t))
1678 return -1;
1679 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1680 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_gid_t))
1681 return -1;
1682 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1683 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_gid_t))
1684 return -1;
1685 break;
1686
1687 case gdb_sys_chown:
1688 case gdb_sys_setuid:
1689 case gdb_sys_setgid:
1690 case gdb_sys_setfsuid:
1691 case gdb_sys_setfsgid:
1692 case gdb_sys_pivot_root:
1693 break;
1694
1695 case gdb_sys_mincore:
1696 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1697 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1698 tdep->size_PAGE_SIZE))
1699 return -1;
1700 break;
1701
1702 case gdb_sys_madvise:
1703 break;
1704
1705 case gdb_sys_getdents64:
1706 {
1707 ULONGEST count;
1708 regcache_raw_read_unsigned (regcache, tdep->arg2,
1709 &tmpulongest);
1710 regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
1711 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1712 tdep->size_dirent64 * count))
1713 return -1;
1714 }
1715 break;
1716
1717 case gdb_sys_fcntl64:
1718 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1719 if (tmpulongest == tdep->fcntl_F_GETLK64)
1720 {
1721 regcache_raw_read_unsigned (regcache, tdep->arg3,
1722 &tmpulongest);
1723 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1724 tdep->size_flock64))
1725 return -1;
1726 }
1727 else if (tmpulongest != tdep->fcntl_F_SETLK64
1728 && tmpulongest != tdep->fcntl_F_SETLKW64)
1729 {
1730 goto sys_fcntl;
1731 }
1732 break;
1733
1734 case gdb_sys_ni_syscall222:
1735 case gdb_sys_ni_syscall223:
1736 case gdb_sys_gettid:
1737 case gdb_sys_readahead:
1738 case gdb_sys_setxattr:
1739 case gdb_sys_lsetxattr:
1740 case gdb_sys_fsetxattr:
1741 break;
1742
1743 case gdb_sys_getxattr:
1744 case gdb_sys_lgetxattr:
1745 case gdb_sys_fgetxattr:
1746 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1747 if (tmpulongest)
1748 {
1749 ULONGEST size;
1750 regcache_raw_read_unsigned (regcache, tdep->arg4, &size);
1751 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size))
1752 return -1;
1753 }
1754 break;
1755
1756 case gdb_sys_listxattr:
1757 case gdb_sys_llistxattr:
1758 case gdb_sys_flistxattr:
1759 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1760 if (tmpulongest)
1761 {
1762 ULONGEST size;
1763 regcache_raw_read_unsigned (regcache, tdep->arg3, &size);
1764 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size))
1765 return -1;
1766 }
1767 break;
1768
1769 case gdb_sys_removexattr:
1770 case gdb_sys_lremovexattr:
1771 case gdb_sys_fremovexattr:
1772 case gdb_sys_tkill:
1773 break;
1774
1775 case gdb_sys_sendfile64:
1776 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1777 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1778 tdep->size_loff_t))
1779 return -1;
1780 break;
1781
1782 case gdb_sys_futex:
1783 case gdb_sys_sched_setaffinity:
1784 break;
1785
1786 case gdb_sys_sched_getaffinity:
1787 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1788 if (tmpulongest)
1789 {
1790 ULONGEST len;
1791 regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
1792 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) len))
1793 return -1;
1794 }
1795 break;
1796
1797 case gdb_sys_set_thread_area:
1798 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1799 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
1800 return -1;
1801 break;
1802
1803 case gdb_sys_get_thread_area:
1804 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1805 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1806 tdep->size_user_desc))
1807 return -1;
1808 break;
1809
1810 case gdb_sys_io_setup:
1811 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1812 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_long))
1813 return -1;
1814 break;
1815
1816 case gdb_sys_io_destroy:
1817 break;
1818
1819 case gdb_sys_io_getevents:
1820 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1821 if (tmpulongest)
1822 {
1823 ULONGEST nr;
1824 regcache_raw_read_unsigned (regcache, tdep->arg3, &nr);
1825 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1826 nr * tdep->size_io_event))
1827 return -1;
1828 }
1829 break;
1830
1831 case gdb_sys_io_submit:
1832 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1833 if (tmpulongest)
1834 {
1835 ULONGEST nr, i;
1836 gdb_byte *iocbp;
1837
1838 regcache_raw_read_unsigned (regcache, tdep->arg2, &nr);
1839 iocbp = alloca (nr * tdep->size_pointer);
1840 if (target_read_memory ((CORE_ADDR) tmpulongest, iocbp,
1841 nr * tdep->size_pointer))
1842 {
1843 if (record_debug)
1844 fprintf_unfiltered (gdb_stdlog,
1845 "Process record: error reading memory "
1846 "at addr = 0x%s len = %u.\n",
1847 OUTPUT_REG (tmpulongest, tdep->arg2),
1848 (int) (nr * tdep->size_pointer));
1849 return -1;
1850 }
1851 for (i = 0; i < nr; i++)
1852 {
1853 tmpaddr
1854 = (CORE_ADDR) extract_unsigned_integer (iocbp,
1855 tdep->size_pointer,
1856 byte_order);
1857 if (record_arch_list_add_mem (tmpaddr, tdep->size_iocb))
1858 return -1;
1859 iocbp += tdep->size_pointer;
1860 }
1861 }
1862 break;
1863
1864 case gdb_sys_io_cancel:
1865 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1866 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1867 tdep->size_io_event))
1868 return -1;
1869 break;
1870
1871 case gdb_sys_fadvise64:
1872 case gdb_sys_ni_syscall251:
1873 break;
1874
1875 case gdb_sys_exit_group:
1876 {
1877 int q;
1878 target_terminal_ours ();
1879 q = yquery (_("The next instruction is syscall exit_group. "
1880 "It will make the program exit. "
1881 "Do you want to stop the program?"));
1882 target_terminal_inferior ();
1883 if (q)
1884 return 1;
1885 }
1886 break;
1887
1888 case gdb_sys_lookup_dcookie:
1889 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1890 if (tmpulongest)
1891 {
1892 ULONGEST len;
1893 regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
1894 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) len))
1895 return -1;
1896 }
1897 break;
1898
1899 case gdb_sys_epoll_create:
1900 case gdb_sys_epoll_ctl:
1901 break;
1902
1903 case gdb_sys_epoll_wait:
1904 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1905 if (tmpulongest)
1906 {
1907 ULONGEST maxevents;
1908 regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
1909 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1910 maxevents * tdep->size_epoll_event))
1911 return -1;
1912 }
1913 break;
1914
1915 case gdb_sys_remap_file_pages:
1916 case gdb_sys_set_tid_address:
1917 break;
1918
1919 case gdb_sys_timer_create:
1920 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1921 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
1922 return -1;
1923 break;
1924
1925 case gdb_sys_timer_settime:
1926 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1927 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1928 tdep->size_itimerspec))
1929 return -1;
1930 break;
1931
1932 case gdb_sys_timer_gettime:
1933 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1934 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1935 tdep->size_itimerspec))
1936 return -1;
1937 break;
1938
1939 case gdb_sys_timer_getoverrun:
1940 case gdb_sys_timer_delete:
1941 case gdb_sys_clock_settime:
1942 break;
1943
1944 case gdb_sys_clock_gettime:
1945 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1946 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1947 tdep->size_timespec))
1948 return -1;
1949 break;
1950
1951 case gdb_sys_clock_getres:
1952 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1953 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1954 tdep->size_timespec))
1955 return -1;
1956 break;
1957
1958 case gdb_sys_clock_nanosleep:
1959 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1960 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1961 tdep->size_timespec))
1962 return -1;
1963 break;
1964
1965 case gdb_sys_statfs64:
1966 case gdb_sys_fstatfs64:
1967 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1968 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1969 tdep->size_statfs64))
1970 return -1;
1971 break;
1972
1973 case gdb_sys_tgkill:
1974 case gdb_sys_utimes:
1975 case gdb_sys_fadvise64_64:
1976 case gdb_sys_ni_syscall273:
1977 case gdb_sys_mbind:
1978 break;
1979
1980 case gdb_sys_get_mempolicy:
1981 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1982 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
1983 return -1;
1984 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1985 if (tmpulongest)
1986 {
1987 ULONGEST maxnode;
1988 regcache_raw_read_unsigned (regcache, tdep->arg3, &maxnode);
1989 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1990 maxnode * tdep->size_long))
1991 return -1;
1992 }
1993 break;
1994
1995 case gdb_sys_set_mempolicy:
1996 case gdb_sys_mq_open:
1997 case gdb_sys_mq_unlink:
1998 case gdb_sys_mq_timedsend:
1999 break;
2000
2001 case gdb_sys_mq_timedreceive:
2002 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2003 if (tmpulongest)
2004 {
2005 ULONGEST msg_len;
2006 regcache_raw_read_unsigned (regcache, tdep->arg3, &msg_len);
2007 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2008 (int) msg_len))
2009 return -1;
2010 }
2011 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
2012 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
2013 return -1;
2014 break;
2015
2016 case gdb_sys_mq_notify:
2017 break;
2018
2019 case gdb_sys_mq_getsetattr:
2020 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2021 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2022 tdep->size_mq_attr))
2023 return -1;
2024 break;
2025
2026 case gdb_sys_kexec_load:
2027 break;
2028
2029 case gdb_sys_waitid:
2030 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2031 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2032 tdep->size_siginfo))
2033 return -1;
2034 regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
2035 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2036 tdep->size_rusage))
2037 return -1;
2038 break;
2039
2040 case gdb_sys_ni_syscall285:
2041 case gdb_sys_add_key:
2042 case gdb_sys_request_key:
2043 break;
2044
2045 case gdb_sys_keyctl:
2046 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
2047 if (tmpulongest == 6 || tmpulongest == 11)
2048 {
2049 regcache_raw_read_unsigned (regcache, tdep->arg3,
2050 &tmpulongest);
2051 if (tmpulongest)
2052 {
2053 ULONGEST buflen;
2054 regcache_raw_read_unsigned (regcache, tdep->arg4, &buflen);
2055 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2056 (int) buflen))
2057 return -1;
2058 }
2059 }
2060 break;
2061
2062 case gdb_sys_ioprio_set:
2063 case gdb_sys_ioprio_get:
2064 case gdb_sys_inotify_init:
2065 case gdb_sys_inotify_add_watch:
2066 case gdb_sys_inotify_rm_watch:
2067 case gdb_sys_migrate_pages:
2068 case gdb_sys_openat:
2069 case gdb_sys_mkdirat:
2070 case gdb_sys_mknodat:
2071 case gdb_sys_fchownat:
2072 case gdb_sys_futimesat:
2073 break;
2074
2075 case gdb_sys_fstatat64:
2076 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2077 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2078 tdep->size_stat64))
2079 return -1;
2080 break;
2081
2082 case gdb_sys_unlinkat:
2083 case gdb_sys_renameat:
2084 case gdb_sys_linkat:
2085 case gdb_sys_symlinkat:
2086 break;
2087
2088 case gdb_sys_readlinkat:
2089 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2090 if (tmpulongest)
2091 {
2092 ULONGEST bufsiz;
2093 regcache_raw_read_unsigned (regcache, tdep->arg4, &bufsiz);
2094 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) bufsiz))
2095 return -1;
2096 }
2097 break;
2098
2099 case gdb_sys_fchmodat:
2100 case gdb_sys_faccessat:
2101 break;
2102
2103 case gdb_sys_pselect6:
2104 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2105 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2106 tdep->size_fd_set))
2107 return -1;
2108 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2109 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2110 tdep->size_fd_set))
2111 return -1;
2112 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
2113 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2114 tdep->size_fd_set))
2115 return -1;
2116 regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
2117 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2118 tdep->size_timespec))
2119 return -1;
2120 break;
2121
2122 case gdb_sys_ppoll:
2123 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
2124 if (tmpulongest)
2125 {
2126 ULONGEST nfds;
2127 regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
2128 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2129 tdep->size_pollfd * nfds))
2130 return -1;
2131 }
2132 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2133 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2134 tdep->size_timespec))
2135 return -1;
2136 break;
2137
2138 case gdb_sys_unshare:
2139 case gdb_sys_set_robust_list:
2140 break;
2141
2142 case gdb_sys_get_robust_list:
2143 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2144 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
2145 return -1;
2146 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2147 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
2148 return -1;
2149 break;
2150
2151 case gdb_sys_splice:
2152 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2153 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2154 tdep->size_loff_t))
2155 return -1;
2156 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
2157 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2158 tdep->size_loff_t))
2159 return -1;
2160 break;
2161
2162 case gdb_sys_sync_file_range:
2163 case gdb_sys_tee:
2164 case gdb_sys_vmsplice:
2165 break;
2166
2167 case gdb_sys_move_pages:
2168 regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
2169 if (tmpulongest)
2170 {
2171 ULONGEST nr_pages;
2172 regcache_raw_read_unsigned (regcache, tdep->arg2, &nr_pages);
2173 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2174 nr_pages * tdep->size_int))
2175 return -1;
2176 }
2177 break;
2178
2179 case gdb_sys_getcpu:
2180 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
2181 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
2182 return -1;
2183 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2184 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
2185 return -1;
2186 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2187 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2188 tdep->size_ulong * 2))
2189 return -1;
2190 break;
2191
2192 case gdb_sys_epoll_pwait:
2193 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2194 if (tmpulongest)
2195 {
2196 ULONGEST maxevents;
2197 regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
2198 tmpint = (int) maxevents * tdep->size_epoll_event;
2199 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
2200 return -1;
2201 }
2202 break;
2203
2204 default:
2205 printf_unfiltered (_("Process record and replay target doesn't "
2206 "support syscall number %d\n"), syscall);
2207 return -1;
2208 break;
2209 }
2210
2211 return 0;
2212 }
GDB Binutils - Deliverables
This page took 0.074724 seconds and 4 git commands to generate.