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