OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [event-loop.c] - Blame information for rev 827

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Event loop machinery for GDB, the GNU debugger.
2
   Copyright (C) 1999, 2000, 2001, 2002, 2005, 2006, 2007, 2008
3
   Free Software Foundation, Inc.
4
   Written by Elena Zannoni <ezannoni@cygnus.com> of Cygnus Solutions.
5
 
6
   This file is part of GDB.
7
 
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 3 of the License, or
11
   (at your option) any later version.
12
 
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.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with this program.  If not, see <http://www.gnu.org/licenses/>. */
20
 
21
#include "defs.h"
22
#include "event-loop.h"
23
#include "event-top.h"
24
 
25
#ifdef HAVE_POLL
26
#if defined (HAVE_POLL_H)
27
#include <poll.h>
28
#elif defined (HAVE_SYS_POLL_H)
29
#include <sys/poll.h>
30
#endif
31
#endif
32
 
33
#include <sys/types.h>
34
#include "gdb_string.h"
35
#include <errno.h>
36
#include <sys/time.h>
37
#include "exceptions.h"
38
#include "gdb_assert.h"
39
#include "gdb_select.h"
40
 
41
typedef struct gdb_event gdb_event;
42
typedef void (event_handler_func) (int);
43
 
44
/* Event for the GDB event system.  Events are queued by calling
45
   async_queue_event and serviced later on by gdb_do_one_event. An
46
   event can be, for instance, a file descriptor becoming ready to be
47
   read. Servicing an event simply means that the procedure PROC will
48
   be called.  We have 2 queues, one for file handlers that we listen
49
   to in the event loop, and one for the file handlers+events that are
50
   ready. The procedure PROC associated with each event is always the
51
   same (handle_file_event).  Its duty is to invoke the handler
52
   associated with the file descriptor whose state change generated
53
   the event, plus doing other cleanups and such. */
54
 
55
struct gdb_event
56
  {
57
    event_handler_func *proc;   /* Procedure to call to service this event. */
58
    int fd;                     /* File descriptor that is ready. */
59
    struct gdb_event *next_event;       /* Next in list of events or NULL. */
60
  };
61
 
62
/* Information about each file descriptor we register with the event
63
   loop. */
64
 
65
typedef struct file_handler
66
  {
67
    int fd;                     /* File descriptor. */
68
    int mask;                   /* Events we want to monitor: POLLIN, etc. */
69
    int ready_mask;             /* Events that have been seen since
70
                                   the last time. */
71
    handler_func *proc;         /* Procedure to call when fd is ready. */
72
    gdb_client_data client_data;        /* Argument to pass to proc. */
73
    int error;                  /* Was an error detected on this fd? */
74
    struct file_handler *next_file;     /* Next registered file descriptor. */
75
  }
76
file_handler;
77
 
78
/* PROC is a function to be invoked when the READY flag is set. This
79
   happens when there has been a signal and the corresponding signal
80
   handler has 'triggered' this async_signal_handler for
81
   execution. The actual work to be done in response to a signal will
82
   be carried out by PROC at a later time, within process_event. This
83
   provides a deferred execution of signal handlers.
84
   Async_init_signals takes care of setting up such an
85
   asyn_signal_handler for each interesting signal. */
86
typedef struct async_signal_handler
87
  {
88
    int ready;                  /* If ready, call this handler from the main event loop,
89
                                   using invoke_async_handler. */
90
    struct async_signal_handler *next_handler;  /* Ptr to next handler */
91
    sig_handler_func *proc;     /* Function to call to do the work */
92
    gdb_client_data client_data;        /* Argument to async_handler_func */
93
  }
94
async_signal_handler;
95
 
96
 
97
/* Event queue:
98
   - the first event in the queue is the head of the queue.
99
   It will be the next to be serviced.
100
   - the last event in the queue
101
 
102
   Events can be inserted at the front of the queue or at the end of
103
   the queue.  Events will be extracted from the queue for processing
104
   starting from the head.  Therefore, events inserted at the head of
105
   the queue will be processed in a last in first out fashion, while
106
   those inserted at the tail of the queue will be processed in a first
107
   in first out manner.  All the fields are NULL if the queue is
108
   empty. */
109
 
110
static struct
111
  {
112
    gdb_event *first_event;     /* First pending event */
113
    gdb_event *last_event;      /* Last pending event */
114
  }
115
event_queue;
116
 
117
/* Gdb_notifier is just a list of file descriptors gdb is interested in.
118
   These are the input file descriptor, and the target file
119
   descriptor. We have two flavors of the notifier, one for platforms
120
   that have the POLL function, the other for those that don't, and
121
   only support SELECT. Each of the elements in the gdb_notifier list is
122
   basically a description of what kind of events gdb is interested
123
   in, for each fd. */
124
 
125
/* As of 1999-04-30 only the input file descriptor is registered with the
126
   event loop. */
127
 
128
/* Do we use poll or select ? */
129
#ifdef HAVE_POLL
130
#define USE_POLL 1
131
#else
132
#define USE_POLL 0
133
#endif /* HAVE_POLL */
134
 
135
static unsigned char use_poll = USE_POLL;
136
 
137
#ifdef USE_WIN32API
138
#include <windows.h>
139
#include <io.h>
140
#endif
141
 
