Lines Matching refs:buffer
44 // maximum implementation derived buffer size is 65536
132 // TODO: we should think about moving the address fields into the buffer
158 static status_t append_data(net_buffer* buffer, const void* data, size_t size);
186 NetBufferTraceEntry(net_buffer* buffer)
188 fBuffer(buffer)
213 Create(size_t headerSpace, net_buffer* buffer)
215 NetBufferTraceEntry(buffer),
223 out.Print("net buffer create: header space: %lu -> buffer: %p",
234 Free(net_buffer* buffer)
236 NetBufferTraceEntry(buffer)
243 out.Print("net buffer free: buffer: %p", fBuffer);
250 Duplicate(net_buffer* buffer, net_buffer* clone)
252 NetBufferTraceEntry(buffer),
260 out.Print("net buffer dup: buffer: %p -> %p", fBuffer, fClone);
270 Clone(net_buffer* buffer, bool shareFreeSpace, net_buffer* clone)
272 NetBufferTraceEntry(buffer),
281 out.Print("net buffer clone: buffer: %p, share free space: %s "
293 Split(net_buffer* buffer, uint32 offset, net_buffer* newBuffer)
295 NetBufferTraceEntry(buffer),
304 out.Print("net buffer split: buffer: %p, offset: %lu "
316 Merge(net_buffer* buffer, net_buffer* otherBuffer, bool after)
318 NetBufferTraceEntry(buffer),
327 out.Print("net buffer merge: buffers: %p + %p, after: %s "
340 AppendCloned(net_buffer* buffer, net_buffer* source, uint32 offset,
343 NetBufferTraceEntry(buffer),
353 out.Print("net buffer append cloned: buffer: %p, from: %p, "
366 PrependSize(net_buffer* buffer, size_t size)
368 NetBufferTraceEntry(buffer),
376 out.Print("net buffer prepend size: buffer: %p, size: %lu", fBuffer,
387 AppendSize(net_buffer* buffer, size_t size)
389 NetBufferTraceEntry(buffer),
397 out.Print("net buffer append size: buffer: %p, size: %lu", fBuffer,
408 RemoveHeader(net_buffer* buffer, size_t size)
410 NetBufferTraceEntry(buffer),
418 out.Print("net buffer remove header: buffer: %p, size: %lu",
429 Trim(net_buffer* buffer, size_t size)
431 NetBufferTraceEntry(buffer),
439 out.Print("net buffer trim: buffer: %p, size: %lu",
450 Read(net_buffer* buffer, uint32 offset, void* data, size_t size)
452 NetBufferTraceEntry(buffer),
462 out.Print("net buffer read: buffer: %p, offset: %lu, size: %lu, "
475 Write(net_buffer* buffer, uint32 offset, const void* data, size_t size)
477 NetBufferTraceEntry(buffer),
487 out.Print("net buffer write: buffer: %p, offset: %lu, size: %lu, "
524 out.Print("net buffer data header create: header: %p", fHeader);
541 out.Print("net buffer data header acquire: header: %p "
562 out.Print("net buffer data header release: header: %p "
598 char buffer[64];
600 buffer, sizeof(buffer), true);
602 dprintf(" %s: %s\n", prefix, buffer);
610 net_buffer_private* buffer = (net_buffer_private*)_buffer;
612 dprintf("buffer %p, size %" B_PRIu32 ", flags %" B_PRIx32 ", stored header "
613 "%" B_PRIuSIZE ", interface address %p\n", buffer, buffer->size,
614 buffer->flags, buffer->stored_header_length, buffer->interface_address);
616 dump_address("source", buffer->source, buffer->interface_address);
617 dump_address("destination", buffer->destination, buffer->interface_address);
620 while ((node = (data_node*)list_get_next_item(&buffer->buffers, node))
627 dump_block((char*)node->start - buffer->stored_header_length,
628 min_c(buffer->stored_header_length, 64), " s ");
671 net_buffer_private* buffer = (net_buffer_private*)_buffer;
676 data_node* node = (data_node*)list_get_first_item(&buffer->buffers);
680 buffer, node, node->offset, size);
684 node = (data_node*)list_get_next_item(&buffer->buffers, node);
687 if (size != buffer->size) {
689 buffer, buffer->size, size);
697 check_buffer_contents(net_buffer* buffer, size_t offset, const void* data,
704 if (read_data(buffer, offset, bufferData, size) == B_OK) {
710 "%ld, buffer: %p, offset: %lu, size: %lu", index, buffer,
714 panic("failed to read from buffer %p, offset: %lu, size: %lu",
715 buffer, offset, size);
723 check_buffer_contents(net_buffer* buffer, size_t offset, net_buffer* source,
731 check_buffer_contents(buffer, offset, bufferData, size);
733 panic("failed to read from source buffer %p, offset: %lu, size: %lu",
742 # define CHECK_BUFFER(buffer) check_buffer(buffer)
744 # define CHECK_BUFFER(buffer) do {} while (false)
790 free_net_buffer(net_buffer_private* buffer)
793 if (buffer != NULL)
796 object_cache_free(sNetBufferCache, buffer, 0);
910 alloc_data_header_space(net_buffer_private* buffer, size_t size,
914 uint8* allocated = alloc_data_header_space(buffer->allocation_header, size);
916 // not enough header space left -- create a fresh buffer for headers
923 release_data_header(buffer->allocation_header);
924 buffer->allocation_header = header;
928 allocated = alloc_data_header_space(buffer->allocation_header, size);
932 *_header = buffer->allocation_header;
964 add_data_node(net_buffer_private* buffer, data_header* header)
967 data_node* node = (data_node*)alloc_data_header_space(buffer,
996 // this is the first node of a buffer (i.e. the header is an allocation
1013 get_node_at_offset(net_buffer_private* buffer, size_t offset)
1015 data_node* node = (data_node*)list_get_first_item(&buffer->buffers);
1017 node = (data_node*)list_get_next_item(&buffer->buffers, node);
1024 \a to net_buffer. The source buffer will remain unchanged.
1093 net_buffer_private* buffer = allocate_net_buffer();
1094 if (buffer == NULL)
1097 TRACE(("%d: create buffer %p\n", find_thread(NULL), buffer));
1108 free_net_buffer(buffer);
1111 buffer->allocation_header = header;
1115 list_init(&buffer->buffers);
1116 list_add_item(&buffer->buffers, node);
1118 buffer->ancillary_data = NULL;
1119 buffer->stored_header_length = 0;
1121 buffer->source = (sockaddr*)&buffer->storage.source;
1122 buffer->destination = (sockaddr*)&buffer->storage.destination;
1124 buffer->storage.source.ss_len = 0;
1125 buffer->storage.destination.ss_len = 0;
1127 buffer->interface_address = NULL;
1128 buffer->offset = 0;
1129 buffer->flags = 0;
1130 buffer->size = 0;
1132 CHECK_BUFFER(buffer);
1133 CREATE_PARANOIA_CHECK_SET(buffer, "net_buffer");
1134 SET_PARANOIA_CHECK(PARANOIA_SUSPICIOUS, buffer, &buffer->size,
1135 sizeof(buffer->size));
1137 T(Create(headerSpace, buffer));
1139 return buffer;
1146 net_buffer_private* buffer = (net_buffer_private*)_buffer;
1148 TRACE(("%d: free buffer %p\n", find_thread(NULL), buffer));
1149 T(Free(buffer));
1151 CHECK_BUFFER(buffer);
1152 DELETE_PARANOIA_CHECK_SET(buffer);
1155 = (data_node*)list_remove_head_item(&buffer->buffers)) {
1159 delete_ancillary_data_container(buffer->ancillary_data);
1161 release_data_header(buffer->allocation_header);
1163 if (buffer->interface_address != NULL)
1164 ((InterfaceAddress*)buffer->interface_address)->ReleaseReference();
1166 free_net_buffer(buffer);
1170 /*! Creates a duplicate of the \a buffer. The new buffer does not share internal
1176 net_buffer_private* buffer = (net_buffer_private*)_buffer;
1178 ParanoiaChecker _(buffer);
1180 TRACE(("%d: duplicate_buffer(buffer %p)\n", find_thread(NULL), buffer));
1191 // copy the data from the source buffer
1193 data_node* node = (data_node*)list_get_first_item(&buffer->buffers);
1197 CHECK_BUFFER(buffer);
1201 node = (data_node*)list_get_next_item(&buffer->buffers, node);
1204 copy_metadata(duplicate, buffer);
1206 ASSERT(duplicate->size == buffer->size);
1207 CHECK_BUFFER(buffer);
1211 T(Duplicate(buffer, duplicate));
1217 /*! Clones the buffer by grabbing another reference to the underlying data.
1220 If \a shareFreeSpace is \c true, the cloned buffer may claim the free
1221 space in the original buffer as the original buffer can still do. If you
1229 // probably place cloned nodes on a header not belonging to our buffer, if
1233 net_buffer_private* buffer = (net_buffer_private*)_buffer;
1239 if (append_cloned_data(clone, buffer, 0, buffer->size) != B_OK) {
1244 copy_metadata(clone, buffer);
1245 ASSERT(clone->size == buffer->size);
1250 ParanoiaChecker _(buffer);
1252 TRACE(("%d: clone_buffer(buffer %p)\n", find_thread(NULL), buffer));
1258 TRACE(("%d: clone: %p\n", find_thread(NULL), buffer));
1260 data_node* sourceNode = (data_node*)list_get_first_item(&buffer->buffers);
1271 // grab reference to this buffer - all additional nodes will get
1290 // the free space stays with the original buffer
1299 sourceNode = (data_node*)list_get_next_item(&buffer->buffers,
1306 // There was not enough space left for another node in this buffer
1308 panic("clone buffer hits size limit... (fix me)");
1314 copy_metadata(clone, buffer);
1316 ASSERT(clone->size == buffer->size);
1320 CHECK_BUFFER(buffer);
1323 T(Clone(buffer, shareFreeSpace, clone));
1330 /*! Split the buffer at offset, the header data
1331 is returned as new buffer.
1336 net_buffer* buffer = create_buffer(DATA_NODE_SIZE);
1337 if (buffer == NULL)
1340 copy_metadata(buffer, from);
1343 ParanoiaChecker _2(buffer);
1345 TRACE(("%d: split_buffer(buffer %p -> %p, offset %" B_PRIu32 ")\n",
1346 find_thread(NULL), from, buffer, offset));
1348 if (append_data_from_buffer(buffer, from, offset) == B_OK) {
1351 CHECK_BUFFER(buffer);
1352 T(Split(from, offset, buffer));
1353 return buffer;
1357 free_buffer(buffer);
1363 /*! Merges the second buffer with the first. If \a after is \c true, the
1364 second buffer's contents will be appended to the first ones, else they
1366 The second buffer will be freed if this function succeeds.
1371 net_buffer_private* buffer = (net_buffer_private*)_buffer;
1376 TRACE(("%d: merge buffer %p with %p (%s)\n", find_thread(NULL), buffer,
1378 T(Merge(buffer, with, after));
1379 //dump_buffer(buffer);
1383 ParanoiaChecker _(buffer);
1384 CHECK_BUFFER(buffer);
1396 // change offset of all nodes already in the buffer
1399 node = (data_node*)list_get_next_item(&buffer->buffers, node);
1418 // The node is already in the buffer, we can just move it
1424 data_node* newNode = add_data_node(buffer, node->header);
1433 // the old node will get freed with its buffer
1437 list_add_item(&buffer->buffers, node);
1438 node->offset = buffer->size;
1440 list_insert_item_before(&buffer->buffers, before, node);
1442 buffer->size += node->used;
1445 SET_PARANOIA_CHECK(PARANOIA_SUSPICIOUS, buffer, &buffer->size,
1446 sizeof(buffer->size));
1452 //dump_buffer(buffer);
1453 CHECK_BUFFER(buffer);
1466 net_buffer_private* buffer = (net_buffer_private*)_buffer;
1468 T(Write(buffer, offset, data, size));
1470 ParanoiaChecker _(buffer);
1472 if (offset + size > buffer->size)
1478 data_node* node = get_node_at_offset(buffer, offset);
1499 node = (data_node*)list_get_next_item(&buffer->buffers, node);
1504 CHECK_BUFFER(buffer);
1513 net_buffer_private* buffer = (net_buffer_private*)_buffer;
1515 T(Read(buffer, offset, data, size));
1517 ParanoiaChecker _(buffer);
1519 if (offset + size > buffer->size)
1525 data_node* node = get_node_at_offset(buffer, offset);
1546 node = (data_node*)list_get_next_item(&buffer->buffers, node);
1551 CHECK_BUFFER(buffer);
1560 net_buffer_private* buffer = (net_buffer_private*)_buffer;
1561 data_node* node = (data_node*)list_get_first_item(&buffer->buffers);
1563 node = add_first_data_node(buffer->allocation_header);
1568 T(PrependSize(buffer, size));
1570 ParanoiaChecker _(buffer);
1572 TRACE(("%d: prepend_size(buffer %p, size %ld) [has %u]\n",
1573 find_thread(NULL), buffer, size, node->HeaderSpace()));
1574 //dump_buffer(buffer);
1578 node->AddHeaderSpace(buffer->stored_header_length);
1580 buffer->stored_header_length = 0;
1593 remove_header(buffer, sizePrepended);
1601 list_insert_item_before(&buffer->buffers, previous, node);
1621 while ((node = (data_node*)list_get_next_item(&buffer->buffers,
1630 // the data fits into this buffer
1639 while ((node = (data_node*)list_get_next_item(&buffer->buffers, node))
1645 buffer->size += size;
1647 SET_PARANOIA_CHECK(PARANOIA_SUSPICIOUS, buffer, &buffer->size,
1648 sizeof(buffer->size));
1651 //dump_buffer(buffer);
1652 CHECK_BUFFER(buffer);
1658 prepend_data(net_buffer* buffer, const void* data, size_t size)
1661 status_t status = prepend_size(buffer, size, &contiguousBuffer);
1672 write_data(buffer, 0, data, size);
1675 //dump_buffer(buffer);
1684 net_buffer_private* buffer = (net_buffer_private*)_buffer;
1685 data_node* node = (data_node*)list_get_last_item(&buffer->buffers);
1687 node = add_first_data_node(buffer->allocation_header);
1692 T(AppendSize(buffer, size));
1694 ParanoiaChecker _(buffer);
1696 TRACE(("%d: append_size(buffer %p, size %ld)\n", find_thread(NULL),
1697 buffer, size));
1698 //dump_buffer(buffer);
1701 // we need to append at least one new buffer
1709 buffer->size += previousTailSpace;
1711 SET_PARANOIA_CHECK(PARANOIA_SUSPICIOUS, buffer, &buffer->size,
1712 sizeof(buffer->size));
1724 remove_trailer(buffer, sizeAdded);
1736 node->offset = buffer->size;
1738 buffer->size += sizeUsed;
1740 SET_PARANOIA_CHECK(PARANOIA_SUSPICIOUS, buffer, &buffer->size,
1741 sizeof(buffer->size));
1743 list_add_item(&buffer->buffers, node);
1754 //dump_buffer(buffer);
1755 CHECK_BUFFER(buffer);
1760 // the data fits into this buffer
1767 buffer->size += size;
1768 SET_PARANOIA_CHECK(PARANOIA_SUSPICIOUS, buffer, &buffer->size,
1769 sizeof(buffer->size));
1772 //dump_buffer(buffer);
1773 CHECK_BUFFER(buffer);
1780 append_data(net_buffer* buffer, const void* data, size_t size)
1782 size_t used = buffer->size;
1785 status_t status = append_size(buffer, size, &contiguousBuffer);
1796 write_data(buffer, used, data, size);
1802 /*! Removes bytes from the beginning of the buffer.
1807 net_buffer_private* buffer = (net_buffer_private*)_buffer;
1809 T(RemoveHeader(buffer, bytes));
1811 ParanoiaChecker _(buffer);
1813 if (bytes > buffer->size)
1816 TRACE(("%d: remove_header(buffer %p, %ld bytes)\n", find_thread(NULL),
1817 buffer, bytes));
1818 //dump_buffer(buffer);
1824 node = (data_node*)list_get_first_item(&buffer->buffers);
1828 CHECK_BUFFER(buffer);
1836 list_remove_item(&buffer->buffers, node);
1840 buffer->stored_header_length = 0;
1850 buffer->stored_header_length += cut;
1855 node = (data_node*)list_get_next_item(&buffer->buffers, node);
1861 node = (data_node*)list_get_next_item(&buffer->buffers, node);
1864 buffer->size -= bytes;
1865 SET_PARANOIA_CHECK(PARANOIA_SUSPICIOUS, buffer, &buffer->size,
1866 sizeof(buffer->size));
1869 //dump_buffer(buffer);
1870 CHECK_BUFFER(buffer);
1876 /*! Removes bytes from the end of the buffer.
1879 remove_trailer(net_buffer* buffer, size_t bytes)
1881 return trim_data(buffer, buffer->size - bytes);
1885 /*! Trims the buffer to the specified \a newSize by removing space from
1886 the end of the buffer.
1891 net_buffer_private* buffer = (net_buffer_private*)_buffer;
1892 TRACE(("%d: trim_data(buffer %p, newSize = %ld, buffer size = %" B_PRIu32 ")\n",
1893 find_thread(NULL), buffer, newSize, buffer->size));
1894 T(Trim(buffer, newSize));
1895 //dump_buffer(buffer);
1897 ParanoiaChecker _(buffer);
1899 if (newSize > buffer->size)
1901 if (newSize == buffer->size)
1904 data_node* node = get_node_at_offset(buffer, newSize);
1906 // trim size greater than buffer size
1915 node = (data_node*)list_get_next_item(&buffer->buffers, node);
1918 data_node* next = (data_node*)list_get_next_item(&buffer->buffers, node);
1919 list_remove_item(&buffer->buffers, node);
1925 buffer->size = newSize;
1926 SET_PARANOIA_CHECK(PARANOIA_SUSPICIOUS, buffer, &buffer->size,
1927 sizeof(buffer->size));
1930 //dump_buffer(buffer);
1931 CHECK_BUFFER(buffer);
1937 /*! Appends data coming from buffer \a source to the buffer \a buffer. It only
1947 net_buffer_private* buffer = (net_buffer_private*)_buffer;
1949 TRACE(("%d: append_cloned_data(buffer %p, source %p, offset = %" B_PRIu32 ", "
1950 "bytes = %ld)\n", find_thread(NULL), buffer, source, offset, bytes));
1951 T(AppendCloned(buffer, source, offset, bytes));
1953 ParanoiaChecker _(buffer);
1959 // find data_node to start with from the source buffer
1962 // trim size greater than buffer size
1969 data_node* clone = add_data_node(buffer, node->header);
1971 remove_trailer(buffer, sizeAppended);
1978 clone->offset = buffer->size;
1981 if (list_is_empty(&buffer->buffers)) {
1983 buffer->stored_header_length = source->stored_header_length;
1988 list_add_item(&buffer->buffers, clone);
1992 buffer->size += clone->used;
2001 //dump_buffer(buffer);
2003 CHECK_BUFFER(buffer);
2004 SET_PARANOIA_CHECK(PARANOIA_SUSPICIOUS, buffer, &buffer->size,
2005 sizeof(buffer->size));
2012 set_ancillary_data(net_buffer* buffer, ancillary_data_container* container)
2014 ((net_buffer_private*)buffer)->ancillary_data = container;
2019 get_ancillary_data(net_buffer* buffer)
2021 return ((net_buffer_private*)buffer)->ancillary_data;
2025 /*! Moves all ancillary data from buffer \c from to the end of the list of
2026 ancillary data of buffer \c to. Note, that this is the only function that
2027 transfers or copies ancillary data from one buffer to another.
2029 \param from The buffer from which to remove the ancillary data.
2030 \param to The buffer to which to add the ancillary data.
2047 // no ancillary data in the target buffer
2070 net_buffer_private* buffer = (net_buffer_private*)_buffer;
2071 data_node* node = (data_node*)list_get_first_item(&buffer->buffers);
2078 node->AddHeaderSpace(buffer->stored_header_length);
2080 buffer->stored_header_length = 0;
2085 buffer->stored_header_length = 0;
2095 net_buffer_private* buffer = (net_buffer_private*)_buffer;
2096 data_node* node = (data_node*)list_get_first_item(&buffer->buffers);
2100 return buffer->stored_header_length;
2104 /*! Reads from the complete buffer with an eventually stored header.
2111 net_buffer_private* buffer = (net_buffer_private*)_buffer;
2113 if (offset < buffer->stored_header_length) {
2114 data_node* node = (data_node*)list_get_first_item(&buffer->buffers);
2116 || offset + bytes > buffer->stored_header_length + buffer->size)
2121 size_t copied = std::min(bytes, buffer->stored_header_length - offset);
2122 memcpy(data, node->start + offset - buffer->stored_header_length,
2132 offset -= buffer->stored_header_length;
2138 /*! Copies from the complete \a source buffer with an eventually stored header
2139 to the specified target \a buffer.
2144 append_restored_header(net_buffer* buffer, net_buffer* _source, uint32 offset,
2158 status_t status = append_data(buffer,
2171 return append_cloned_data(buffer, source, offset, bytes);
2175 /*! Tries to directly access the requested space in the buffer.
2179 \return B_BAD_VALUE if the offset is outside of the buffer's bounds.
2180 \return B_ERROR in case the buffer is not contiguous at that location.
2186 net_buffer_private* buffer = (net_buffer_private*)_buffer;
2188 ParanoiaChecker _(buffer);
2190 //TRACE(("direct_access(buffer %p, offset %ld, size %ld)\n", buffer, offset,
2193 if (offset + size > buffer->size)
2197 data_node* node = get_node_at_offset(buffer, offset);
2214 net_buffer_private* buffer = (net_buffer_private*)_buffer;
2216 if (offset + size > buffer->size || size == 0)
2220 data_node* node = get_node_at_offset(buffer, offset);
2226 // Since the maximum buffer size is 65536 bytes, it's impossible
2245 node = (data_node*)list_get_next_item(&buffer->buffers, node);
2264 net_buffer_private* buffer = (net_buffer_private*)_buffer;
2265 data_node* node = (data_node*)list_get_first_item(&buffer->buffers);
2275 node = (data_node*)list_get_next_item(&buffer->buffers, node);
2285 net_buffer_private* buffer = (net_buffer_private*)_buffer;
2286 data_node* node = (data_node*)list_get_first_item(&buffer->buffers);
2293 node = (data_node*)list_get_next_item(&buffer->buffers, node);
2301 swap_addresses(net_buffer* buffer)
2303 std::swap(buffer->source, buffer->destination);
2315 sNetBufferCache = create_object_cache("net buffer cache",
2329 "Print net buffer statistics",
2330 "\nPrint net buffer statistics.\n", 0);
2334 "Dump net buffer",
2335 "\nDump the net buffer's internal structures.\n", 0);