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  * Authors: Nathan Binkert
  29  */
  30
  31 #include <sys/ioctl.h>
  32 #include <sys/types.h>
  33
  34 #if defined(__sun__) || defined(__SUNPRO_CC)
  35 #include <sys/file.h>
  36
  37 #endif
  38
  39 #include "base/pollevent.hh"
  40
  41 #include <fcntl.h>
  42 #include <unistd.h>
  43
  44 #include <csignal>
  45
  46 #include "base/misc.hh"
  47 #include "base/types.hh"
  48 #include "sim/async.hh"
  49 #include "sim/core.hh"
  50 #include "sim/eventq.hh"
  51 #include "sim/serialize.hh"
  52
  53 using namespace std;
  54
  55 PollQueue pollQueue;
  56
  57 /////////////////////////////////////////////////////
  58 //
  59 PollEvent::PollEvent(int _fd, int _events)
  60     : queue(NULL), enabled(true)
  61 {
  62     pfd.fd = _fd;
  63     pfd.events = _events;
  64     pfd.revents = 0;
  65 }
  66
  67 PollEvent::~PollEvent()
  68 {
  69     if (queue)
  70         queue->remove(this);
  71 }
  72
  73 void
  74 PollEvent::disable()
  75 {
  76     if (!enabled) return;
  77     enabled = false;
  78
  79     if (queue)
  80         queue->copy();
  81 }
  82
  83 void
  84 PollEvent::enable()
  85 {
  86     if (enabled) return;
  87     enabled = true;
  88
  89     if (queue)
  90         queue->copy();
  91 }
  92
  93 void
  94 PollEvent::serialize(CheckpointOut &cp) const
  95 {
  96     SERIALIZE_SCALAR(pfd.fd);
  97     SERIALIZE_SCALAR(pfd.events);
  98     SERIALIZE_SCALAR(enabled);
  99 }
 100
 101 void
 102 PollEvent::unserialize(CheckpointIn &cp)
 103 {
 104     UNSERIALIZE_SCALAR(pfd.fd);
 105     UNSERIALIZE_SCALAR(pfd.events);
 106     UNSERIALIZE_SCALAR(enabled);
 107 }
 108
 109 /////////////////////////////////////////////////////
 110 //
 111 PollQueue::PollQueue()
 112     : poll_fds(NULL), max_size(0), num_fds(0)
 113 { }
 114
 115 PollQueue::~PollQueue()
 116 {
 117     for (int i = 0; i < num_fds; i++)
 118         setupAsyncIO(poll_fds[0].fd, false);
 119
 120     delete [] poll_fds;
 121 }
 122
 123 void
 124 PollQueue::copy()
 125 {
 126     eventvec_t::iterator i = events.begin();
 127     eventvec_t::iterator end = events.end();
 128
 129     num_fds = 0;
 130
 131     while (i < end) {
 132         if ((*i)->enabled)
 133             poll_fds[num_fds++] = (*i)->pfd;
 134         ++i;
 135     }
 136 }
 137
 138 void
 139 PollQueue::remove(PollEvent *event)
 140 {
 141     eventvec_t::iterator i = events.begin();
 142     eventvec_t::iterator end = events.end();
 143
 144     while (i < end) {
 145         if (*i == event) {
 146            events.erase(i);
 147            copy();
 148            event->queue = NULL;
 149            return;
 150         }
 151
 152         ++i;
 153     }
 154
 155     panic("Event does not exist.  Cannot remove.");
 156 }
 157
 158 void
 159 PollQueue::schedule(PollEvent *event)
 160 {
 161     if (event->queue)
 162         panic("Event already scheduled!");
 163
 164     event->queue = this;
 165     events.push_back(event);
 166     setupAsyncIO(event->pfd.fd, true);
 167
 168     // if we ran out of space in the fd array, double the capacity
 169     // if this is the first time that we've scheduled an event, create
 170     // the array with an initial size of 16
 171     if (++num_fds > max_size) {
 172         if (max_size > 0) {
 173             delete [] poll_fds;
 174             max_size *= 2;
 175         } else {
 176             max_size = 16;
 177         }
 178
 179         poll_fds = new pollfd[max_size];
 180     }
 181
 182     copy();
 183 }
 184
 185 void
 186 PollQueue::service()
 187 {
 188     int ret = poll(poll_fds, num_fds, 0);
 189
 190     if (ret <= 0)
 191         return;
 192
 193     for (int i = 0; i < num_fds; i++) {
 194         int revents = poll_fds[i].revents;
 195         if (revents) {
 196             events[i]->process(revents);
 197             if (--ret <= 0)
 198                 break;
 199         }
 200     }
 201 }
 202
 203 void
 204 PollQueue::setupAsyncIO(int fd, bool set)
 205 {
 206     int flags = fcntl(fd, F_GETFL);
 207     if (flags == -1)
 208         panic("Could not set up async IO");
 209
 210     if (set)
 211         flags |= FASYNC;
 212     else
 213         flags &= ~(FASYNC);
 214
 215     if (set) {
 216       if (fcntl(fd, F_SETOWN, getpid()) == -1)
 217         panic("Could not set up async IO");
 218     }
 219
 220     if (fcntl(fd, F_SETFL, flags) == -1)
 221         panic("Could not set up async IO");
 222
 223     // The file descriptor might already have events pending. We won't
 224     // see them if they occurred before we set the FASYNC
 225     // flag. Simulate a SIGIO to ensure that the FD will be polled in
 226     // next iteration of the simulation loop. We could just poll it,
 227     // but this is much simpler.
 228     if (set) {
 229         async_event = true;
 230         async_io = true;
 231         /* Wake up some event queue to handle event */
 232         getEventQueue(0)->wakeup();
 233     }
 234 }