142
static struct
143
  {
144
    /* Ptr to head of file handler list. */
145
    file_handler *first_file_handler;
146
 
147
#ifdef HAVE_POLL
148
    /* Ptr to array of pollfd structures. */
149
    struct pollfd *poll_fds;
150
 
151
    /* Timeout in milliseconds for calls to poll(). */
152
    int poll_timeout;
153
#endif
154
 
155
    /* Masks to be used in the next call to select.
156
       Bits are set in response to calls to create_file_handler. */
157
    fd_set check_masks[3];
158
 
159
    /* What file descriptors were found ready by select. */
160
    fd_set ready_masks[3];
161
 
162
    /* Number of file descriptors to monitor. (for poll) */
163
    /* Number of valid bits (highest fd value + 1). (for select) */
164
    int num_fds;
165
 
166
    /* Time structure for calls to select(). */
167
    struct timeval select_timeout;
168
 
169
    /* Flag to tell whether the timeout should be used. */
170
    int timeout_valid;
171
  }
172
gdb_notifier;
173
 
174
/* Structure associated with a timer. PROC will be executed at the
175
   first occasion after WHEN. */
176
struct gdb_timer
177
  {
178
    struct timeval when;
179
    int timer_id;
180
    struct gdb_timer *next;
181
    timer_handler_func *proc;   /* Function to call to do the work */
182
    gdb_client_data client_data;        /* Argument to async_handler_func */
183
  }
184
gdb_timer;
185
 
186
/* List of currently active timers. It is sorted in order of
187
   increasing timers. */
188
static struct
189
  {
190
    /* Pointer to first in timer list. */
191
    struct gdb_timer *first_timer;
192
 
193
    /* Id of the last timer created. */
194
    int num_timers;
195
  }
196
timer_list;
197
 
198
/* All the async_signal_handlers gdb is interested in are kept onto
199
   this list. */
200
static struct
201
  {
202
    /* Pointer to first in handler list. */
203
    async_signal_handler *first_handler;
204
 
205
    /* Pointer to last in handler list. */
206
    async_signal_handler *last_handler;
207
  }
208
sighandler_list;
209
 
210
/* Are any of the handlers ready?  Check this variable using
211
   check_async_ready. This is used by process_event, to determine
212
   whether or not to invoke the invoke_async_signal_handler
213
   function. */
214
static int async_handler_ready = 0;
215
 
216
static void create_file_handler (int fd, int mask, handler_func * proc, gdb_client_data client_data);
217
static void invoke_async_signal_handler (void);
218
static void handle_file_event (int event_file_desc);
219
static int gdb_wait_for_event (void);
220
static int check_async_ready (void);
221
static void async_queue_event (gdb_event * event_ptr, queue_position position);
222
static gdb_event *create_file_event (int fd);
223
static int process_event (void);
224
static void handle_timer_event (int dummy);
225
static void poll_timers (void);
226
 
227
 
228
/* Insert an event object into the gdb event queue at
229
   the specified position.
230
   POSITION can be head or tail, with values TAIL, HEAD.
231
   EVENT_PTR points to the event to be inserted into the queue.
232
   The caller must allocate memory for the event. It is freed
233
   after the event has ben handled.
234
   Events in the queue will be processed head to tail, therefore,
235
   events inserted at the head of the queue will be processed
236
   as last in first out. Event appended at the tail of the queue
237
   will be processed first in first out. */
238
static void
239
async_queue_event (gdb_event * event_ptr, queue_position position)
240
{
241
  if (position == TAIL)
242
    {
243
      /* The event will become the new last_event. */
244
 
245
      event_ptr->next_event = NULL;
246
      if (event_queue.first_event == NULL)
247
        event_queue.first_event = event_ptr;
248
      else
249
        event_queue.last_event->next_event = event_ptr;
250
      event_queue.last_event = event_ptr;
251
    }
252
  else if (position == HEAD)
253
    {
254
      /* The event becomes the new first_event. */
255
 
256
      event_ptr->next_event = event_queue.first_event;
257
      if (event_queue.first_event == NULL)
258
        event_queue.last_event = event_ptr;
259
      event_queue.first_event = event_ptr;
260
    }
261
}
262
 
263
/* Create a file event, to be enqueued in the event queue for
264
   processing. The procedure associated to this event is always
265
   handle_file_event, which will in turn invoke the one that was
266
   associated to FD when it was registered with the event loop. */
267
static gdb_event *
268
create_file_event (int fd)
269
{
270
  gdb_event *file_event_ptr;
271
 
272
  file_event_ptr = (gdb_event *) xmalloc (sizeof (gdb_event));
273
  file_event_ptr->proc = handle_file_event;
274
  file_event_ptr->fd = fd;
275
  return (file_event_ptr);
276
}
277
 
278
/* Process one event.
279
   The event can be the next one to be serviced in the event queue,
280
   or an asynchronous event handler can be invoked in response to
281
   the reception of a signal.
282
   If an event was processed (either way), 1 is returned otherwise
283
 
284
   Scan the queue from head to tail, processing therefore the high
285
   priority events first, by invoking the associated event handler
286
   procedure. */
