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