src/base/pollevent.cc

   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
  29 #include <sys/ioctl.h>
  30 #include <sys/types.h>
  31
  32 #include <fcntl.h>
  33 #include <signal.h>
  34 #include <unistd.h>
  35
  36 #include "sim/async.hh"
  37 #include "sim/host.hh"
  38 #include "base/misc.hh"
  39 #include "base/pollevent.hh"
  40 #include "sim/root.hh"
  41 #include "sim/serialize.hh"
  42
  43 using namespace std;
  44
  45 PollQueue pollQueue;
  46
  47 /////////////////////////////////////////////////////
  48 //
  49 PollEvent::PollEvent(int _fd, int _events)
  50     : queue(NULL), enabled(true)
  51 {
  52     pfd.fd = _fd;
  53     pfd.events = _events;
  54 }
  55
  56 PollEvent::~PollEvent()
  57 {
  58     if (queue)
  59         queue->remove(this);
  60 }
  61
  62 void
  63 PollEvent::disable()
  64 {
  65     if (!enabled) return;
  66     enabled = false;
  67
  68     if (queue)
  69         queue->copy();
  70 }
  71
  72 void
  73 PollEvent::enable()
  74 {
  75     if (enabled) return;
  76     enabled = true;
  77
  78     if (queue)
  79         queue->copy();
  80 }
  81
  82 void
  83 PollEvent::serialize(ostream &os)
  84 {
  85     SERIALIZE_SCALAR(pfd.fd);
  86     SERIALIZE_SCALAR(pfd.events);
  87     SERIALIZE_SCALAR(enabled);
  88 }
  89
  90 void
  91 PollEvent::unserialize(Checkpoint *cp, const std::string &section)
  92 {
  93     UNSERIALIZE_SCALAR(pfd.fd);
  94     UNSERIALIZE_SCALAR(pfd.events);
  95     UNSERIALIZE_SCALAR(enabled);
  96 }
  97
  98 /////////////////////////////////////////////////////
  99 //
 100 PollQueue::PollQueue()
 101     : poll_fds(NULL), max_size(0), num_fds(0)
 102 { }
 103
 104 PollQueue::~PollQueue()
 105 {
 106     removeHandler();
 107     for (int i = 0; i < num_fds; i++)
 108         setupAsyncIO(poll_fds[0].fd, false);
 109
 110     delete [] poll_fds;
 111 }
 112
 113 void
 114 PollQueue::copy()
 115 {
 116     eventvec_t::iterator i = events.begin();
 117     eventvec_t::iterator end = events.end();
 118
 119     num_fds = 0;
 120
 121     while (i < end) {
 122         if ((*i)->enabled)
 123             poll_fds[num_fds++] = (*i)->pfd;
 124         ++i;
 125     }
 126 }
 127
 128 void
 129 PollQueue::remove(PollEvent *event)
 130 {
 131     eventvec_t::iterator i = events.begin();
 132     eventvec_t::iterator end = events.end();
 133
 134     while (i < end) {
 135         if (*i == event) {
 136            events.erase(i);
 137            copy();
 138            event->queue = NULL;
 139            return;
 140         }
 141
 142         ++i;
 143     }
 144
 145     panic("Event does not exist.  Cannot remove.");
 146 }
 147
 148 void
 149 PollQueue::schedule(PollEvent *event)
 150 {
 151     if (event->queue)
 152         panic("Event already scheduled!");
 153
 154     event->queue = this;
 155     events.push_back(event);
 156     setupAsyncIO(event->pfd.fd, true);
 157
 158     // if we ran out of space in the fd array, double the capacity
 159     // if this is the first time that we've scheduled an event, create
 160     // the array with an initial size of 16
 161     if (++num_fds > max_size) {
 162         if (max_size > 0) {
 163             delete [] poll_fds;
 164             max_size *= 2;
 165         } else {
 166             max_size = 16;
 167             setupHandler();
 168         }
 169
 170         poll_fds = new pollfd[max_size];
 171     }
 172
 173     copy();
 174 }
 175
 176 void
 177 PollQueue::service()
 178 {
 179     int ret = poll(poll_fds, num_fds, 0);
 180
 181     if (ret <= 0)
 182         return;
 183
 184     for (int i = 0; i < num_fds; i++) {
 185         int revents = poll_fds[i].revents;
 186         if (revents) {
 187             events[i]->process(revents);
 188             if (--ret <= 0)
 189                 break;
 190         }
 191     }
 192 }
 193
 194 struct sigaction PollQueue::oldio;
 195 struct sigaction PollQueue::oldalrm;
 196 bool PollQueue::handler = false;
 197
 198 void
 199 PollQueue::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 (fcntl(fd, F_SETFL, flags) == -1)
 211         panic("Could not set up async IO");
 212
 213     if (set) {
 214       if (fcntl(fd, F_SETOWN, getpid()) == -1)
 215         panic("Could not set up async IO");
 216     }
 217 }
 218
 219 void
 220 PollQueue::setupHandler()
 221 {
 222     struct sigaction act;
 223
 224     act.sa_handler = handleIO;
 225     sigemptyset(&act.sa_mask);
 226     act.sa_flags = SA_RESTART;
 227
 228     if (sigaction(SIGIO, &act, &oldio) == -1)
 229         panic("could not do sigaction");
 230
 231     act.sa_handler = handleALRM;
 232     sigemptyset(&act.sa_mask);
 233     act.sa_flags = SA_RESTART;
 234
 235     if (sigaction(SIGALRM, &act, &oldalrm) == -1)
 236         panic("could not do sigaction");
 237
 238     alarm(1);
 239
 240     handler = true;
 241 }
 242
 243 void
 244 PollQueue::removeHandler()
 245 {
 246     if (sigaction(SIGIO, &oldio, NULL) == -1)
 247         panic("could not remove handler");
 248
 249     if (sigaction(SIGIO, &oldalrm, NULL) == -1)
 250         panic("could not remove handler");
 251 }
 252
 253 void
 254 PollQueue::handleIO(int sig)
 255 {
 256     if (sig != SIGIO)
 257         panic("Wrong Handler");
 258
 259     async_event = true;
 260     async_io = true;
 261 }
 262
 263 void
 264 PollQueue::handleALRM(int sig)
 265 {
 266     if (sig != SIGALRM)
 267         panic("Wrong Handler");
 268
 269     async_event = true;
 270     async_alarm = true;
 271     alarm(1);
 272 }
 273