287
static int
288
process_event (void)
289
{
290
  gdb_event *event_ptr, *prev_ptr;
291
  event_handler_func *proc;
292
  int fd;
293
 
294
  /* First let's see if there are any asynchronous event handlers that
295
     are ready. These would be the result of invoking any of the
296
     signal handlers. */
297
 
298
  if (check_async_ready ())
299
    {
300
      invoke_async_signal_handler ();
301
      return 1;
302
    }
303
 
304
  /* Look in the event queue to find an event that is ready
305
     to be processed. */
306
 
307
  for (event_ptr = event_queue.first_event; event_ptr != NULL;
308
       event_ptr = event_ptr->next_event)
309
    {
310
      /* Call the handler for the event. */
311
 
312
      proc = event_ptr->proc;
313
      fd = event_ptr->fd;
314
 
315
      /* Let's get rid of the event from the event queue.  We need to
316
         do this now because while processing the event, the proc
317
         function could end up calling 'error' and therefore jump out
318
         to the caller of this function, gdb_do_one_event. In that
319
         case, we would have on the event queue an event wich has been
320
         processed, but not deleted. */
321
 
322
      if (event_queue.first_event == event_ptr)
323
        {
324
          event_queue.first_event = event_ptr->next_event;
325
          if (event_ptr->next_event == NULL)
326
            event_queue.last_event = NULL;
327
        }
328
      else
329
        {
330
          prev_ptr = event_queue.first_event;
331
          while (prev_ptr->next_event != event_ptr)
332
            prev_ptr = prev_ptr->next_event;
333
 
334
          prev_ptr->next_event = event_ptr->next_event;
335
          if (event_ptr->next_event == NULL)
336
            event_queue.last_event = prev_ptr;
337
        }
338
      xfree (event_ptr);
339
 
340
      /* Now call the procedure associated with the event. */
341
      (*proc) (fd);
342
      return 1;
343
    }
344
 
345
  /* this is the case if there are no event on the event queue. */
346
  return 0;
347
}
348
 
349
/* Process one high level event.  If nothing is ready at this time,
350
   wait for something to happen (via gdb_wait_for_event), then process
351
   it.  Returns >0 if something was done otherwise returns <0 (this
352
   can happen if there are no event sources to wait for).  If an error
353
   occurs catch_errors() which calls this function returns zero. */
354
 
355
int
356
gdb_do_one_event (void *data)
357
{
358
  /* Any events already waiting in the queue? */
359
  if (process_event ())
360
    {
361
      return 1;
362
    }
363
 
364
  /* Are any timers that are ready? If so, put an event on the queue. */
365
  poll_timers ();
366
 
367
  /* Wait for a new event.  If gdb_wait_for_event returns -1,
368
     we should get out because this means that there are no
369
     event sources left. This will make the event loop stop,
370
     and the application exit. */
371
 
372
  if (gdb_wait_for_event () < 0)
373
    {
374
      return -1;
375
    }
376
 
377
  /* Handle any new events occurred while waiting. */
378
  if (process_event ())
379
    {
380
      return 1;
381
    }
382
 
383
  /* If gdb_wait_for_event has returned 1, it means that one
384
     event has been handled. We break out of the loop. */
385
  return 1;
386
}
387
 
388
/* Start up the event loop. This is the entry point to the event loop
389
   from the command loop. */
390
 
391
void
392
start_event_loop (void)
393
{
394
  /* Loop until there is nothing to do. This is the entry point to the
395
     event loop engine. gdb_do_one_event, called via catch_errors()
396
     will process one event for each invocation.  It blocks waits for
397
     an event and then processes it.  >0 when an event is processed, 0
398
     when catch_errors() caught an error and <0 when there are no
399
     longer any event sources registered. */
400
  while (1)
401
    {
402
      int gdb_result;
403
 
404
      gdb_result = catch_errors (gdb_do_one_event, 0, "", RETURN_MASK_ALL);
405
      if (gdb_result < 0)
406
        break;
407
 
408
      /* If we long-jumped out of do_one_event, we probably
409
         didn't get around to resetting the prompt, which leaves
410
         readline in a messed-up state.  Reset it here. */
411
 
412
      if (gdb_result == 0)
413
        {
414
          /* FIXME: this should really be a call to a hook that is
415
             interface specific, because interfaces can display the
416
             prompt in their own way. */
417
          display_gdb_prompt (0);
418
          /* This call looks bizarre, but it is required.  If the user
419
             entered a command that caused an error,
420
             after_char_processing_hook won't be called from
421
             rl_callback_read_char_wrapper.  Using a cleanup there
422
             won't work, since we want this function to be called
423
             after a new prompt is printed.  */
424
          if (after_char_processing_hook)
425
            (*after_char_processing_hook) ();
426
          /* Maybe better to set a flag to be checked somewhere as to
427
             whether display the prompt or not. */
428
        }
429
    }
430
 
431
  /* We are done with the event loop. There are no more event sources
432
     to listen to.  So we exit GDB. */
433
  return;
434
}
435
 
436
 
437
/* Wrapper function for create_file_handler, so that the caller
438
   doesn't have to know implementation details about the use of poll
439
   vs. select. */
440
void
441
add_file_handler (int fd, handler_func * proc, gdb_client_data client_data)
442
{
443
#ifdef HAVE_POLL
444
  struct pollfd fds;
445
#endif
446
 
447
  if (use_poll)
448
    {
449
#ifdef HAVE_POLL
450
      /* Check to see if poll () is usable. If not, we'll switch to
451
         use select. This can happen on systems like
452
         m68k-motorola-sys, `poll' cannot be used to wait for `stdin'.
453
         On m68k-motorola-sysv, tty's are not stream-based and not
454
         `poll'able. */
455
      fds.fd = fd;
456
      fds.events = POLLIN;
457
      if (poll (&fds, 1, 0) == 1 && (fds.revents & POLLNVAL))
458
        use_poll = 0;
459
#else
460
      internal_error (__FILE__, __LINE__,
461
                      _("use_poll without HAVE_POLL"));
462
#endif /* HAVE_POLL */
463
    }
464
  if (use_poll)
465
    {
466
#ifdef HAVE_POLL
467
      create_file_handler (fd, POLLIN, proc, client_data);
468
#else
469
      internal_error (__FILE__, __LINE__,
470
                      _("use_poll without HAVE_POLL"));
471
#endif
472
    }
473
  else
474
    create_file_handler (fd, GDB_READABLE | GDB_EXCEPTION, proc, client_data);
475
}
476
 
