1 /* 2 * Copyright 2005-2008, Axel Dörfler, axeld@pinc-software.de. 3 * Distributed under the terms of the MIT License. 4 */ 5 6 7 #include "ring_buffer.h" 8 9 #include <KernelExport.h> 10 #if 0 11 #include <port.h> 12 #endif 13 14 #include <stdlib.h> 15 #include <string.h> 16 #include <sys/uio.h> 17 18 #ifndef HAIKU_TARGET_PLATFORM_HAIKU 19 #define user_memcpy(x...) (memcpy(x), B_OK) 20 #endif 21 22 /*! This is a light-weight ring_buffer implementation. 23 * It does not provide any locking - you are supposed to ensure thread-safety 24 * with the restrictions you choose. Unless you are passing in unsafe buffers, 25 * the functions are safe to be called with interrupts turned off as well (not 26 * the user functions). 27 * They also don't use malloc() or any kind of locking after initialization. 28 */ 29 30 31 static inline int32 32 space_left_in_buffer(struct ring_buffer *buffer) 33 { 34 return buffer->size - buffer->in; 35 } 36 37 38 static ssize_t 39 read_from_buffer(struct ring_buffer *buffer, uint8 *data, ssize_t length, 40 bool user) 41 { 42 int32 available = buffer->in; 43 44 if (length > available) 45 length = available; 46 47 if (length == 0) 48 return 0; 49 50 ssize_t bytesRead = length; 51 52 if (buffer->first + length <= buffer->size) { 53 // simple copy 54 if (user) { 55 if (user_memcpy(data, buffer->buffer + buffer->first, length) < B_OK) 56 return B_BAD_ADDRESS; 57 } else 58 memcpy(data, buffer->buffer + buffer->first, length); 59 } else { 60 // need to copy both ends 61 size_t upper = buffer->size - buffer->first; 62 size_t lower = length - upper; 63 64 if (user) { 65 if (user_memcpy(data, buffer->buffer + buffer->first, upper) < B_OK 66 || user_memcpy(data + upper, buffer->buffer, lower) < B_OK) 67 return B_BAD_ADDRESS; 68 } else { 69 memcpy(data, buffer->buffer + buffer->first, upper); 70 memcpy(data + upper, buffer->buffer, lower); 71 } 72 } 73 74 buffer->first = (buffer->first + bytesRead) % buffer->size; 75 buffer->in -= bytesRead; 76 77 return bytesRead; 78 } 79 80 81 static ssize_t 82 write_to_buffer(struct ring_buffer *buffer, const uint8 *data, ssize_t length, 83 bool user) 84 { 85 int32 left = space_left_in_buffer(buffer); 86 if (length > left) 87 length = left; 88 89 if (length == 0) 90 return 0; 91 92 ssize_t bytesWritten = length; 93 int32 position = (buffer->first + buffer->in) % buffer->size; 94 95 if (position + length <= buffer->size) { 96 // simple copy 97 if (user) { 98 if (user_memcpy(buffer->buffer + position, data, length) < B_OK) 99 return B_BAD_ADDRESS; 100 } else 101 memcpy(buffer->buffer + position, data, length); 102 } else { 103 // need to copy both ends 104 size_t upper = buffer->size - position; 105 size_t lower = length - upper; 106 107 if (user) { 108 if (user_memcpy(buffer->buffer + position, data, upper) < B_OK 109 || user_memcpy(buffer->buffer, data + upper, lower) < B_OK) 110 return B_BAD_ADDRESS; 111 } else { 112 memcpy(buffer->buffer + position, data, upper); 113 memcpy(buffer->buffer, data + upper, lower); 114 } 115 } 116 117 buffer->in += bytesWritten; 118 119 return bytesWritten; 120 } 121 122 123 // #pragma mark - 124 125 126 struct ring_buffer* 127 create_ring_buffer(size_t size) 128 { 129 return create_ring_buffer_etc(NULL, size, 0); 130 } 131 132 133 struct ring_buffer* 134 create_ring_buffer_etc(void* memory, size_t size, uint32 flags) 135 { 136 if (memory == NULL) { 137 ring_buffer* buffer = (ring_buffer*)malloc(sizeof(ring_buffer) + size); 138 if (buffer == NULL) 139 return NULL; 140 141 buffer->size = size; 142 ring_buffer_clear(buffer); 143 144 return buffer; 145 } 146 147 size -= sizeof(ring_buffer); 148 ring_buffer* buffer = (ring_buffer*)memory; 149 150 buffer->size = size; 151 if ((flags & RING_BUFFER_INIT_FROM_BUFFER) != 0 152 && (size_t)buffer->size == size 153 && buffer->in >= 0 && (size_t)buffer->in <= size 154 && buffer->first >= 0 && (size_t)buffer->first < size) { 155 // structure looks valid 156 } else 157 ring_buffer_clear(buffer); 158 159 return buffer; 160 } 161 162 163 void 164 delete_ring_buffer(struct ring_buffer *buffer) 165 { 166 free(buffer); 167 } 168 169 170 void 171 ring_buffer_clear(struct ring_buffer *buffer) 172 { 173 buffer->in = 0; 174 buffer->first = 0; 175 } 176 177 178 size_t 179 ring_buffer_readable(struct ring_buffer *buffer) 180 { 181 return buffer->in; 182 } 183 184 185 size_t 186 ring_buffer_writable(struct ring_buffer *buffer) 187 { 188 return buffer->size - buffer->in; 189 } 190 191 192 void 193 ring_buffer_flush(struct ring_buffer *buffer, size_t length) 194 { 195 // we can't flush more bytes than there are 196 if (length > (size_t)buffer->in) 197 length = buffer->in; 198 199 buffer->in -= length; 200 buffer->first = (buffer->first + length) % buffer->size; 201 } 202 203 204 size_t 205 ring_buffer_read(struct ring_buffer *buffer, uint8 *data, ssize_t length) 206 { 207 return read_from_buffer(buffer, data, length, false); 208 } 209 210 211 size_t 212 ring_buffer_write(struct ring_buffer *buffer, const uint8 *data, ssize_t length) 213 { 214 return write_to_buffer(buffer, data, length, false); 215 } 216 217 218 ssize_t 219 ring_buffer_user_read(struct ring_buffer *buffer, uint8 *data, ssize_t length) 220 { 221 return read_from_buffer(buffer, data, length, true); 222 } 223 224 225 ssize_t 226 ring_buffer_user_write(struct ring_buffer *buffer, const uint8 *data, ssize_t length) 227 { 228 return write_to_buffer(buffer, data, length, true); 229 } 230 231 232 /*! Reads data from the ring buffer, but doesn't remove the data from it. 233 \param buffer The ring buffer. 234 \param offset The offset relative to the beginning of the data in the ring 235 buffer at which to start reading. 236 \param data The buffer to which to copy the data. 237 \param length The number of bytes to read at maximum. 238 \return The number of bytes actually read from the buffer. 239 */ 240 size_t 241 ring_buffer_peek(struct ring_buffer* buffer, size_t offset, void* data, 242 size_t length) 243 { 244 size_t available = buffer->in; 245 246 if (offset >= available || length == 0) 247 return 0; 248 249 if (offset + length > available) 250 length = available - offset; 251 252 if ((offset += buffer->first) >= (size_t)buffer->size) 253 offset -= buffer->size; 254 255 if (offset + length <= (size_t)buffer->size) { 256 // simple copy 257 memcpy(data, buffer->buffer + offset, length); 258 } else { 259 // need to copy both ends 260 size_t upper = buffer->size - offset; 261 size_t lower = length - upper; 262 263 memcpy(data, buffer->buffer + offset, upper); 264 memcpy((uint8*)data + upper, buffer->buffer, lower); 265 } 266 267 return length; 268 } 269 270 271 /*! Returns iovecs describing the contents of the ring buffer. 272 273 \param buffer The ring buffer. 274 \param vecs Pointer to an iovec array with at least 2 elements to be filled 275 in by the function. 276 \return The number of iovecs the function has filled in to describe the 277 contents of the ring buffer. \c 0, if empty, \c 2 at maximum. 278 */ 279 int32 280 ring_buffer_get_vecs(struct ring_buffer* buffer, struct iovec* vecs) 281 { 282 if (buffer->in == 0) 283 return 0; 284 285 if (buffer->first + buffer->in <= buffer->size) { 286 // one element 287 vecs[0].iov_base = buffer->buffer + buffer->first; 288 vecs[0].iov_len = buffer->in; 289 return 1; 290 } 291 292 // two elements 293 size_t upper = buffer->size - buffer->first; 294 size_t lower = buffer->in - upper; 295 296 vecs[0].iov_base = buffer->buffer + buffer->first; 297 vecs[0].iov_len = upper; 298 vecs[1].iov_base = buffer->buffer; 299 vecs[1].iov_len = lower; 300 301 return 2; 302 } 303 304 305 #if 0 306 /** Sends the contents of the ring buffer to a port. 307 * The buffer will be empty afterwards only if sending the data actually works. 308 */ 309 310 status_t 311 ring_buffer_write_to_port(struct ring_buffer *buffer, port_id port, int32 code, 312 uint32 flags, bigtime_t timeout) 313 { 314 int32 length = buffer->in; 315 if (length == 0) 316 return B_OK; 317 318 status_t status; 319 320 if (buffer->first + length <= buffer->size) { 321 // simple write 322 status = write_port_etc(port, code, buffer->buffer + buffer->first, length, 323 flags, timeout); 324 } else { 325 // need to write both ends 326 size_t upper = buffer->size - buffer->first; 327 size_t lower = length - upper; 328 329 iovec vecs[2]; 330 vecs[0].iov_base = buffer->buffer + buffer->first; 331 vecs[0].iov_len = upper; 332 vecs[1].iov_base = buffer->buffer; 333 vecs[1].iov_len = lower; 334 335 status = writev_port_etc(port, code, vecs, 2, length, flags, timeout); 336 } 337 338 if (status < B_OK) 339 return status; 340 341 buffer->first = (buffer->first + length) % buffer->size; 342 buffer->in -= length; 343 344 return status; 345 } 346 #endif 347