syscall_emul_buf.hh revision 10497
1/* 2 * Copyright (c) 2003-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: Steve Reinhardt 29 */ 30 31#ifndef __SIM_SYSCALL_EMUL_BUF_HH__ 32#define __SIM_SYSCALL_EMUL_BUF_HH__ 33 34/// 35/// @file syscall_emul_buf.hh 36/// 37/// This file defines buffer classes used to handle pointer arguments 38/// in emulated syscalls. 39 40#include <cstring> 41 42#include "base/types.hh" 43#include "mem/se_translating_port_proxy.hh" 44 45/** 46 * Base class for BufferArg and TypedBufferArg, Not intended to be 47 * used directly. 48 * 49 * The BufferArg classes represent buffers in target user space that 50 * are passed by reference to an (emulated) system call. Each 51 * instance provides an internal (simulator-space) buffer of the 52 * appropriate size and tracks the user-space address. The copyIn() 53 * and copyOut() methods copy the user-space buffer to and from the 54 * simulator-space buffer, respectively. 55 */ 56class BaseBufferArg { 57 58 public: 59 60 /** 61 * Allocate a buffer of size 'size' representing the memory at 62 * target address 'addr'. 63 */ 64 BaseBufferArg(Addr _addr, int _size) 65 : addr(_addr), size(_size), bufPtr(new uint8_t[size]) 66 { 67 // clear out buffer: in case we only partially populate this, 68 // and then do a copyOut(), we want to make sure we don't 69 // introduce any random junk into the simulated address space 70 memset(bufPtr, 0, size); 71 } 72 73 virtual ~BaseBufferArg() { delete [] bufPtr; } 74 75 /** 76 * copy data into simulator space (read from target memory) 77 */ 78 virtual bool copyIn(SETranslatingPortProxy &memproxy) 79 { 80 memproxy.readBlob(addr, bufPtr, size); 81 return true; // no EFAULT detection for now 82 } 83 84 /** 85 * copy data out of simulator space (write to target memory) 86 */ 87 virtual bool copyOut(SETranslatingPortProxy &memproxy) 88 { 89 memproxy.writeBlob(addr, bufPtr, size); 90 return true; // no EFAULT detection for now 91 } 92 93 protected: 94 const Addr addr; ///< address of buffer in target address space 95 const int size; ///< buffer size 96 uint8_t * const bufPtr; ///< pointer to buffer in simulator space 97}; 98 99/** 100 * BufferArg represents an untyped buffer in target user space that is 101 * passed by reference to an (emulated) system call. 102 */ 103class BufferArg : public BaseBufferArg 104{ 105 public: 106 /** 107 * Allocate a buffer of size 'size' representing the memory at 108 * target address 'addr'. 109 */ 110 BufferArg(Addr _addr, int _size) : BaseBufferArg(_addr, _size) { } 111 112 /** 113 * Return a pointer to the internal simulator-space buffer. 114 */ 115 void *bufferPtr() { return bufPtr; } 116}; 117 118/** 119 * TypedBufferArg is a class template; instances of this template 120 * represent typed buffers in target user space that are passed by 121 * reference to an (emulated) system call. 122 * 123 * This template provides operator overloads for convenience, allowing 124 * for example the use of '->' to reference fields within a struct 125 * type. 126 */ 127template <class T> 128class TypedBufferArg : public BaseBufferArg 129{ 130 public: 131 /** 132 * Allocate a buffer of type T representing the memory at target 133 * address 'addr'. The user can optionally specify a specific 134 * number of bytes to allocate to deal with structs that have 135 * variable-size arrays at the end. 136 */ 137 TypedBufferArg(Addr _addr, int _size = sizeof(T)) 138 : BaseBufferArg(_addr, _size) 139 { } 140 141 /** 142 * Convert TypedBufferArg<T> to a pointer to T that points to the 143 * internal buffer. 144 */ 145 operator T*() { return (T *)bufPtr; } 146 147 /** 148 * Convert TypedBufferArg<T> to a reference to T that references the 149 * internal buffer value. 150 */ 151 T &operator*() { return *((T *)bufPtr); } 152 153 154 /** 155 * Enable the use of '->' to reference fields where T is a struct 156 * type. 157 */ 158 T* operator->() { return (T *)bufPtr; } 159 160 /** 161 * Enable the use of '[]' to reference fields where T is an array 162 * type. 163 */ 164 T &operator[](int i) { return ((T *)bufPtr)[i]; } 165}; 166 167 168#endif // __SIM_SYSCALL_EMUL_BUF_HH__ 169