fd_entry.hh revision 11856
1/* 2 * Copyright (c) 2016 Advanced Micro Devices, Inc. 3 * All rights reserved. 4 * 5 * For use for simulation and test purposes only 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions are met: 9 * 10 * 1. Redistributions of source code must retain the above copyright notice, 11 * this list of conditions and the following disclaimer. 12 * 13 * 2. Redistributions in binary form must reproduce the above copyright notice, 14 * this list of conditions and the following disclaimer in the documentation 15 * and/or other materials provided with the distribution. 16 * 17 * 3. Neither the name of the copyright holder nor the names of its 18 * contributors may be used to endorse or promote products derived from this 19 * software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 25 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 31 * POSSIBILITY OF SUCH DAMAGE. 32 * 33 * Author: Brandon Potter 34 */ 35 36#ifndef __FD_ENTRY_HH__ 37#define __FD_ENTRY_HH__ 38 39#include <memory> 40#include <ostream> 41#include <string> 42 43#include "sim/serialize.hh" 44 45class EmulatedDriver; 46 47/** 48 * Holds a single file descriptor mapping and that mapping's data for 49 * processes running in syscall emulation mode. 50 */ 51class FDEntry : public Serializable 52{ 53 public: 54 FDEntry(bool close_on_exec = false) 55 : _closeOnExec(close_on_exec) 56 { } 57 58 virtual std::shared_ptr<FDEntry> clone() const = 0; 59 60 inline bool getCOE() const { return _closeOnExec; } 61 62 inline void setCOE(bool close_on_exec) { _closeOnExec = close_on_exec; } 63 64 virtual void serialize(CheckpointOut &cp) const; 65 virtual void unserialize(CheckpointIn &cp); 66 67 protected: 68 bool _closeOnExec; 69}; 70 71/** 72 * Extends the base class to include a host-backed file descriptor field 73 * that records the integer used to represent the file descriptor on the host 74 * and the file's flags. 75 */ 76class HBFDEntry: public FDEntry 77{ 78 public: 79 HBFDEntry(int flags, int sim_fd, bool close_on_exec = false) 80 : FDEntry(close_on_exec), _flags(flags), _simFD(sim_fd) 81 { } 82 83 inline int getFlags() const { return _flags; } 84 inline int getSimFD() const { return _simFD; } 85 86 inline void setFlags(int flags) { _flags = flags; } 87 inline void setSimFD(int sim_fd) { _simFD = sim_fd; } 88 89 protected: 90 int _flags; 91 int _simFD; 92}; 93 94/** 95 * Holds file descriptors for host-backed files; host-backed files are 96 * files which were opened on the physical machine where the simulation 97 * is running (probably the thing on/under your desk). All regular files 98 * are redirected to make it appear that the file descriptor assignment 99 * starts at file descriptor '3' (not including stdin, stdout, stderr) and 100 * then grows upward. 101 */ 102class FileFDEntry: public HBFDEntry 103{ 104 public: 105 FileFDEntry(int sim_fd, int flags, std::string const& file_name, 106 uint64_t file_offset, bool close_on_exec = false) 107 : HBFDEntry(flags, sim_fd, close_on_exec), 108 _fileName(file_name), _fileOffset(file_offset) 109 { } 110 111 FileFDEntry(FileFDEntry const& reg, bool close_on_exec = false) 112 : HBFDEntry(reg._flags, reg._simFD, close_on_exec), 113 _fileName(reg._fileName), _fileOffset(reg._fileOffset) 114 { } 115 116 inline std::shared_ptr<FDEntry> 117 clone() const override 118 { 119 return std::make_shared<FileFDEntry>(*this); 120 } 121 122 inline std::string getFileName() const { return _fileName; } 123 inline uint64_t getFileOffset() const { return _fileOffset; } 124 125 inline void setFileName(std::string file_name) { _fileName = file_name; } 126 inline void setFileOffset (uint64_t f_off) { _fileOffset = f_off; } 127 128 void serialize(CheckpointOut &cp) const override; 129 void unserialize(CheckpointIn &cp) override; 130 131 private: 132 std::string _fileName; 133 uint64_t _fileOffset; 134}; 135 136/** 137 * Holds the metadata needed to maintain the mappings for file descriptors 138 * allocated with the pipe() system calls and its variants. 139 */ 140class PipeFDEntry: public HBFDEntry 141{ 142 public: 143 enum EndType { 144 read = 0, 145 write = 1 146 }; 147 148 PipeFDEntry(int sim_fd, int flags, EndType pipe_end_type, 149 bool close_on_exec = false) 150 : HBFDEntry(flags, sim_fd, close_on_exec), _pipeReadSource(-1), 151 _pipeEndType(pipe_end_type) 152 { } 153 154 PipeFDEntry(PipeFDEntry const& pipe, bool close_on_exec = false) 155 : HBFDEntry(pipe._flags, pipe._simFD, close_on_exec), 156 _pipeReadSource(pipe._pipeReadSource), 157 _pipeEndType(pipe._pipeEndType) 158 { } 159 160 inline std::shared_ptr<FDEntry> 161 clone() const override 162 { 163 return std::make_shared<PipeFDEntry>(*this); 164 } 165 166 inline EndType getEndType() const { return _pipeEndType; } 167 inline int getPipeReadSource() const { return _pipeReadSource; } 168 169 inline void setPipeReadSource(int tgt_fd) { _pipeReadSource = tgt_fd; } 170 inline void setEndType(EndType type) { _pipeEndType = type; } 171 172 void serialize(CheckpointOut &cp) const override; 173 void unserialize(CheckpointIn &cp) override; 174 175 private: 176 int _pipeReadSource; 177 EndType _pipeEndType; 178}; 179 180/** 181 * Holds file descriptors needed to simulate devices opened with pseudo 182 * files (commonly with calls to ioctls). 183 */ 184class DeviceFDEntry : public FDEntry 185{ 186 public: 187 DeviceFDEntry(EmulatedDriver *driver, std::string const& file_name, 188 bool close_on_exec = false) 189 : FDEntry(close_on_exec), _driver(driver), _fileName(file_name) 190 { } 191 192 DeviceFDEntry(DeviceFDEntry const& dev, bool close_on_exec = false) 193 : FDEntry(close_on_exec), _driver(dev._driver), 194 _fileName(dev._fileName) 195 { } 196 197 std::shared_ptr<FDEntry> 198 clone() const override 199 { 200 return std::make_shared<DeviceFDEntry>(*this); 201 } 202 203 inline EmulatedDriver *getDriver() const { return _driver; } 204 inline std::string getFileName() const { return _fileName; } 205 206 void serialize(CheckpointOut &cp) const override; 207 void unserialize(CheckpointIn &cp) override; 208 209 private: 210 EmulatedDriver *_driver; 211 std::string _fileName; 212}; 213 214#endif // __FD_ENTRY_HH__ 215