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