Mercurial > hg > truffle
annotate agent/src/os/win32/IOBuf.hpp @ 3917:eca1193ca245
4965777: GC changes to support use of discovered field for pending references
Summary: If and when the reference handler thread is able to use the discovered field to link reference objects in its pending list, so will GC. In that case, GC will scan through this field once a reference object has been placed on the pending list, but not scan that field before that stage, as the field is used by the concurrent GC thread to link discovered objects. When ReferenceHandleR thread does not use the discovered field for the purpose of linking the elements in the pending list, as would be the case in older JDKs, the JVM will fall back to the old behaviour of using the next field for that purpose.
Reviewed-by: jcoomes, mchung, stefank
| author | ysr |
|---|---|
| date | Wed, 07 Sep 2011 13:55:42 -0700 |
| parents | c18cbe5936b8 |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
2 * Copyright (c) 2000, 2003, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 25 #ifndef _IO_BUF_ | |
| 26 #define _IO_BUF_ | |
| 27 | |
| 28 // This file is currently used for os/solaris/agent/ too. At some point in time | |
| 29 // the source will be reorganized to avoid these ifdefs. | |
| 30 // Note that this class can read/write from a file as well as a socket. This | |
| 31 // file capability is only implemented on win32. | |
| 32 | |
| 33 #ifdef WIN32 | |
| 34 #include <winsock2.h> | |
| 35 #else | |
| 36 #include <sys/types.h> | |
| 37 #include <sys/socket.h> | |
| 38 // These are from win32 winsock2.h | |
| 39 typedef unsigned int SOCKET; | |
| 40 typedef void * HANDLE; | |
| 41 typedef unsigned long DWORD; | |
| 42 #define INVALID_SOCKET (SOCKET)(~0) | |
| 43 #endif | |
| 44 | |
| 45 #include <vector> | |
| 46 #include "Buffer.hpp" | |
| 47 | |
| 48 /** Manages an input/output buffer pair for a socket or file handle. */ | |
| 49 class IOBuf { | |
| 50 public: | |
| 51 IOBuf(int inBufLen, int outBufLen); | |
| 52 ~IOBuf(); | |
| 53 | |
| 54 enum ReadLineResult { | |
| 55 RL_GOT_DATA, | |
| 56 RL_NO_DATA, | |
| 57 RL_ERROR | |
| 58 }; | |
| 59 | |
| 60 /** Change the socket with which this buffer is associated */ | |
| 61 void setSocket(SOCKET sock); | |
| 62 | |
| 63 // Reading/writing files is only supported on windows. | |
| 64 #ifdef WIN32 | |
| 65 /** Change the output file handle with which this buffer is | |
| 66 associated. Currently IOBufs can not be used to read from a file | |
| 67 handle. */ | |
| 68 void setOutputFileHandle(HANDLE handle); | |
| 69 #endif | |
| 70 | |
| 71 /** Reset the input and output buffers, without flushing the output | |
| 72 data to the socket */ | |
| 73 void reset(); | |
| 74 | |
| 75 /** Try to read a line of data from the given socket without | |
| 76 blocking. If was able to read a complete line of data, returns a | |
| 77 character pointer to the beginning of the (null-terminated) | |
| 78 string. If not, returns NULL, but maintains enough state that | |
| 79 subsequent calls to tryReadLine() will not ignore the data | |
| 80 already read. NOTE: this skips end-of-line characters (typically | |
| 81 CR/LF) as defined by "isEOL()". When switching back and forth | |
| 82 between binary and text modes, to be sure no data is lost, pad | |
| 83 the beginning and end of the binary transmission with bytes | |
| 84 which can not be confused with these characters. */ | |
| 85 ReadLineResult tryReadLine(); | |
| 86 | |
| 87 /** Read a line of data from the given socket, blocking until a | |
| 88 line, including EOL, appears. Return the line, or NULL if | |
| 89 something goes wrong. */ | |
| 90 char *readLine(); | |
| 91 | |
| 92 /** Get the pointer to the beginning of the (null-terminated) line. | |
| 93 This should only be called if tryReadLine() has returned | |
| 94 RL_GOT_DATA. This sets the "parsing cursor" to the beginning of | |
| 95 the line. */ | |
| 96 char* getLine(); | |
| 97 | |
| 98 // NOTE: any further data-acquisition routines must ALWAYS call | |
| 99 // fixupData() at the beginning! | |
| 100 | |
| 101 //---------------------------------------------------------------------- | |
| 102 // Output routines | |
| 103 // | |
| 104 | |
| 105 /** Flush the output buffer to the socket. Returns true if | |
| 106 succeeded, false if write error occurred. */ | |
| 107 bool flush(); | |
| 108 | |
| 109 /** Write the given string to the output buffer. May flush if output | |
| 110 buffer becomes too full to store the data. Not guaranteed to | |
| 111 work if string is longer than the size of the output buffer. | |
| 112 Does not include the null terminator of the string. Returns true | |
| 113 if succeeded, false if write error occurred. */ | |
| 114 bool writeString(const char* str); | |
| 115 | |
| 116 /** Write the given int to the output buffer. May flush if output | |
| 117 buffer becomes too full to store the data. Returns true if | |
| 118 succeeded, false if write error occurred. */ | |
| 119 bool writeInt(int val); | |
| 120 | |
| 121 /** Write the given unsigned int to the output buffer. May flush if | |
| 122 output buffer becomes too full to store the data. Returns true | |
| 123 if succeeded, false if write error occurred. */ | |
| 124 bool writeUnsignedInt(unsigned int val); | |
| 125 | |
| 126 /** Write the given boolean to the output buffer. May flush if | |
| 127 output buffer becomes too full to store the data. Returns true | |
| 128 if succeeded, false if write error occurred. */ | |
| 129 bool writeBoolAsInt(bool val); | |
| 130 | |
| 131 /** Write the given address to the output buffer. May flush if | |
| 132 output buffer becomes too full to store the data. Returns true | |
| 133 if succeeded, false if write error occurred. */ | |
| 134 bool writeAddress(void* val); | |
| 135 | |
| 136 /** Writes a space to the output buffer. May flush if output buffer | |
| 137 becomes too full to store the data. Returns true if succeeded, | |
| 138 false if write error occurred. */ | |
| 139 bool writeSpace(); | |
| 140 | |
| 141 /** Writes an end-of-line sequence to the output buffer. May flush | |
| 142 if output buffer becomes too full to store the data. Returns | |
| 143 true if succeeded, false if write error occurred. */ | |
| 144 bool writeEOL(); | |
| 145 | |
| 146 /** Writes a binary character to the output buffer. */ | |
| 147 bool writeBinChar(char c); | |
| 148 | |
| 149 /** Writes a binary unsigned short in network (big-endian) byte | |
| 150 order to the output buffer. */ | |
| 151 bool writeBinUnsignedShort(unsigned short i); | |
| 152 | |
| 153 /** Writes a binary unsigned int in network (big-endian) byte order | |
| 154 to the output buffer. */ | |
| 155 bool writeBinUnsignedInt(unsigned int i); | |
| 156 | |
| 157 /** Writes a binary buffer to the output buffer. */ | |
| 158 bool writeBinBuf(char* buf, int size); | |
| 159 | |
| 160 #ifdef WIN32 | |
| 161 enum FillState { | |
| 162 DONE = 1, | |
| 163 MORE_DATA_PENDING = 2, | |
| 164 FAILED = 3 | |
| 165 }; | |
| 166 | |
| 167 /** Very specialized routine; fill the output buffer from the given | |
| 168 file handle. Caller is responsible for ensuring that there is | |
| 169 data to be read on the file handle. */ | |
| 170 FillState fillFromFileHandle(HANDLE fh, DWORD* numRead); | |
| 171 #endif | |
| 172 | |
| 173 /** Binary utility routine (for poke) */ | |
| 174 static bool isBinEscapeChar(char c); | |
| 175 | |
| 176 private: | |
| 177 IOBuf(const IOBuf&); | |
| 178 IOBuf& operator=(const IOBuf&); | |
| 179 | |
| 180 // Returns -1 if non-blocking and no data available | |
| 181 int readChar(bool block); | |
| 182 // Line-oriented reading | |
| 183 std::vector<char> curLine; | |
| 184 bool gotDataLastTime; | |
| 185 | |
| 186 ReadLineResult doReadLine(bool); | |
| 187 | |
| 188 bool flushImpl(bool moreDataToCome); | |
| 189 | |
| 190 SOCKET fd; | |
| 191 HANDLE outHandle; | |
| 192 bool usingSocket; | |
| 193 | |
| 194 // Buffers | |
| 195 Buffer* inBuf; | |
| 196 Buffer* outBuf; | |
| 197 | |
| 198 // Simple finite-state machine to handle binary data | |
| 199 enum State { | |
| 200 TEXT_STATE, | |
| 201 BIN_STATE, | |
| 202 EOL_STATE | |
| 203 }; | |
| 204 enum Action { | |
| 205 NO_ACTION, | |
| 206 GOT_LINE, // TEXT_STATE -> EOL_STATE transition | |
| 207 SKIP_EOL_CHAR // EOL_STATE -> EOL_STATE transition | |
| 208 }; | |
| 209 | |
| 210 State state; | |
| 211 Action processChar(char c); | |
| 212 | |
| 213 // Handling incoming binary buffers (poke command) | |
| 214 int binPos; // Number of binary characters read so far; | |
| 215 // total number to read is binLength + 4 | |
| 216 int binLength; // Number of binary characters in message; | |
| 217 // not valid until binPos >= 4 | |
| 218 | |
| 219 bool isEOL(char c); | |
| 220 }; | |
| 221 | |
| 222 #endif // #defined _IO_BUF_ |