1 /* Remote target callback routines.
2 Copyright 1995, 1996, 1997, 2000, 2002, 2003, 2004
3 Free Software Foundation, Inc.
4 Contributed by Cygnus Solutions.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 /* This file provides a standard way for targets to talk to the host OS
29 #ifdef ANSI_PROTOTYPES
52 #include <sys/types.h>
54 #include "gdb/callback.h"
55 #include "targ-vals.h"
57 #include "libiberty.h"
63 /* ??? sim_cb_printf should be cb_printf, but until the callback support is
64 broken out of the simulator directory, these are here to not require
66 void sim_cb_printf
PARAMS ((host_callback
*, const char *, ...));
67 void sim_cb_eprintf
PARAMS ((host_callback
*, const char *, ...));
69 extern CB_TARGET_DEFS_MAP cb_init_syscall_map
[];
70 extern CB_TARGET_DEFS_MAP cb_init_errno_map
[];
71 extern CB_TARGET_DEFS_MAP cb_init_open_map
[];
73 extern int system
PARAMS ((const char *));
75 static int os_init
PARAMS ((host_callback
*));
76 static int os_shutdown
PARAMS ((host_callback
*));
77 static int os_unlink
PARAMS ((host_callback
*, const char *));
78 static long os_time
PARAMS ((host_callback
*, long *));
79 static int os_system
PARAMS ((host_callback
*, const char *));
80 static int os_rename
PARAMS ((host_callback
*, const char *, const char *));
81 static int os_write_stdout
PARAMS ((host_callback
*, const char *, int));
82 static void os_flush_stdout
PARAMS ((host_callback
*));
83 static int os_write_stderr
PARAMS ((host_callback
*, const char *, int));
84 static void os_flush_stderr
PARAMS ((host_callback
*));
85 static int os_write
PARAMS ((host_callback
*, int, const char *, int));
86 static int os_read_stdin
PARAMS ((host_callback
*, char *, int));
87 static int os_read
PARAMS ((host_callback
*, int, char *, int));
88 static int os_open
PARAMS ((host_callback
*, const char *, int));
89 static int os_lseek
PARAMS ((host_callback
*, int, long, int));
90 static int os_isatty
PARAMS ((host_callback
*, int));
91 static int os_get_errno
PARAMS ((host_callback
*));
92 static int os_close
PARAMS ((host_callback
*, int));
93 static void os_vprintf_filtered
PARAMS ((host_callback
*, const char *, va_list));
94 static void os_evprintf_filtered
PARAMS ((host_callback
*, const char *, va_list));
95 static void os_error
PARAMS ((host_callback
*, const char *, ...));
96 static int fdmap
PARAMS ((host_callback
*, int));
97 static int fdbad
PARAMS ((host_callback
*, int));
98 static int wrap
PARAMS ((host_callback
*, int));
100 /* Set the callback copy of errno from what we see now. */
107 p
->last_errno
= errno
;
111 /* Make sure the FD provided is ok. If not, return non-zero
119 if (fd
< 0 || fd
> MAX_CALLBACK_FDS
|| p
->fd_buddy
[fd
] < 0)
121 p
->last_errno
= EINVAL
;
143 result
= fdbad (p
, fd
);
146 /* If this file descripter has one or more buddies (originals /
147 duplicates from a dup), just remove it from the circular list. */
148 for (i
= fd
; (next
= p
->fd_buddy
[i
]) != fd
; )
151 p
->fd_buddy
[i
] = p
->fd_buddy
[fd
];
156 int other
= p
->ispipe
[fd
];
161 /* Closing the read side. */
167 /* Closing the write side. */
172 /* If there was data in the buffer, make a last "now empty"
173 call, then deallocate data. */
174 if (p
->pipe_buffer
[writer
].buffer
!= NULL
)
176 (*p
->pipe_empty
) (p
, reader
, writer
);
177 free (p
->pipe_buffer
[writer
].buffer
);
178 p
->pipe_buffer
[writer
].buffer
= NULL
;
181 /* Clear pipe data for this side. */
182 p
->pipe_buffer
[fd
].size
= 0;
185 /* If this was the first close, mark the other side as the
186 only remaining side. */
187 if (fd
!= abs (other
))
188 p
->ispipe
[abs (other
)] = -other
;
189 p
->fd_buddy
[fd
] = -1;
193 result
= wrap (p
, close (fdmap (p
, fd
)));
195 p
->fd_buddy
[fd
] = -1;
201 /* taken from gdb/util.c:notice_quit() - should be in a library */
204 #if defined(__GO32__) || defined (_MSC_VER)
209 #if defined(__GO32__)
225 sim_cb_eprintf (p
, "CTRL-A to quit, CTRL-B to quit harder\n");
229 #if defined (_MSC_VER)
230 /* NB - this will not compile! */
231 int k
= win32pollquit();
240 #define os_poll_quit 0
241 #endif /* defined(__GO32__) || defined(_MSC_VER) */
247 return cb_host_to_target_errno (p
, p
->last_errno
);
258 result
= fdbad (p
, fd
);
261 result
= wrap (p
, isatty (fdmap (p
, fd
)));
267 os_lseek (p
, fd
, off
, way
)
275 result
= fdbad (p
, fd
);
278 result
= lseek (fdmap (p
, fd
), off
, way
);
283 os_open (p
, name
, flags
)
289 for (i
= 0; i
< MAX_CALLBACK_FDS
; i
++)
291 if (p
->fd_buddy
[i
] < 0)
293 int f
= open (name
, cb_target_to_host_open (p
, flags
), 0644);
296 p
->last_errno
= errno
;
304 p
->last_errno
= EMFILE
;
309 os_read (p
, fd
, buf
, len
)
317 result
= fdbad (p
, fd
);
322 int writer
= p
->ispipe
[fd
];
324 /* Can't read from the write-end. */
327 p
->last_errno
= EBADF
;
331 /* Nothing to read if nothing is written. */
332 if (p
->pipe_buffer
[writer
].size
== 0)
335 /* Truncate read request size to buffer size minus what's already
337 if (len
> p
->pipe_buffer
[writer
].size
- p
->pipe_buffer
[fd
].size
)
338 len
= p
->pipe_buffer
[writer
].size
- p
->pipe_buffer
[fd
].size
;
340 memcpy (buf
, p
->pipe_buffer
[writer
].buffer
+ p
->pipe_buffer
[fd
].size
,
343 /* Account for what we just read. */
344 p
->pipe_buffer
[fd
].size
+= len
;
346 /* If we've read everything, empty and deallocate the buffer and
347 signal buffer-empty to client. (This isn't expected to be a
348 hot path in the simulator, so we don't hold on to the buffer.) */
349 if (p
->pipe_buffer
[fd
].size
== p
->pipe_buffer
[writer
].size
)
351 free (p
->pipe_buffer
[writer
].buffer
);
352 p
->pipe_buffer
[writer
].buffer
= NULL
;
353 p
->pipe_buffer
[fd
].size
= 0;
354 p
->pipe_buffer
[writer
].size
= 0;
355 (*p
->pipe_empty
) (p
, fd
, writer
);
361 result
= wrap (p
, read (fdmap (p
, fd
), buf
, len
));
366 os_read_stdin (p
, buf
, len
)
371 return wrap (p
, read (0, buf
, len
));
375 os_write (p
, fd
, buf
, len
)
384 result
= fdbad (p
, fd
);
390 int reader
= -p
->ispipe
[fd
];
392 /* Can't write to the read-end. */
395 p
->last_errno
= EBADF
;
399 /* Can't write to pipe with closed read end.
400 FIXME: We should send a SIGPIPE. */
403 p
->last_errno
= EPIPE
;
407 /* As a sanity-check, we bail out it the buffered contents is much
408 larger than the size of the buffer on the host. We don't want
409 to run out of memory in the simulator due to a target program
410 bug if we can help it. Unfortunately, regarding the value that
411 reaches the simulated program, it's no use returning *less*
412 than the requested amount, because cb_syscall loops calling
413 this function until the whole amount is done. */
414 if (p
->pipe_buffer
[fd
].size
+ len
> 10 * PIPE_BUF
)
416 p
->last_errno
= EFBIG
;
420 p
->pipe_buffer
[fd
].buffer
421 = xrealloc (p
->pipe_buffer
[fd
].buffer
, p
->pipe_buffer
[fd
].size
+ len
);
422 memcpy (p
->pipe_buffer
[fd
].buffer
+ p
->pipe_buffer
[fd
].size
,
424 p
->pipe_buffer
[fd
].size
+= len
;
426 (*p
->pipe_nonempty
) (p
, reader
, fd
);
430 real_fd
= fdmap (p
, fd
);
434 result
= wrap (p
, write (real_fd
, buf
, len
));
437 result
= p
->write_stdout (p
, buf
, len
);
440 result
= p
->write_stderr (p
, buf
, len
);
447 os_write_stdout (p
, buf
, len
)
448 host_callback
*p ATTRIBUTE_UNUSED
;
452 return fwrite (buf
, 1, len
, stdout
);
457 host_callback
*p ATTRIBUTE_UNUSED
;
463 os_write_stderr (p
, buf
, len
)
464 host_callback
*p ATTRIBUTE_UNUSED
;
468 return fwrite (buf
, 1, len
, stderr
);
473 host_callback
*p ATTRIBUTE_UNUSED
;
479 os_rename (p
, f1
, f2
)
484 return wrap (p
, rename (f1
, f2
));
493 return wrap (p
, system (s
));
501 return wrap (p
, time (t
));
510 return wrap (p
, unlink (f1
));
514 os_stat (p
, file
, buf
)
519 /* ??? There is an issue of when to translate to the target layout.
520 One could do that inside this function, or one could have the
521 caller do it. It's more flexible to let the caller do it, though
522 I'm not sure the flexibility will ever be useful. */
523 return wrap (p
, stat (file
, buf
));
527 os_fstat (p
, fd
, buf
)
537 #if defined (HAVE_STRUCT_STAT_ST_ATIME) || defined (HAVE_STRUCT_STAT_ST_CTIME) || defined (HAVE_STRUCT_STAT_ST_MTIME)
538 time_t t
= (*p
->time
) (p
, NULL
);
541 /* We have to fake the struct stat contents, since the pipe is
542 made up in the simulator. */
543 memset (buf
, 0, sizeof (*buf
));
545 #ifdef HAVE_STRUCT_STAT_ST_MODE
546 buf
->st_mode
= S_IFIFO
;
549 /* If more accurate tracking than current-time is needed (for
550 example, on GNU/Linux we get accurate numbers), the p->time
551 callback (which may be something other than os_time) should
552 happen for each read and write, and we'd need to keep track of
553 atime, ctime and mtime. */
554 #ifdef HAVE_STRUCT_STAT_ST_ATIME
557 #ifdef HAVE_STRUCT_STAT_ST_CTIME
560 #ifdef HAVE_STRUCT_STAT_ST_MTIME
566 /* ??? There is an issue of when to translate to the target layout.
567 One could do that inside this function, or one could have the
568 caller do it. It's more flexible to let the caller do it, though
569 I'm not sure the flexibility will ever be useful. */
570 return wrap (p
, fstat (fdmap (p
, fd
), buf
));
574 os_lstat (p
, file
, buf
)
579 /* NOTE: hpn/2004-12-12: Same issue here as with os_fstat. */
580 return wrap (p
, lstat (file
, buf
));
584 os_ftruncate (p
, fd
, len
)
591 result
= fdbad (p
, fd
);
594 p
->last_errno
= EINVAL
;
599 result
= wrap (p
, ftruncate (fdmap (p
, fd
), len
));
604 os_truncate (p
, file
, len
)
609 return wrap (p
, truncate (file
, len
));
619 /* We deliberately don't use fd 0. It's probably stdin anyway. */
620 for (i
= 1; i
< MAX_CALLBACK_FDS
; i
++)
624 if (p
->fd_buddy
[i
] < 0)
625 for (j
= i
+ 1; j
< MAX_CALLBACK_FDS
; j
++)
626 if (p
->fd_buddy
[j
] < 0)
628 /* Found two free fd:s. Set stat to allocated and mark
637 /* Poison the FD map to make bugs apparent. */
644 p
->last_errno
= EMFILE
;
648 /* Stub functions for pipe support. They should always be overridden in
649 targets using the pipe support, but that's up to the target. */
651 /* Called when the simulator says that the pipe at (reader, writer) is
652 now empty (so the writer should leave its waiting state). */
655 os_pipe_empty (p
, reader
, writer
)
662 /* Called when the simulator says the pipe at (reader, writer) is now
663 non-empty (so the writer should wait). */
666 os_pipe_nonempty (p
, reader
, writer
)
678 for (i
= 0; i
< MAX_CALLBACK_FDS
; i
++)
682 /* Zero out all pipe state. Don't call callbacks for non-empty
683 pipes; the target program has likely terminated at this point
684 or we're called at initialization time. */
686 p
->pipe_buffer
[i
].size
= 0;
687 p
->pipe_buffer
[i
].buffer
= NULL
;
689 next
= p
->fd_buddy
[i
];
695 if (j
== MAX_CALLBACK_FDS
)
697 next
= p
->fd_buddy
[j
];
699 /* At the initial call of os_init, we got -1, 0, 0, 0, ... */
721 for (i
= 0; i
< 3; i
++)
724 p
->fd_buddy
[i
] = i
- 1;
726 p
->fd_buddy
[0] = MAX_CALLBACK_FDS
;
727 p
->fd_buddy
[MAX_CALLBACK_FDS
] = 2;
729 p
->syscall_map
= cb_init_syscall_map
;
730 p
->errno_map
= cb_init_errno_map
;
731 p
->open_map
= cb_init_open_map
;
740 #ifdef ANSI_PROTOTYPES
741 os_printf_filtered (host_callback
*p ATTRIBUTE_UNUSED
, const char *format
, ...)
743 os_printf_filtered (p
, va_alist
)
749 #ifdef ANSI_PROTOTYPES
750 va_start (args
, format
);
755 format
= va_arg (args
, char *);
758 vfprintf (stdout
, format
, args
);
764 #ifdef ANSI_PROTOTYPES
765 os_vprintf_filtered (host_callback
*p ATTRIBUTE_UNUSED
, const char *format
, va_list args
)
767 os_vprintf_filtered (p
, format
, args
)
773 vprintf (format
, args
);
778 #ifdef ANSI_PROTOTYPES
779 os_evprintf_filtered (host_callback
*p ATTRIBUTE_UNUSED
, const char *format
, va_list args
)
781 os_evprintf_filtered (p
, format
, args
)
787 vfprintf (stderr
, format
, args
);
792 #ifdef ANSI_PROTOTYPES
793 os_error (host_callback
*p ATTRIBUTE_UNUSED
, const char *format
, ...)
795 os_error (p
, va_alist
)
801 #ifdef ANSI_PROTOTYPES
802 va_start (args
, format
);
807 format
= va_arg (args
, char *);
810 vfprintf (stderr
, format
, args
);
811 fprintf (stderr
, "\n");
817 host_callback default_callback
=
852 os_printf_filtered
, /* deprecated */
855 os_evprintf_filtered
,
861 { -1, }, /* fd_buddy */
863 { { 0, 0 }, }, /* pipe_buffer */
871 /* Defaults expected to be overridden at initialization, where needed. */
872 BFD_ENDIAN_UNKNOWN
, /* target_endian */
873 4, /* target_sizeof_int */
878 /* Read in a file describing the target's system call values.
879 E.g. maybe someone will want to use something other than newlib.
880 This assumes that the basic system call recognition and value passing/
881 returning is supported. So maybe some coding/recompilation will be
882 necessary, but not as much.
884 If an error occurs, the existing mapping is not changed. */
887 cb_read_target_syscall_maps (cb
, file
)
891 CB_TARGET_DEFS_MAP
*syscall_map
, *errno_map
, *open_map
, *signal_map
;
892 const char *stat_map
;
895 if ((f
= fopen (file
, "r")) == NULL
)
898 /* ... read in and parse file ... */
901 return CB_RC_NO_MEM
; /* FIXME:wip */
903 /* Free storage allocated for any existing maps. */
905 free (cb
->syscall_map
);
907 free (cb
->errno_map
);
911 free (cb
->signal_map
);
913 free ((PTR
) cb
->stat_map
);
915 cb
->syscall_map
= syscall_map
;
916 cb
->errno_map
= errno_map
;
917 cb
->open_map
= open_map
;
918 cb
->signal_map
= signal_map
;
919 cb
->stat_map
= stat_map
;
924 /* Translate the target's version of a syscall number to the host's.
925 This isn't actually the host's version, rather a canonical form.
926 ??? Perhaps this should be renamed to ..._canon_syscall. */
929 cb_target_to_host_syscall (cb
, target_val
)
933 CB_TARGET_DEFS_MAP
*m
;
935 for (m
= &cb
->syscall_map
[0]; m
->target_val
!= -1; ++m
)
936 if (m
->target_val
== target_val
)
942 /* FIXME: sort tables if large.
943 Alternatively, an obvious improvement for errno conversion is
944 to machine generate a function with a large switch(). */
946 /* Translate the host's version of errno to the target's. */
949 cb_host_to_target_errno (cb
, host_val
)
953 CB_TARGET_DEFS_MAP
*m
;
955 for (m
= &cb
->errno_map
[0]; m
->host_val
; ++m
)
956 if (m
->host_val
== host_val
)
957 return m
->target_val
;
959 /* ??? Which error to return in this case is up for grabs.
960 Note that some missing values may have standard alternatives.
961 For now return 0 and require caller to deal with it. */
965 /* Given a set of target bitmasks for the open system call,
966 return the host equivalent.
967 Mapping open flag values is best done by looping so there's no need
968 to machine generate this function. */
971 cb_target_to_host_open (cb
, target_val
)
976 CB_TARGET_DEFS_MAP
*m
;
978 for (m
= &cb
->open_map
[0]; m
->host_val
!= -1; ++m
)
980 switch (m
->target_val
)
982 /* O_RDONLY can be (and usually is) 0 which needs to be treated
984 case TARGET_O_RDONLY
:
985 case TARGET_O_WRONLY
:
987 if ((target_val
& (TARGET_O_RDONLY
| TARGET_O_WRONLY
| TARGET_O_RDWR
))
989 host_val
|= m
->host_val
;
990 /* Handle the host/target differentiating between binary and
991 text mode. Only one case is of importance */
992 #if ! defined (TARGET_O_BINARY) && defined (O_BINARY)
993 host_val
|= O_BINARY
;
997 if ((m
->target_val
& target_val
) == m
->target_val
)
998 host_val
|= m
->host_val
;
1006 /* Utility for e.g. cb_host_to_target_stat to store values in the target's
1010 cb_store_target_endian (cb
, p
, size
, val
)
1014 long val
; /* ??? must be as big as target word size */
1016 if (cb
->target_endian
== BFD_ENDIAN_BIG
)
1035 /* Translate a host's stat struct into a target's.
1036 If HS is NULL, just compute the length of the buffer required,
1039 The result is the size of the target's stat struct,
1040 or zero if an error occurred during the translation. */
1043 cb_host_to_target_stat (cb
, hs
, ts
)
1045 const struct stat
*hs
;
1048 const char *m
= cb
->stat_map
;
1057 char *q
= strchr (m
, ',');
1060 /* FIXME: Use sscanf? */
1063 /* FIXME: print error message */
1066 size
= atoi (q
+ 1);
1069 /* FIXME: print error message */
1077 /* Defined here to avoid emacs indigestion on a lone "else". */
1080 else if (strncmp (m, #FLD, q - m) == 0) \
1081 cb_store_target_endian (cb, p, size, hs->FLD)
1083 #ifdef HAVE_STRUCT_STAT_ST_DEV
1086 #ifdef HAVE_STRUCT_STAT_ST_INO
1089 #ifdef HAVE_STRUCT_STAT_ST_MODE
1092 #ifdef HAVE_STRUCT_STAT_ST_NLINK
1095 #ifdef HAVE_STRUCT_STAT_ST_UID
1098 #ifdef HAVE_STRUCT_STAT_ST_GID
1101 #ifdef HAVE_STRUCT_STAT_ST_RDEV
1104 #ifdef HAVE_STRUCT_STAT_ST_SIZE
1107 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
1110 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
1113 #ifdef HAVE_STRUCT_STAT_ST_ATIME
1116 #ifdef HAVE_STRUCT_STAT_ST_MTIME
1119 #ifdef HAVE_STRUCT_STAT_ST_CTIME
1125 /* Unsupported field, store 0. */
1126 cb_store_target_endian (cb
, p
, size
, 0);
1130 m
= strchr (q
, ':');
1135 return p
- (char *) ts
;
1138 /* Cover functions to the vfprintf callbacks.
1140 ??? If one thinks of the callbacks as a subsystem onto itself [or part of
1141 a larger "remote target subsystem"] with a well defined interface, then
1142 one would think that the subsystem would provide these. However, until
1143 one is allowed to create such a subsystem (with its own source tree
1144 independent of any particular user), such a critter can't exist. Thus
1145 these functions are here for the time being. */
1148 sim_cb_printf (host_callback
*p
, const char *fmt
, ...)
1153 p
->vprintf_filtered (p
, fmt
, ap
);
1158 sim_cb_eprintf (host_callback
*p
, const char *fmt
, ...)
1163 p
->evprintf_filtered (p
, fmt
, ap
);