477
/* Add a file handler/descriptor to the list of descriptors we are
478
   interested in.
479
   FD is the file descriptor for the file/stream to be listened to.
480
   For the poll case, MASK is a combination (OR) of
481
   POLLIN, POLLRDNORM, POLLRDBAND, POLLPRI, POLLOUT, POLLWRNORM,
482
   POLLWRBAND: these are the events we are interested in. If any of them
483
   occurs, proc should be called.
484
   For the select case, MASK is a combination of READABLE, WRITABLE, EXCEPTION.
485
   PROC is the procedure that will be called when an event occurs for
486
   FD.  CLIENT_DATA is the argument to pass to PROC. */
487
static void
488
create_file_handler (int fd, int mask, handler_func * proc, gdb_client_data client_data)
489
{
490
  file_handler *file_ptr;
491
 
492
  /* Do we already have a file handler for this file? (We may be
493
     changing its associated procedure). */
494
  for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL;
495
       file_ptr = file_ptr->next_file)
496
    {
497
      if (file_ptr->fd == fd)
498
        break;
499
    }
500
 
501
  /* It is a new file descriptor. Add it to the list. Otherwise, just
502
     change the data associated with it. */
503
  if (file_ptr == NULL)
504
    {
505
      file_ptr = (file_handler *) xmalloc (sizeof (file_handler));
506
      file_ptr->fd = fd;
507
      file_ptr->ready_mask = 0;
508
      file_ptr->next_file = gdb_notifier.first_file_handler;
509
      gdb_notifier.first_file_handler = file_ptr;
510
 
511
      if (use_poll)
512
        {
513
#ifdef HAVE_POLL
514
          gdb_notifier.num_fds++;
515
          if (gdb_notifier.poll_fds)
516
            gdb_notifier.poll_fds =
517
              (struct pollfd *) xrealloc (gdb_notifier.poll_fds,
518
                                          (gdb_notifier.num_fds
519
                                           * sizeof (struct pollfd)));
520
          else
521
            gdb_notifier.poll_fds =
522
              (struct pollfd *) xmalloc (sizeof (struct pollfd));
523
          (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->fd = fd;
524
          (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->events = mask;
525
          (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->revents = 0;
526
#else
527
          internal_error (__FILE__, __LINE__,
528
                          _("use_poll without HAVE_POLL"));
529
#endif /* HAVE_POLL */
530
        }
531
      else
532
        {
533
          if (mask & GDB_READABLE)
534
            FD_SET (fd, &gdb_notifier.check_masks[0]);
535
          else
536
            FD_CLR (fd, &gdb_notifier.check_masks[0]);
537
 
538
          if (mask & GDB_WRITABLE)
539
            FD_SET (fd, &gdb_notifier.check_masks[1]);
540
          else
541
            FD_CLR (fd, &gdb_notifier.check_masks[1]);
542
 
543
          if (mask & GDB_EXCEPTION)
544
            FD_SET (fd, &gdb_notifier.check_masks[2]);
545
          else
546
            FD_CLR (fd, &gdb_notifier.check_masks[2]);
547
 
548
          if (gdb_notifier.num_fds <= fd)
549
            gdb_notifier.num_fds = fd + 1;
550
        }
551
    }
552
 
553
  file_ptr->proc = proc;
554
  file_ptr->client_data = client_data;
555
  file_ptr->mask = mask;
556
}
557
 
558
/* Remove the file descriptor FD from the list of monitored fd's:
559
   i.e. we don't care anymore about events on the FD. */
560
void
561
delete_file_handler (int fd)
562
{
563
  file_handler *file_ptr, *prev_ptr = NULL;
564
  int i;
565
#ifdef HAVE_POLL
566
  int j;
567
  struct pollfd *new_poll_fds;
568
#endif
569
 
570
  /* Find the entry for the given file. */
571
 
572
  for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL;
573
       file_ptr = file_ptr->next_file)
574
    {
575
      if (file_ptr->fd == fd)
576
        break;
577
    }
578
 
579
  if (file_ptr == NULL)
580
    return;
581
 
582
  if (use_poll)
583
    {
584
#ifdef HAVE_POLL
585
      /* Create a new poll_fds array by copying every fd's information but the
586
         one we want to get rid of. */
587
 
588
      new_poll_fds =
589
        (struct pollfd *) xmalloc ((gdb_notifier.num_fds - 1) * sizeof (struct pollfd));
590
 
591
      for (i = 0, j = 0; i < gdb_notifier.num_fds; i++)
592
        {
593
          if ((gdb_notifier.poll_fds + i)->fd != fd)
594
            {
595
              (new_poll_fds + j)->fd = (gdb_notifier.poll_fds + i)->fd;
596
              (new_poll_fds + j)->events = (gdb_notifier.poll_fds + i)->events;
597
              (new_poll_fds + j)->revents = (gdb_notifier.poll_fds + i)->revents;
598
              j++;
599
            }
600
        }
601
      xfree (gdb_notifier.poll_fds);
602
      gdb_notifier.poll_fds = new_poll_fds;
603
      gdb_notifier.num_fds--;
604
#else
605
      internal_error (__FILE__, __LINE__,
606
                      _("use_poll without HAVE_POLL"));
607
#endif /* HAVE_POLL */
608
    }
609
  else
610
    {
611
      if (file_ptr->mask & GDB_READABLE)
612
        FD_CLR (fd, &gdb_notifier.check_masks[0]);
613
      if (file_ptr->mask & GDB_WRITABLE)
614
        FD_CLR (fd, &gdb_notifier.check_masks[1]);
615
      if (file_ptr->mask & GDB_EXCEPTION)
616
        FD_CLR (fd, &gdb_notifier.check_masks[2]);
617
 
618
      /* Find current max fd. */
619
 
620
      if ((fd + 1) == gdb_notifier.num_fds)
621
        {
622
          gdb_notifier.num_fds--;
623
          for (i = gdb_notifier.num_fds; i; i--)
624
            {
625
              if (FD_ISSET (i - 1, &gdb_notifier.check_masks[0])
626
                  || FD_ISSET (i - 1, &gdb_notifier.check_masks[1])
627
                  || FD_ISSET (i - 1, &gdb_notifier.check_masks[2]))
628
                break;
629
            }
630
          gdb_notifier.num_fds = i;
631
        }
632
    }
633
 
634
  /* Deactivate the file descriptor, by clearing its mask,
635
     so that it will not fire again. */
636
 
637
  file_ptr->mask = 0;
638
 
639
  /* Get rid of the file handler in the file handler list. */
640
  if (file_ptr == gdb_notifier.first_file_handler)
641
    gdb_notifier.first_file_handler = file_ptr->next_file;
642
  else
643
    {
644
      for (prev_ptr = gdb_notifier.first_file_handler;
645
           prev_ptr->next_file != file_ptr;
646
           prev_ptr = prev_ptr->next_file)
647
        ;
648
      prev_ptr->next_file = file_ptr->next_file;
649
    }
650
  xfree (file_ptr);
651
}
652
 
653
/* Handle the given event by calling the procedure associated to the
654
   corresponding file handler.  Called by process_event indirectly,
655
   through event_ptr->proc.  EVENT_FILE_DESC is file descriptor of the
656
   event in the front of the event queue. */
657
static void
658
handle_file_event (int event_file_desc)
659
{
660
  file_handler *file_ptr;
661
  int mask;
662
#ifdef HAVE_POLL
663
  int error_mask;
664
  int error_mask_returned;
665
#endif
666
 
667
  /* Search the file handler list to find one that matches the fd in
668
     the event. */
669
  for (file_ptr = gdb_notifier.first_file_handler; file_ptr != NULL;
670
       file_ptr = file_ptr->next_file)
671
    {
672
      if (file_ptr->fd == event_file_desc)
673
        {
674
          /* With poll, the ready_mask could have any of three events
675
             set to 1: POLLHUP, POLLERR, POLLNVAL. These events cannot
676
             be used in the requested event mask (events), but they
677
             can be returned in the return mask (revents). We need to
678
             check for those event too, and add them to the mask which
679
             will be passed to the handler. */
680
 
681
          /* See if the desired events (mask) match the received
682
             events (ready_mask). */
683
 
684
          if (use_poll)
685
            {
686
#ifdef HAVE_POLL
687
              error_mask = POLLHUP | POLLERR | POLLNVAL;
688
              mask = (file_ptr->ready_mask & file_ptr->mask) |
689
                (file_ptr->ready_mask & error_mask);
690
              error_mask_returned = mask & error_mask;
691
 
692
              if (error_mask_returned != 0)
693
                {
694
                  /* Work in progress. We may need to tell somebody what
695
                     kind of error we had. */
696
                  if (error_mask_returned & POLLHUP)
697
                    printf_unfiltered (_("Hangup detected on fd %d\n"), file_ptr->fd);
698
                  if (error_mask_returned & POLLERR)
699
                    printf_unfiltered (_("Error detected on fd %d\n"), file_ptr->fd);
700
                  if (error_mask_returned & POLLNVAL)
701
                    printf_unfiltered (_("Invalid or non-`poll'able fd %d\n"), file_ptr->fd);
702
                  file_ptr->error = 1;
703
                }
704
              else
705
                file_ptr->error = 0;
706
#else
707
              internal_error (__FILE__, __LINE__,
708
                              _("use_poll without HAVE_POLL"));
709
#endif /* HAVE_POLL */
710
            }
711
          else
712
            {
713
              if (file_ptr->ready_mask & GDB_EXCEPTION)
714
                {
715
                  printf_unfiltered (_("Exception condition detected on fd %d\n"), file_ptr->fd);
716
                  file_ptr->error = 1;
717
                }
718
              else
719
                file_ptr->error = 0;
720
              mask = file_ptr->ready_mask & file_ptr->mask;
721
            }
722
 
723
          /* Clear the received events for next time around. */
724
          file_ptr->ready_mask = 0;
725
 
726
          /* If there was a match, then call the handler. */
727
          if (mask != 0)
728
            (*file_ptr->proc) (file_ptr->error, file_ptr->client_data);
729
          break;
730
        }
731
    }
732
}
733
 
734
/* Called by gdb_do_one_event to wait for new events on the
735
   monitored file descriptors. Queue file events as they are
736
   detected by the poll.
737
   If there are no events, this function will block in the
738
   call to poll.
739
   Return -1 if there are no files descriptors to monitor,
740
   otherwise return 0. */
741
static int
742
gdb_wait_for_event (void)
743
{
744
  file_handler *file_ptr;
745
  gdb_event *file_event_ptr;
746
  int num_found = 0;
747
  int i;
748
 
749
  /* Make sure all output is done before getting another event. */
750
  gdb_flush (gdb_stdout);
751
  gdb_flush (gdb_stderr);
752
 
753
  if (gdb_notifier.num_fds == 0)
754
    return -1;
755
 
756
  if (use_poll)
757
    {
758
#ifdef HAVE_POLL
759
      num_found =
760
        poll (gdb_notifier.poll_fds,
761
              (unsigned long) gdb_notifier.num_fds,
762
              gdb_notifier.timeout_valid ? gdb_notifier.poll_timeout : -1);
763
 
764
      /* Don't print anything if we get out of poll because of a
765
         signal. */
766
      if (num_found == -1 && errno != EINTR)
767
        perror_with_name (("poll"));
768
#else
769
      internal_error (__FILE__, __LINE__,
770
                      _("use_poll without HAVE_POLL"));
771
#endif /* HAVE_POLL */
772
    }
773
  else
774
    {
775
      gdb_notifier.ready_masks[0] = gdb_notifier.check_masks[0];
776
      gdb_notifier.ready_masks[1] = gdb_notifier.check_masks[1];
777
      gdb_notifier.ready_masks[2] = gdb_notifier.check_masks[2];
778
      num_found = gdb_select (gdb_notifier.num_fds,
779
                              &gdb_notifier.ready_masks[0],
780
                              &gdb_notifier.ready_masks[1],
781
                              &gdb_notifier.ready_masks[2],
782
                              gdb_notifier.timeout_valid
783
                              ? &gdb_notifier.select_timeout : NULL);
784
 
785
      /* Clear the masks after an error from select. */
786
      if (num_found == -1)
787
        {
788
          FD_ZERO (&gdb_notifier.ready_masks[0]);
789
          FD_ZERO (&gdb_notifier.ready_masks[1]);
790
          FD_ZERO (&gdb_notifier.ready_masks[2]);
791
          /* Dont print anything is we got a signal, let gdb handle it. */
792
          if (errno != EINTR)
793
            perror_with_name (("select"));
794
        }
795
    }
796
 
797
  /* Enqueue all detected file events. */
798
 
799
  if (use_poll)
800
    {
801
#ifdef HAVE_POLL
802
      for (i = 0; (i < gdb_notifier.num_fds) && (num_found > 0); i++)
803
        {
804
          if ((gdb_notifier.poll_fds + i)->revents)
805
            num_found--;
806
          else
807
            continue;
808
 
809
          for (file_ptr = gdb_notifier.first_file_handler;
810
               file_ptr != NULL;
811
               file_ptr = file_ptr->next_file)
812
            {
813
              if (file_ptr->fd == (gdb_notifier.poll_fds + i)->fd)
814
                break;
815
            }
816
 
817
          if (file_ptr)
818
            {
819
              /* Enqueue an event only if this is still a new event for
820
                 this fd. */
821
              if (file_ptr->ready_mask == 0)
822
                {
823
                  file_event_ptr = create_file_event (file_ptr->fd);
824
                  async_queue_event (file_event_ptr, TAIL);
825
                }
826
              file_ptr->ready_mask = (gdb_notifier.poll_fds + i)->revents;
827
            }
828
        }
829
#else
830
      internal_error (__FILE__, __LINE__,
831
                      _("use_poll without HAVE_POLL"));
832
#endif /* HAVE_POLL */
833
    }
834
  else
835
    {
836
      for (file_ptr = gdb_notifier.first_file_handler;
837
           (file_ptr != NULL) && (num_found > 0);
838
           file_ptr = file_ptr->next_file)
839
        {
840
          int mask = 0;
841
 
842
          if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[0]))
843
            mask |= GDB_READABLE;
844
          if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[1]))
