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