projects / deliverable / binutils-gdb.git / blob
? search:


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