845
            mask |= GDB_WRITABLE;
846
          if (FD_ISSET (file_ptr->fd, &gdb_notifier.ready_masks[2]))
847
            mask |= GDB_EXCEPTION;
848
 
849
          if (!mask)
850
            continue;
851
          else
852
            num_found--;
853
 
854
          /* Enqueue an event only if this is still a new event for
855
             this fd. */
856
 
857
          if (file_ptr->ready_mask == 0)
858
            {
859
              file_event_ptr = create_file_event (file_ptr->fd);
860
              async_queue_event (file_event_ptr, TAIL);
861
            }
862
          file_ptr->ready_mask = mask;
863
        }
864
    }
865
  return 0;
866
}
867
 
868
 
869
/* Create an asynchronous handler, allocating memory for it.
870
   Return a pointer to the newly created handler.
871
   This pointer will be used to invoke the handler by
872
   invoke_async_signal_handler.
873
   PROC is the function to call with CLIENT_DATA argument
874
   whenever the handler is invoked. */
875
async_signal_handler *
876
create_async_signal_handler (sig_handler_func * proc, gdb_client_data client_data)
877
{
878
  async_signal_handler *async_handler_ptr;
879
 
880
  async_handler_ptr =
881
    (async_signal_handler *) xmalloc (sizeof (async_signal_handler));
882
  async_handler_ptr->ready = 0;
883
  async_handler_ptr->next_handler = NULL;
884
  async_handler_ptr->proc = proc;
885
  async_handler_ptr->client_data = client_data;
886
  if (sighandler_list.first_handler == NULL)
887
    sighandler_list.first_handler = async_handler_ptr;
888
  else
889
    sighandler_list.last_handler->next_handler = async_handler_ptr;
890
  sighandler_list.last_handler = async_handler_ptr;
891
  return async_handler_ptr;
892
}
893
 
