pollevent.cc revision 9990 
1/*
2 * Copyright (c) 2002-2005 The Regents of The University of Michigan
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;
9 * redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution;
12 * neither the name of the copyright holders nor the names of its
13 * contributors may be used to endorse or promote products derived from
14 * this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * Authors: Nathan Binkert
29 */
30
31#include <sys/ioctl.h>
32#include <sys/types.h>
33#if defined(__sun__) || defined(__SUNPRO_CC)
34#include <sys/file.h>
35#endif
36
37#include <fcntl.h>
38#include <unistd.h>
39
40#include <csignal>
41
42#include "base/misc.hh"
43#include "base/pollevent.hh"
44#include "base/types.hh"
45#include "sim/async.hh"
46#include "sim/core.hh"
47#include "sim/serialize.hh"
48
49using namespace std;
50
51PollQueue pollQueue;
52
53/////////////////////////////////////////////////////
54//
55PollEvent::PollEvent(int _fd, int _events)
56    : queue(NULL), enabled(true)
57{
58    pfd.fd = _fd;
59    pfd.events = _events;
60}
61
62PollEvent::~PollEvent()
63{
64    if (queue)
65        queue->remove(this);
66}
67
68void
69PollEvent::disable()
70{
71    if (!enabled) return;
72    enabled = false;
73
74    if (queue)
75        queue->copy();
76}
77
78void
79PollEvent::enable()
80{
81    if (enabled) return;
82    enabled = true;
83
84    if (queue)
85        queue->copy();
86}
87
88void
89PollEvent::serialize(ostream &os)
90{
91    SERIALIZE_SCALAR(pfd.fd);
92    SERIALIZE_SCALAR(pfd.events);
93    SERIALIZE_SCALAR(enabled);
94}
95
96void
97PollEvent::unserialize(Checkpoint *cp, const std::string &section)
98{
99    UNSERIALIZE_SCALAR(pfd.fd);
100    UNSERIALIZE_SCALAR(pfd.events);
101    UNSERIALIZE_SCALAR(enabled);
102}
103
104/////////////////////////////////////////////////////
105//
106PollQueue::PollQueue()
107    : poll_fds(NULL), max_size(0), num_fds(0)
108{ }
109
110PollQueue::~PollQueue()
111{
112    for (int i = 0; i < num_fds; i++)
113        setupAsyncIO(poll_fds[0].fd, false);
114
115    delete [] poll_fds;
116}
117
118void
119PollQueue::copy()
120{
121    eventvec_t::iterator i = events.begin();
122    eventvec_t::iterator end = events.end();
123
124    num_fds = 0;
125
126    while (i < end) {
127        if ((*i)->enabled)
128            poll_fds[num_fds++] = (*i)->pfd;
129        ++i;
130    }
131}
132
133void
134PollQueue::remove(PollEvent *event)
135{
136    eventvec_t::iterator i = events.begin();
137    eventvec_t::iterator end = events.end();
138
139    while (i < end) {
140        if (*i == event) {
141           events.erase(i);
142           copy();
143           event->queue = NULL;
144           return;
145        }
146
147        ++i;
148    }
149
150    panic("Event does not exist.  Cannot remove.");
151}
152
153void
154PollQueue::schedule(PollEvent *event)
155{
156    if (event->queue)
157        panic("Event already scheduled!");
158
159    event->queue = this;
160    events.push_back(event);
161    setupAsyncIO(event->pfd.fd, true);
162
163    // if we ran out of space in the fd array, double the capacity
164    // if this is the first time that we've scheduled an event, create
165    // the array with an initial size of 16
166    if (++num_fds > max_size) {
167        if (max_size > 0) {
168            delete [] poll_fds;
169            max_size *= 2;
170        } else {
171            max_size = 16;
172        }
173
174        poll_fds = new pollfd[max_size];
175    }
176
177    copy();
178}
179
180void
181PollQueue::service()
182{
183    int ret = poll(poll_fds, num_fds, 0);
184
185    if (ret <= 0)
186        return;
187
188    for (int i = 0; i < num_fds; i++) {
189        int revents = poll_fds[i].revents;
190        if (revents) {
191            events[i]->process(revents);
192            if (--ret <= 0)
193                break;
194        }
195    }
196}
197
198void
199PollQueue::setupAsyncIO(int fd, bool set)
200{
201    int flags = fcntl(fd, F_GETFL);
202    if (flags == -1)
203        panic("Could not set up async IO");
204
205    if (set)
206        flags |= FASYNC;
207    else
208        flags &= ~(FASYNC);
209
210    if (set) {
211      if (fcntl(fd, F_SETOWN, getpid()) == -1)
212        panic("Could not set up async IO");
213    }
214
215    if (fcntl(fd, F_SETFL, flags) == -1)
216        panic("Could not set up async IO");
217
218    // The file descriptor might already have events pending. We won't
219    // see them if they occurred before we set the FASYNC
220    // flag. Simulate a SIGIO to ensure that the FD will be polled in
221    // next iteration of the simulation loop. We could just poll it,
222    // but this is much simpler.
223    if (set) {
224        async_event = true;
225        async_io = true;
226    }
227}
228