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