894
/* Mark the handler (ASYNC_HANDLER_PTR) as ready. This information will
895
   be used when the handlers are invoked, after we have waited for
896
   some event.  The caller of this function is the interrupt handler
897
   associated with a signal. */
898
void
899
mark_async_signal_handler (async_signal_handler * async_handler_ptr)
900
{
901
  ((async_signal_handler *) async_handler_ptr)->ready = 1;
902
  async_handler_ready = 1;
903
}
904
 
905
/* Call all the handlers that are ready. */
906
static void
907
invoke_async_signal_handler (void)
908
{
909
  async_signal_handler *async_handler_ptr;
910
 
911
  if (async_handler_ready == 0)
912
    return;
913
  async_handler_ready = 0;
914
 
915
  /* Invoke ready handlers. */
916
 
917
  while (1)
918
    {
919
      for (async_handler_ptr = sighandler_list.first_handler;
920
           async_handler_ptr != NULL;
921
           async_handler_ptr = async_handler_ptr->next_handler)
922
        {
923
          if (async_handler_ptr->ready)
924
            break;
925
        }
926
      if (async_handler_ptr == NULL)
927
        break;
928
      async_handler_ptr->ready = 0;
929
      (*async_handler_ptr->proc) (async_handler_ptr->client_data);
930
    }
931
 
932
  return;
933
}
934
 
