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