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