935
/* Delete an asynchronous handler (ASYNC_HANDLER_PTR).
936
   Free the space allocated for it.  */
937
void
938
delete_async_signal_handler (async_signal_handler ** async_handler_ptr)
939
{
940
  async_signal_handler *prev_ptr;
941
 
942
  if (sighandler_list.first_handler == (*async_handler_ptr))
943
    {
944
      sighandler_list.first_handler = (*async_handler_ptr)->next_handler;
945
      if (sighandler_list.first_handler == NULL)
946
        sighandler_list.last_handler = NULL;
947
    }
948
  else
949
    {
950
      prev_ptr = sighandler_list.first_handler;
951
      while (prev_ptr && prev_ptr->next_handler != (*async_handler_ptr))
952
        prev_ptr = prev_ptr->next_handler;
953
      prev_ptr->next_handler = (*async_handler_ptr)->next_handler;
954
      if (sighandler_list.last_handler == (*async_handler_ptr))
955
        sighandler_list.last_handler = prev_ptr;
956
    }
957
  xfree ((*async_handler_ptr));
958
  (*async_handler_ptr) = NULL;
959
}
960
 
961
/* Is it necessary to call invoke_async_signal_handler? */
962
static int
963
check_async_ready (void)
964
{
965
  return async_handler_ready;
966
}
967
 
968
/* Create a timer that will expire in MILLISECONDS from now. When the
969
   timer is ready, PROC will be executed. At creation, the timer is
970
   aded to the timers queue.  This queue is kept sorted in order of
971
   increasing timers. Return a handle to the timer struct. */
972
int
973
create_timer (int milliseconds, timer_handler_func * proc, gdb_client_data client_data)
974
{
975
  struct gdb_timer *timer_ptr, *timer_index, *prev_timer;
976
  struct timeval time_now, delta;
977
 
978
  /* compute seconds */
979
  delta.tv_sec = milliseconds / 1000;
980
  /* compute microseconds */
981
  delta.tv_usec = (milliseconds % 1000) * 1000;
982
 
983
  gettimeofday (&time_now, NULL);
984
 
985
  timer_ptr = (struct gdb_timer *) xmalloc (sizeof (gdb_timer));
986
  timer_ptr->when.tv_sec = time_now.tv_sec + delta.tv_sec;
987
  timer_ptr->when.tv_usec = time_now.tv_usec + delta.tv_usec;
988
  /* carry? */
989
  if (timer_ptr->when.tv_usec >= 1000000)
990
    {
991
      timer_ptr->when.tv_sec += 1;
992
      timer_ptr->when.tv_usec -= 1000000;
993
    }
994
  timer_ptr->proc = proc;
995
  timer_ptr->client_data = client_data;
996
  timer_list.num_timers++;
997
  timer_ptr->timer_id = timer_list.num_timers;
998
 
999
  /* Now add the timer to the timer queue, making sure it is sorted in
1000
     increasing order of expiration. */
1001
 
1002
  for (timer_index = timer_list.first_timer;
1003
       timer_index != NULL;
1004
       timer_index = timer_index->next)
1005
    {
1006
      /* If the seconds field is greater or if it is the same, but the
1007
         microsecond field is greater. */
1008
      if ((timer_index->when.tv_sec > timer_ptr->when.tv_sec) ||
1009
          ((timer_index->when.tv_sec == timer_ptr->when.tv_sec)
1010
           && (timer_index->when.tv_usec > timer_ptr->when.tv_usec)))
1011
        break;
1012
    }
1013
 
1014
  if (timer_index == timer_list.first_timer)
1015
    {
1016
      timer_ptr->next = timer_list.first_timer;
1017
      timer_list.first_timer = timer_ptr;
1018
 
1019
    }
1020
  else
1021
    {
1022
      for (prev_timer = timer_list.first_timer;
1023
           prev_timer->next != timer_index;
1024
           prev_timer = prev_timer->next)
1025
        ;
1026
 
1027
      prev_timer->next = timer_ptr;
1028
      timer_ptr->next = timer_index;
1029
    }
1030
 
1031
  gdb_notifier.timeout_valid = 0;
1032
  return timer_ptr->timer_id;
1033
}
1034
 
