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