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