1035
/* There is a chance that the creator of the timer wants to get rid of
1036
   it before it expires. */
1037
void
1038
delete_timer (int id)
1039
{
1040
  struct gdb_timer *timer_ptr, *prev_timer = NULL;
1041
 
1042
  /* Find the entry for the given timer. */
1043
 
1044
  for (timer_ptr = timer_list.first_timer; timer_ptr != NULL;
1045
       timer_ptr = timer_ptr->next)
1046
    {
1047
      if (timer_ptr->timer_id == id)
1048
        break;
1049
    }
1050
 
1051
  if (timer_ptr == NULL)
1052
    return;
1053
  /* Get rid of the timer in the timer list. */
1054
  if (timer_ptr == timer_list.first_timer)
1055
    timer_list.first_timer = timer_ptr->next;
1056
  else
1057
    {
1058
      for (prev_timer = timer_list.first_timer;
1059
           prev_timer->next != timer_ptr;
1060
           prev_timer = prev_timer->next)
1061
        ;
1062
      prev_timer->next = timer_ptr->next;
1063
    }
1064
  xfree (timer_ptr);
1065
 
1066
  gdb_notifier.timeout_valid = 0;
1067
}
1068
 
1069
/* When a timer event is put on the event queue, it will be handled by
1070
   this function.  Just call the assiciated procedure and delete the
1071
   timer event from the event queue. Repeat this for each timer that
1072
   has expired. */
1073
static void
1074
handle_timer_event (int dummy)
1075
{
1076
  struct timeval time_now;
1077
  struct gdb_timer *timer_ptr, *saved_timer;
1078
 
1079
  gettimeofday (&time_now, NULL);
1080
  timer_ptr = timer_list.first_timer;
1081
 
1082
  while (timer_ptr != NULL)
1083
    {
1084
      if ((timer_ptr->when.tv_sec > time_now.tv_sec) ||
1085
          ((timer_ptr->when.tv_sec == time_now.tv_sec) &&
1086
           (timer_ptr->when.tv_usec > time_now.tv_usec)))
1087
        break;
1088
 
1089
      /* Get rid of the timer from the beginning of the list. */
1090
      timer_list.first_timer = timer_ptr->next;
1091
      saved_timer = timer_ptr;
1092
      timer_ptr = timer_ptr->next;
1093
      /* Call the procedure associated with that timer. */
1094
      (*saved_timer->proc) (saved_timer->client_data);
1095
      xfree (saved_timer);
1096
    }
1097
 
1098
  gdb_notifier.timeout_valid = 0;
1099
}
1100
 
1101
/* Check whether any timers in the timers queue are ready. If at least
1102
   one timer is ready, stick an event onto the event queue.  Even in
1103
   case more than one timer is ready, one event is enough, because the
1104
   handle_timer_event() will go through the timers list and call the
1105
   procedures associated with all that have expired. Update the
1106
   timeout for the select() or poll() as well. */
1107
static void
1108
poll_timers (void)
1109
{
1110
  struct timeval time_now, delta;
1111
  gdb_event *event_ptr;
1112
 
1113
  if (timer_list.first_timer != NULL)
1114
    {
1115
      gettimeofday (&time_now, NULL);
1116
      delta.tv_sec = timer_list.first_timer->when.tv_sec - time_now.tv_sec;
1117
      delta.tv_usec = timer_list.first_timer->when.tv_usec - time_now.tv_usec;
1118
      /* borrow? */
1119
      if (delta.tv_usec < 0)
1120
        {
1121
          delta.tv_sec -= 1;
1122
          delta.tv_usec += 1000000;
1123
        }
1124
 
1125
      /* Oops it expired already. Tell select / poll to return
1126
         immediately. (Cannot simply test if delta.tv_sec is negative
1127
         because time_t might be unsigned.)  */
1128
      if (timer_list.first_timer->when.tv_sec < time_now.tv_sec
1129
          || (timer_list.first_timer->when.tv_sec == time_now.tv_sec
1130
              && timer_list.first_timer->when.tv_usec < time_now.tv_usec))
1131
        {
1132
          delta.tv_sec = 0;
1133
          delta.tv_usec = 0;
1134
        }
1135
 
1136
      if (delta.tv_sec == 0 && delta.tv_usec == 0)
1137
        {
1138
          event_ptr = (gdb_event *) xmalloc (sizeof (gdb_event));
1139
          event_ptr->proc = handle_timer_event;
1140
          event_ptr->fd = timer_list.first_timer->timer_id;
1141
          async_queue_event (event_ptr, TAIL);
1142
        }
1143
 
1144
      /* Now we need to update the timeout for select/ poll, because we
1145
         don't want to sit there while this timer is expiring. */
1146
      if (use_poll)
1147
        {
1148
#ifdef HAVE_POLL
1149
          gdb_notifier.poll_timeout = delta.tv_sec * 1000;
1150
#else
1151
          internal_error (__FILE__, __LINE__,
1152
                          _("use_poll without HAVE_POLL"));
1153
#endif /* HAVE_POLL */
1154
        }
1155
      else
1156
        {
1157
          gdb_notifier.select_timeout.tv_sec = delta.tv_sec;
1158
          gdb_notifier.select_timeout.tv_usec = delta.tv_usec;
1159
        }
1160
      gdb_notifier.timeout_valid = 1;
1161
    }
1162
  else
1163
    gdb_notifier.timeout_valid = 0;
1164
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.