1 /* The common simulator framework for GDB, the GNU Debugger. 2 3 Copyright 2002-2024 Free Software Foundation, Inc. 4 5 Contributed by Andrew Cagney and Red Hat. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 /* This must come before any other includes. */ 23 #include "defs.h" 24 25 #include <errno.h> 26 #if HAVE_FCNTL_H 27 #include <fcntl.h> 28 #endif 29 #include <stdarg.h> 30 #include <stdint.h> 31 #include <stdlib.h> 32 #include <unistd.h> 33 34 #undef open 35 36 #include "sim-main.h" 37 #include "sim-io.h" 38 #include "sim/callback.h" 39 40 /* Define the rate at which the simulator should poll the host 41 for a quit. */ 42 #ifndef POLL_QUIT_INTERVAL 43 #define POLL_QUIT_INTERVAL 0x10 44 #endif 45 46 static int poll_quit_count = POLL_QUIT_INTERVAL; 47 48 /* See the file include/callbacks.h for a description */ 49 50 51 int 52 sim_io_init (SIM_DESC sd) 53 { 54 return STATE_CALLBACK (sd)->init (STATE_CALLBACK (sd)); 55 } 56 57 58 int 59 sim_io_shutdown (SIM_DESC sd) 60 { 61 return STATE_CALLBACK (sd)->shutdown (STATE_CALLBACK (sd)); 62 } 63 64 65 int 66 sim_io_unlink (SIM_DESC sd, 67 const char *f1) 68 { 69 return STATE_CALLBACK (sd)->unlink (STATE_CALLBACK (sd), f1); 70 } 71 72 73 int64_t 74 sim_io_time (SIM_DESC sd) 75 { 76 return STATE_CALLBACK (sd)->time (STATE_CALLBACK (sd)); 77 } 78 79 80 int 81 sim_io_system (SIM_DESC sd, const char *s) 82 { 83 return STATE_CALLBACK (sd)->system (STATE_CALLBACK (sd), s); 84 } 85 86 87 int 88 sim_io_rename (SIM_DESC sd, 89 const char *f1, 90 const char *f2) 91 { 92 return STATE_CALLBACK (sd)->rename (STATE_CALLBACK (sd), f1, f2); 93 } 94 95 96 int 97 sim_io_write_stdout (SIM_DESC sd, 98 const char *buf, 99 int len) 100 { 101 switch (CURRENT_STDIO) { 102 case DO_USE_STDIO: 103 return STATE_CALLBACK (sd)->write_stdout (STATE_CALLBACK (sd), buf, len); 104 break; 105 case DONT_USE_STDIO: 106 return STATE_CALLBACK (sd)->write (STATE_CALLBACK (sd), 1, buf, len); 107 break; 108 default: 109 sim_io_error (sd, "sim_io_write_stdout: unaccounted switch\n"); 110 break; 111 } 112 return 0; 113 } 114 115 116 void 117 sim_io_flush_stdout (SIM_DESC sd) 118 { 119 switch (CURRENT_STDIO) { 120 case DO_USE_STDIO: 121 STATE_CALLBACK (sd)->flush_stdout (STATE_CALLBACK (sd)); 122 break; 123 case DONT_USE_STDIO: 124 break; 125 default: 126 sim_io_error (sd, "sim_io_flush_stdout: unaccounted switch\n"); 127 break; 128 } 129 } 130 131 132 int 133 sim_io_write_stderr (SIM_DESC sd, 134 const char *buf, 135 int len) 136 { 137 switch (CURRENT_STDIO) { 138 case DO_USE_STDIO: 139 return STATE_CALLBACK (sd)->write_stderr (STATE_CALLBACK (sd), buf, len); 140 break; 141 case DONT_USE_STDIO: 142 return STATE_CALLBACK (sd)->write (STATE_CALLBACK (sd), 2, buf, len); 143 break; 144 default: 145 sim_io_error (sd, "sim_io_write_stderr: unaccounted switch\n"); 146 break; 147 } 148 return 0; 149 } 150 151 152 void 153 sim_io_flush_stderr (SIM_DESC sd) 154 { 155 switch (CURRENT_STDIO) { 156 case DO_USE_STDIO: 157 STATE_CALLBACK (sd)->flush_stderr (STATE_CALLBACK (sd)); 158 break; 159 case DONT_USE_STDIO: 160 break; 161 default: 162 sim_io_error (sd, "sim_io_flush_stderr: unaccounted switch\n"); 163 break; 164 } 165 } 166 167 168 int 169 sim_io_write (SIM_DESC sd, 170 int fd, 171 const char *buf, 172 int len) 173 { 174 return STATE_CALLBACK (sd)->write (STATE_CALLBACK (sd), fd, buf, len); 175 } 176 177 178 int 179 sim_io_read_stdin (SIM_DESC sd, 180 char *buf, 181 int len) 182 { 183 switch (CURRENT_STDIO) { 184 case DO_USE_STDIO: 185 return STATE_CALLBACK (sd)->read_stdin (STATE_CALLBACK (sd), buf, len); 186 break; 187 case DONT_USE_STDIO: 188 return STATE_CALLBACK (sd)->read (STATE_CALLBACK (sd), 0, buf, len); 189 break; 190 default: 191 sim_io_error (sd, "sim_io_read_stdin: unaccounted switch\n"); 192 break; 193 } 194 return 0; 195 } 196 197 198 int 199 sim_io_read (SIM_DESC sd, int fd, 200 char *buf, 201 int len) 202 { 203 return STATE_CALLBACK (sd)->read (STATE_CALLBACK (sd), fd, buf, len); 204 } 205 206 207 int 208 sim_io_open (SIM_DESC sd, 209 const char *name, 210 int flags) 211 { 212 return STATE_CALLBACK (sd)->open (STATE_CALLBACK (sd), name, flags); 213 } 214 215 216 int64_t 217 sim_io_lseek (SIM_DESC sd, 218 int fd, 219 int64_t off, 220 int way) 221 { 222 return STATE_CALLBACK (sd)->lseek (STATE_CALLBACK (sd), fd, off, way); 223 } 224 225 226 int 227 sim_io_isatty (SIM_DESC sd, 228 int fd) 229 { 230 return STATE_CALLBACK (sd)->isatty (STATE_CALLBACK (sd), fd); 231 } 232 233 234 int 235 sim_io_get_errno (SIM_DESC sd) 236 { 237 return STATE_CALLBACK (sd)->get_errno (STATE_CALLBACK (sd)); 238 } 239 240 241 int 242 sim_io_close (SIM_DESC sd, 243 int fd) 244 { 245 return STATE_CALLBACK (sd)->close (STATE_CALLBACK (sd), fd); 246 } 247 248 249 void 250 sim_io_printf (SIM_DESC sd, 251 const char *fmt, 252 ...) 253 { 254 va_list ap; 255 va_start (ap, fmt); 256 STATE_CALLBACK (sd)->vprintf_filtered (STATE_CALLBACK (sd), fmt, ap); 257 va_end (ap); 258 } 259 260 261 void 262 sim_io_vprintf (SIM_DESC sd, 263 const char *fmt, 264 va_list ap) 265 { 266 STATE_CALLBACK (sd)->vprintf_filtered (STATE_CALLBACK (sd), fmt, ap); 267 } 268 269 270 void 271 sim_io_eprintf (SIM_DESC sd, 272 const char *fmt, 273 ...) 274 { 275 va_list ap; 276 va_start (ap, fmt); 277 STATE_CALLBACK (sd)->evprintf_filtered (STATE_CALLBACK (sd), fmt, ap); 278 va_end (ap); 279 } 280 281 282 void 283 sim_io_evprintf (SIM_DESC sd, 284 const char *fmt, 285 va_list ap) 286 { 287 STATE_CALLBACK (sd)->evprintf_filtered (STATE_CALLBACK (sd), fmt, ap); 288 } 289 290 291 void 292 sim_io_error (SIM_DESC sd, 293 const char *fmt, 294 ...) 295 { 296 if (sd == NULL || STATE_CALLBACK (sd) == NULL) { 297 va_list ap; 298 va_start (ap, fmt); 299 vfprintf (stderr, fmt, ap); 300 va_end (ap); 301 fprintf (stderr, "\n"); 302 abort (); 303 } 304 else { 305 va_list ap; 306 va_start (ap, fmt); 307 STATE_CALLBACK (sd)->evprintf_filtered (STATE_CALLBACK (sd), fmt, ap); 308 va_end (ap); 309 /* The %s avoids empty printf compiler warnings. Not ideal, but we want 310 error's side-effect where it halts processing. */ 311 STATE_CALLBACK (sd)->error (STATE_CALLBACK (sd), "%s", ""); 312 } 313 } 314 315 316 void 317 sim_io_poll_quit (SIM_DESC sd) 318 { 319 if (STATE_CALLBACK (sd)->poll_quit != NULL && poll_quit_count-- < 0) 320 { 321 poll_quit_count = POLL_QUIT_INTERVAL; 322 if (STATE_CALLBACK (sd)->poll_quit (STATE_CALLBACK (sd))) 323 sim_stop (sd); 324 } 325 } 326 327 328 /* Based on gdb-4.17/sim/ppc/main.c:sim_io_read_stdin(). 329 330 FIXME: Should not be calling fcntl() or grubbing around inside of 331 ->fdmap and ->errno. 332 333 FIXME: Some completly new mechanism for handling the general 334 problem of asynchronous IO is needed. 335 336 FIXME: This function does not supress the echoing (ECHO) of input. 337 Consequently polled input is always displayed. 338 339 FIXME: This function does not perform uncooked reads. 340 Consequently, data will not be read until an EOLN character has 341 been entered. A cntrl-d may force the early termination of a line */ 342 343 344 int 345 sim_io_poll_read (SIM_DESC sd, 346 int sim_io_fd, 347 char *buf, 348 int sizeof_buf) 349 { 350 #if defined(O_NONBLOCK) && defined(F_GETFL) && defined(F_SETFL) 351 int fd = STATE_CALLBACK (sd)->fdmap[sim_io_fd]; 352 int flags; 353 int status; 354 int nr_read; 355 int result; 356 STATE_CALLBACK (sd)->last_errno = 0; 357 /* get the old status */ 358 flags = fcntl (fd, F_GETFL, 0); 359 if (flags == -1) 360 { 361 perror ("sim_io_poll_read"); 362 return 0; 363 } 364 /* temp, disable blocking IO */ 365 status = fcntl (fd, F_SETFL, flags | O_NONBLOCK); 366 if (status == -1) 367 { 368 perror ("sim_io_read_stdin"); 369 return 0; 370 } 371 /* try for input */ 372 nr_read = read (fd, buf, sizeof_buf); 373 if (nr_read >= 0) 374 { 375 /* printf ("<nr-read=%d>\n", nr_read); */ 376 result = nr_read; 377 } 378 else 379 { /* nr_read < 0 */ 380 result = -1; 381 STATE_CALLBACK (sd)->last_errno = errno; 382 } 383 /* return to regular vewing */ 384 status = fcntl (fd, F_SETFL, flags); 385 if (status == -1) 386 { 387 perror ("sim_io_read_stdin"); 388 /* return 0; */ 389 } 390 return result; 391 #else 392 return sim_io_read (sd, sim_io_fd, buf, sizeof_buf); 393 #endif 394 } 395 396 int 397 sim_io_stat (SIM_DESC sd, const char *path, struct stat *buf) 398 { 399 return STATE_CALLBACK (sd)->to_stat (STATE_CALLBACK (sd), path, buf); 400 } 401 402 int 403 sim_io_fstat (SIM_DESC sd, int fd, struct stat *buf) 404 { 405 return STATE_CALLBACK (sd)->to_fstat (STATE_CALLBACK (sd), fd, buf); 406 } 407