[Haiku-commits] r31008 - haiku/trunk/src/add-ons/kernel/network/stack
axeld at BerliOS
axeld at mail.berlios.de
Thu Jun 11 10:48:41 CEST 2009
Author: axeld
Date: 2009-06-11 10:48:40 +0200 (Thu, 11 Jun 2009)
New Revision: 31008
ViewCVS: http://svn.berlios.de/viewcvs/haiku?rev=31008&view=rev
Modified:
haiku/trunk/src/add-ons/kernel/network/stack/net_buffer.cpp
Log:
* Cleanup.
Modified: haiku/trunk/src/add-ons/kernel/network/stack/net_buffer.cpp
===================================================================
--- haiku/trunk/src/add-ons/kernel/network/stack/net_buffer.cpp 2009-06-11 08:30:40 UTC (rev 31007)
+++ haiku/trunk/src/add-ons/kernel/network/stack/net_buffer.cpp 2009-06-11 08:48:40 UTC (rev 31008)
@@ -54,27 +54,27 @@
};
struct free_data {
- struct free_data *next;
- uint16 size;
+ struct free_data* next;
+ uint16 size;
};
struct data_header {
- int32 ref_count;
- addr_t physical_address;
- free_data *first_free;
- uint8 *data_end;
+ int32 ref_count;
+ addr_t physical_address;
+ free_data* first_free;
+ uint8* data_end;
header_space space;
- uint16 tail_space;
+ uint16 tail_space;
};
struct data_node {
struct list_link link;
- struct data_header *header;
- struct data_header *located;
- size_t offset; // the net_buffer-wide offset of this node
- uint8 *start; // points to the start of the data
- uint16 flags;
- uint16 used; // defines how much memory is used by this node
+ struct data_header* header;
+ struct data_header* located;
+ size_t offset; // the net_buffer-wide offset of this node
+ uint8* start; // points to the start of the data
+ uint16 flags;
+ uint16 used; // defines how much memory is used by this node
uint16 HeaderSpace() const
{
@@ -124,14 +124,14 @@
};
struct net_buffer_private : net_buffer {
- struct list buffers;
- data_header *allocation_header; // the current place where we
- // allocate header space (nodes,...)
+ struct list buffers;
+ data_header* allocation_header;
+ // the current place where we allocate header space (nodes, ...)
ancillary_data_container* ancillary_data;
struct {
- struct sockaddr_storage source;
- struct sockaddr_storage destination;
+ struct sockaddr_storage source;
+ struct sockaddr_storage destination;
} storage;
};
@@ -141,17 +141,17 @@
#define MAX_FREE_BUFFER_SIZE (BUFFER_SIZE - DATA_HEADER_SIZE)
-static object_cache *sNetBufferCache;
-static object_cache *sDataNodeCache;
+static object_cache* sNetBufferCache;
+static object_cache* sDataNodeCache;
-static status_t append_data(net_buffer *buffer, const void *data, size_t size);
-static status_t trim_data(net_buffer *_buffer, size_t newSize);
-static status_t remove_header(net_buffer *_buffer, size_t bytes);
-static status_t remove_trailer(net_buffer *_buffer, size_t bytes);
-static status_t append_cloned_data(net_buffer *_buffer, net_buffer *_source,
+static status_t append_data(net_buffer* buffer, const void* data, size_t size);
+static status_t trim_data(net_buffer* _buffer, size_t newSize);
+static status_t remove_header(net_buffer* _buffer, size_t bytes);
+static status_t remove_trailer(net_buffer* _buffer, size_t bytes);
+static status_t append_cloned_data(net_buffer* _buffer, net_buffer* _source,
uint32 offset, size_t bytes);
-static status_t read_data(net_buffer *_buffer, size_t offset, void *data,
+static status_t read_data(net_buffer* _buffer, size_t offset, void* data,
size_t size);
@@ -170,389 +170,389 @@
class NetBufferTraceEntry : public AbstractTraceEntry {
- public:
- NetBufferTraceEntry(net_buffer* buffer)
- :
- fBuffer(buffer)
- {
+public:
+ NetBufferTraceEntry(net_buffer* buffer)
+ :
+ fBuffer(buffer)
+ {
#if NET_BUFFER_TRACING_STACK_TRACE
- fStackTrace = capture_tracing_stack_trace(
- NET_BUFFER_TRACING_STACK_TRACE, 0, false);
+ fStackTrace = capture_tracing_stack_trace(
+ NET_BUFFER_TRACING_STACK_TRACE, 0, false);
#endif
- }
+ }
#if NET_BUFFER_TRACING_STACK_TRACE
- virtual void DumpStackTrace(TraceOutput& out)
- {
- out.PrintStackTrace(fStackTrace);
- }
+ virtual void DumpStackTrace(TraceOutput& out)
+ {
+ out.PrintStackTrace(fStackTrace);
+ }
#endif
- protected:
- net_buffer* fBuffer;
+protected:
+ net_buffer* fBuffer;
#if NET_BUFFER_TRACING_STACK_TRACE
- tracing_stack_trace* fStackTrace;
+ tracing_stack_trace* fStackTrace;
#endif
};
class Create : public NetBufferTraceEntry {
- public:
- Create(size_t headerSpace, net_buffer* buffer)
- :
- NetBufferTraceEntry(buffer),
- fHeaderSpace(headerSpace)
- {
- Initialized();
- }
+public:
+ Create(size_t headerSpace, net_buffer* buffer)
+ :
+ NetBufferTraceEntry(buffer),
+ fHeaderSpace(headerSpace)
+ {
+ Initialized();
+ }
- virtual void AddDump(TraceOutput& out)
- {
- out.Print("net buffer create: header space: %lu -> buffer: %p",
- fHeaderSpace, fBuffer);
- }
+ virtual void AddDump(TraceOutput& out)
+ {
+ out.Print("net buffer create: header space: %lu -> buffer: %p",
+ fHeaderSpace, fBuffer);
+ }
- private:
- size_t fHeaderSpace;
+private:
+ size_t fHeaderSpace;
};
class Free : public NetBufferTraceEntry {
- public:
- Free(net_buffer* buffer)
- :
- NetBufferTraceEntry(buffer)
- {
- Initialized();
- }
+public:
+ Free(net_buffer* buffer)
+ :
+ NetBufferTraceEntry(buffer)
+ {
+ Initialized();
+ }
- virtual void AddDump(TraceOutput& out)
- {
- out.Print("net buffer free: buffer: %p", fBuffer);
- }
+ virtual void AddDump(TraceOutput& out)
+ {
+ out.Print("net buffer free: buffer: %p", fBuffer);
+ }
};
class Duplicate : public NetBufferTraceEntry {
- public:
- Duplicate(net_buffer* buffer, net_buffer* clone)
- :
- NetBufferTraceEntry(buffer),
- fClone(clone)
- {
- Initialized();
- }
+public:
+ Duplicate(net_buffer* buffer, net_buffer* clone)
+ :
+ NetBufferTraceEntry(buffer),
+ fClone(clone)
+ {
+ Initialized();
+ }
- virtual void AddDump(TraceOutput& out)
- {
- out.Print("net buffer dup: buffer: %p -> %p", fBuffer, fClone);
- }
+ virtual void AddDump(TraceOutput& out)
+ {
+ out.Print("net buffer dup: buffer: %p -> %p", fBuffer, fClone);
+ }
- private:
- net_buffer* fClone;
+private:
+ net_buffer* fClone;
};
class Clone : public NetBufferTraceEntry {
- public:
- Clone(net_buffer* buffer, bool shareFreeSpace, net_buffer* clone)
- :
- NetBufferTraceEntry(buffer),
- fClone(clone),
- fShareFreeSpace(shareFreeSpace)
- {
- Initialized();
- }
+public:
+ Clone(net_buffer* buffer, bool shareFreeSpace, net_buffer* clone)
+ :
+ NetBufferTraceEntry(buffer),
+ fClone(clone),
+ fShareFreeSpace(shareFreeSpace)
+ {
+ Initialized();
+ }
- virtual void AddDump(TraceOutput& out)
- {
- out.Print("net buffer clone: buffer: %p, share free space: %s "
- "-> %p", fBuffer, fShareFreeSpace ? "true" : "false", fClone);
- }
+ virtual void AddDump(TraceOutput& out)
+ {
+ out.Print("net buffer clone: buffer: %p, share free space: %s "
+ "-> %p", fBuffer, fShareFreeSpace ? "true" : "false", fClone);
+ }
- private:
- net_buffer* fClone;
- bool fShareFreeSpace;
+private:
+ net_buffer* fClone;
+ bool fShareFreeSpace;
};
class Split : public NetBufferTraceEntry {
- public:
- Split(net_buffer* buffer, uint32 offset, net_buffer* newBuffer)
- :
- NetBufferTraceEntry(buffer),
- fNewBuffer(newBuffer),
- fOffset(offset)
- {
- Initialized();
- }
+public:
+ Split(net_buffer* buffer, uint32 offset, net_buffer* newBuffer)
+ :
+ NetBufferTraceEntry(buffer),
+ fNewBuffer(newBuffer),
+ fOffset(offset)
+ {
+ Initialized();
+ }
- virtual void AddDump(TraceOutput& out)
- {
- out.Print("net buffer split: buffer: %p, offset: %lu "
- "-> %p", fBuffer, fOffset, fNewBuffer);
- }
+ virtual void AddDump(TraceOutput& out)
+ {
+ out.Print("net buffer split: buffer: %p, offset: %lu "
+ "-> %p", fBuffer, fOffset, fNewBuffer);
+ }
- private:
- net_buffer* fNewBuffer;
- uint32 fOffset;
+private:
+ net_buffer* fNewBuffer;
+ uint32 fOffset;
};
class Merge : public NetBufferTraceEntry {
- public:
- Merge(net_buffer* buffer, net_buffer* otherBuffer, bool after)
- :
- NetBufferTraceEntry(buffer),
- fOtherBuffer(otherBuffer),
- fAfter(after)
- {
- Initialized();
- }
+public:
+ Merge(net_buffer* buffer, net_buffer* otherBuffer, bool after)
+ :
+ NetBufferTraceEntry(buffer),
+ fOtherBuffer(otherBuffer),
+ fAfter(after)
+ {
+ Initialized();
+ }
- virtual void AddDump(TraceOutput& out)
- {
- out.Print("net buffer merge: buffers: %p + %p, after: %s "
- "-> %p", fBuffer, fOtherBuffer, fAfter ? "true" : "false",
- fOtherBuffer);
- }
+ virtual void AddDump(TraceOutput& out)
+ {
+ out.Print("net buffer merge: buffers: %p + %p, after: %s "
+ "-> %p", fBuffer, fOtherBuffer, fAfter ? "true" : "false",
+ fOtherBuffer);
+ }
- private:
- net_buffer* fOtherBuffer;
- bool fAfter;
+private:
+ net_buffer* fOtherBuffer;
+ bool fAfter;
};
class AppendCloned : public NetBufferTraceEntry {
- public:
- AppendCloned(net_buffer* buffer, net_buffer* source, uint32 offset,
- size_t size)
- :
- NetBufferTraceEntry(buffer),
- fSource(source),
- fOffset(offset),
- fSize(size)
- {
- Initialized();
- }
+public:
+ AppendCloned(net_buffer* buffer, net_buffer* source, uint32 offset,
+ size_t size)
+ :
+ NetBufferTraceEntry(buffer),
+ fSource(source),
+ fOffset(offset),
+ fSize(size)
+ {
+ Initialized();
+ }
- virtual void AddDump(TraceOutput& out)
- {
- out.Print("net buffer append cloned: buffer: %p, from: %p, "
- "offset: %lu, size: %lu", fBuffer, fSource, fOffset, fSize);
- }
+ virtual void AddDump(TraceOutput& out)
+ {
+ out.Print("net buffer append cloned: buffer: %p, from: %p, "
+ "offset: %lu, size: %lu", fBuffer, fSource, fOffset, fSize);
+ }
- private:
- net_buffer* fSource;
- uint32 fOffset;
- size_t fSize;
+private:
+ net_buffer* fSource;
+ uint32 fOffset;
+ size_t fSize;
};
class PrependSize : public NetBufferTraceEntry {
- public:
- PrependSize(net_buffer* buffer, size_t size)
- :
- NetBufferTraceEntry(buffer),
- fSize(size)
- {
- Initialized();
- }
+public:
+ PrependSize(net_buffer* buffer, size_t size)
+ :
+ NetBufferTraceEntry(buffer),
+ fSize(size)
+ {
+ Initialized();
+ }
- virtual void AddDump(TraceOutput& out)
- {
- out.Print("net buffer prepend size: buffer: %p, size: %lu", fBuffer,
- fSize);
- }
+ virtual void AddDump(TraceOutput& out)
+ {
+ out.Print("net buffer prepend size: buffer: %p, size: %lu", fBuffer,
+ fSize);
+ }
- private:
- size_t fSize;
+private:
+ size_t fSize;
};
class AppendSize : public NetBufferTraceEntry {
- public:
- AppendSize(net_buffer* buffer, size_t size)
- :
- NetBufferTraceEntry(buffer),
- fSize(size)
- {
- Initialized();
- }
+public:
+ AppendSize(net_buffer* buffer, size_t size)
+ :
+ NetBufferTraceEntry(buffer),
+ fSize(size)
+ {
+ Initialized();
+ }
- virtual void AddDump(TraceOutput& out)
- {
- out.Print("net buffer append size: buffer: %p, size: %lu", fBuffer,
- fSize);
- }
+ virtual void AddDump(TraceOutput& out)
+ {
+ out.Print("net buffer append size: buffer: %p, size: %lu", fBuffer,
+ fSize);
+ }
- private:
- size_t fSize;
+private:
+ size_t fSize;
};
class RemoveHeader : public NetBufferTraceEntry {
- public:
- RemoveHeader(net_buffer* buffer, size_t size)
- :
- NetBufferTraceEntry(buffer),
- fSize(size)
- {
- Initialized();
- }
+public:
+ RemoveHeader(net_buffer* buffer, size_t size)
+ :
+ NetBufferTraceEntry(buffer),
+ fSize(size)
+ {
+ Initialized();
+ }
- virtual void AddDump(TraceOutput& out)
- {
- out.Print("net buffer remove header: buffer: %p, size: %lu",
- fBuffer, fSize);
- }
+ virtual void AddDump(TraceOutput& out)
+ {
+ out.Print("net buffer remove header: buffer: %p, size: %lu",
+ fBuffer, fSize);
+ }
- private:
- size_t fSize;
+private:
+ size_t fSize;
};
class Trim : public NetBufferTraceEntry {
- public:
- Trim(net_buffer* buffer, size_t size)
- :
- NetBufferTraceEntry(buffer),
- fSize(size)
- {
- Initialized();
- }
+public:
+ Trim(net_buffer* buffer, size_t size)
+ :
+ NetBufferTraceEntry(buffer),
+ fSize(size)
+ {
+ Initialized();
+ }
- virtual void AddDump(TraceOutput& out)
- {
- out.Print("net buffer trim: buffer: %p, size: %lu",
- fBuffer, fSize);
- }
+ virtual void AddDump(TraceOutput& out)
+ {
+ out.Print("net buffer trim: buffer: %p, size: %lu",
+ fBuffer, fSize);
+ }
- private:
- size_t fSize;
+private:
+ size_t fSize;
};
class Read : public NetBufferTraceEntry {
- public:
- Read(net_buffer* buffer, uint32 offset, void* data, size_t size)
- :
- NetBufferTraceEntry(buffer),
- fData(data),
- fOffset(offset),
- fSize(size)
- {
- Initialized();
- }
+public:
+ Read(net_buffer* buffer, uint32 offset, void* data, size_t size)
+ :
+ NetBufferTraceEntry(buffer),
+ fData(data),
+ fOffset(offset),
+ fSize(size)
+ {
+ Initialized();
+ }
- virtual void AddDump(TraceOutput& out)
- {
- out.Print("net buffer read: buffer: %p, offset: %lu, size: %lu, "
- "data: %p", fBuffer, fOffset, fSize, fData);
- }
+ virtual void AddDump(TraceOutput& out)
+ {
+ out.Print("net buffer read: buffer: %p, offset: %lu, size: %lu, "
+ "data: %p", fBuffer, fOffset, fSize, fData);
+ }
- private:
- void* fData;
- uint32 fOffset;
- size_t fSize;
+private:
+ void* fData;
+ uint32 fOffset;
+ size_t fSize;
};
class Write : public NetBufferTraceEntry {
- public:
- Write(net_buffer* buffer, uint32 offset, const void* data, size_t size)
- :
- NetBufferTraceEntry(buffer),
- fData(data),
- fOffset(offset),
- fSize(size)
- {
- Initialized();
- }
+public:
+ Write(net_buffer* buffer, uint32 offset, const void* data, size_t size)
+ :
+ NetBufferTraceEntry(buffer),
+ fData(data),
+ fOffset(offset),
+ fSize(size)
+ {
+ Initialized();
+ }
- virtual void AddDump(TraceOutput& out)
- {
- out.Print("net buffer write: buffer: %p, offset: %lu, size: %lu, "
- "data: %p", fBuffer, fOffset, fSize, fData);
- }
+ virtual void AddDump(TraceOutput& out)
+ {
+ out.Print("net buffer write: buffer: %p, offset: %lu, size: %lu, "
+ "data: %p", fBuffer, fOffset, fSize, fData);
+ }
- private:
- const void* fData;
- uint32 fOffset;
- size_t fSize;
+private:
+ const void* fData;
+ uint32 fOffset;
+ size_t fSize;
};
#if NET_BUFFER_TRACING >= 2
class DataHeaderTraceEntry : public AbstractTraceEntry {
- public:
- DataHeaderTraceEntry(data_header* header)
- :
- fHeader(header)
- {
- }
+public:
+ DataHeaderTraceEntry(data_header* header)
+ :
+ fHeader(header)
+ {
+ }
- protected:
- data_header* fHeader;
+protected:
+ data_header* fHeader;
};
class CreateDataHeader : public DataHeaderTraceEntry {
- public:
- CreateDataHeader(data_header* header)
- :
- DataHeaderTraceEntry(header)
- {
- Initialized();
- }
+public:
+ CreateDataHeader(data_header* header)
+ :
+ DataHeaderTraceEntry(header)
+ {
+ Initialized();
+ }
- virtual void AddDump(TraceOutput& out)
- {
- out.Print("net buffer data header create: header: %p", fHeader);
- }
+ virtual void AddDump(TraceOutput& out)
+ {
+ out.Print("net buffer data header create: header: %p", fHeader);
+ }
};
class AcquireDataHeader : public DataHeaderTraceEntry {
- public:
- AcquireDataHeader(data_header* header, int32 refCount)
- :
- DataHeaderTraceEntry(header),
- fRefCount(refCount)
- {
- Initialized();
- }
+public:
+ AcquireDataHeader(data_header* header, int32 refCount)
+ :
+ DataHeaderTraceEntry(header),
+ fRefCount(refCount)
+ {
+ Initialized();
+ }
- virtual void AddDump(TraceOutput& out)
- {
- out.Print("net buffer data header acquire: header: %p "
- "-> ref count: %ld", fHeader, fRefCount);
- }
+ virtual void AddDump(TraceOutput& out)
+ {
+ out.Print("net buffer data header acquire: header: %p "
+ "-> ref count: %ld", fHeader, fRefCount);
+ }
- private:
- int32 fRefCount;
+private:
+ int32 fRefCount;
};
class ReleaseDataHeader : public DataHeaderTraceEntry {
- public:
- ReleaseDataHeader(data_header* header, int32 refCount)
- :
- DataHeaderTraceEntry(header),
- fRefCount(refCount)
- {
- Initialized();
- }
+public:
+ ReleaseDataHeader(data_header* header, int32 refCount)
+ :
+ DataHeaderTraceEntry(header),
+ fRefCount(refCount)
+ {
+ Initialized();
+ }
- virtual void AddDump(TraceOutput& out)
- {
- out.Print("net buffer data header release: header: %p "
- "-> ref count: %ld", fHeader, fRefCount);
- }
+ virtual void AddDump(TraceOutput& out)
+ {
+ out.Print("net buffer data header release: header: %p "
+ "-> ref count: %ld", fHeader, fRefCount);
+ }
- private:
- int32 fRefCount;
+private:
+ int32 fRefCount;
};
# define T2(x) new(std::nothrow) NetBufferTracing::x
@@ -572,17 +572,19 @@
#if 1
static void
-dump_buffer(net_buffer *_buffer)
+dump_buffer(net_buffer* _buffer)
{
- net_buffer_private *buffer = (net_buffer_private *)_buffer;
+ net_buffer_private* buffer = (net_buffer_private*)_buffer;
dprintf("buffer %p, size %ld\n", buffer, buffer->size);
- data_node *node = NULL;
- while ((node = (data_node *)list_get_next_item(&buffer->buffers, node)) != NULL) {
- dprintf(" node %p, offset %lu, used %u, header %u, tail %u, header %p\n",
- node, node->offset, node->used, node->HeaderSpace(), node->TailSpace(), node->header);
- //dump_block((char *)node->start, node->used, " ");
- dump_block((char *)node->start, min_c(node->used, 32), " ");
+ data_node* node = NULL;
+ while ((node = (data_node*)list_get_next_item(&buffer->buffers, node))
+ != NULL) {
+ dprintf(" node %p, offset %lu, used %u, header %u, tail %u, "
+ "header %p\n", node, node->offset, node->used, node->HeaderSpace(),
+ node->TailSpace(), node->header);
+ //dump_block((char*)node->start, node->used, " ");
+ dump_block((char*)node->start, min_c(node->used, 32), " ");
}
}
#endif
@@ -606,14 +608,14 @@
#if PARANOID_BUFFER_CHECK
static void
-check_buffer(net_buffer *_buffer)
+check_buffer(net_buffer* _buffer)
{
- net_buffer_private *buffer = (net_buffer_private*)_buffer;
+ net_buffer_private* buffer = (net_buffer_private*)_buffer;
// sum up the size of all nodes
size_t size = 0;
- data_node *node = (data_node *)list_get_first_item(&buffer->buffers);
+ data_node* node = (data_node*)list_get_first_item(&buffer->buffers);
while (node != NULL) {
if (node->offset != size) {
panic("net_buffer %p: bad node %p offset (%lu vs. %lu)",
@@ -621,7 +623,7 @@
return;
}
size += node->used;
- node = (data_node *)list_get_next_item(&buffer->buffers, node);
+ node = (data_node*)list_get_next_item(&buffer->buffers, node);
}
if (size != buffer->size) {
@@ -634,7 +636,7 @@
#if 0
static void
-check_buffer_contents(net_buffer *buffer, size_t offset, const void* data,
+check_buffer_contents(net_buffer* buffer, size_t offset, const void* data,
size_t size)
{
void* bufferData = malloc(size);
@@ -660,7 +662,7 @@
static void
-check_buffer_contents(net_buffer *buffer, size_t offset, net_buffer *source,
+check_buffer_contents(net_buffer* buffer, size_t offset, net_buffer* source,
size_t sourceOffset, size_t size)
{
void* bufferData = malloc(size);
@@ -685,31 +687,31 @@
#endif // !PARANOID_BUFFER_CHECK
-static inline data_header *
+static inline data_header*
allocate_data_header()
{
#if ENABLE_DEBUGGER_COMMANDS
atomic_add(&sAllocatedDataHeaderCount, 1);
atomic_add(&sEverAllocatedDataHeaderCount, 1);
#endif
- return (data_header *)object_cache_alloc(sDataNodeCache, CACHE_DONT_SLEEP);
+ return (data_header*)object_cache_alloc(sDataNodeCache, CACHE_DONT_SLEEP);
}
-static inline net_buffer_private *
+static inline net_buffer_private*
allocate_net_buffer()
{
#if ENABLE_DEBUGGER_COMMANDS
atomic_add(&sAllocatedNetBufferCount, 1);
atomic_add(&sEverAllocatedNetBufferCount, 1);
#endif
- return (net_buffer_private *)object_cache_alloc(sNetBufferCache,
+ return (net_buffer_private*)object_cache_alloc(sNetBufferCache,
CACHE_DONT_SLEEP);
}
static inline void
-free_data_header(data_header *header)
+free_data_header(data_header* header)
{
#if ENABLE_DEBUGGER_COMMANDS
if (header != NULL)
@@ -720,7 +722,7 @@
static inline void
-free_net_buffer(net_buffer_private *buffer)
+free_net_buffer(net_buffer_private* buffer)
{
#if ENABLE_DEBUGGER_COMMANDS
if (buffer != NULL)
@@ -730,10 +732,10 @@
}
-static data_header *
+static data_header*
create_data_header(size_t headerSpace)
{
- data_header *header = allocate_data_header();
+ data_header* header = allocate_data_header();
if (header == NULL)
return NULL;
@@ -742,8 +744,8 @@
// TODO: initialize this correctly
header->space.size = headerSpace;
header->space.free = headerSpace;
- header->data_end = (uint8 *)header + DATA_HEADER_SIZE;
- header->tail_space = (uint8 *)header + BUFFER_SIZE - header->data_end
+ header->data_end = (uint8*)header + DATA_HEADER_SIZE;
+ header->tail_space = (uint8*)header + BUFFER_SIZE - header->data_end
- headerSpace;
header->first_free = NULL;
@@ -754,7 +756,7 @@
static void
-release_data_header(data_header *header)
+release_data_header(data_header* header)
{
int32 refCount = atomic_add(&header->ref_count, -1);
T2(ReleaseDataHeader(header, refCount - 1));
@@ -767,7 +769,7 @@
inline void
-acquire_data_header(data_header *header)
+acquire_data_header(data_header* header)
{
int32 refCount = atomic_add(&header->ref_count, 1);
(void)refCount;
@@ -776,12 +778,12 @@
static void
-free_data_header_space(data_header *header, uint8 *data, size_t size)
+free_data_header_space(data_header* header, uint8* data, size_t size)
{
if (size < sizeof(free_data))
size = sizeof(free_data);
- free_data *freeData = (free_data *)data;
+ free_data* freeData = (free_data*)data;
freeData->next = header->first_free;
freeData->size = size;
@@ -789,11 +791,10 @@
}
-/*!
- Tries to allocate \a size bytes from the free space in the header.
+/*! Tries to allocate \a size bytes from the free space in the header.
*/
-static uint8 *
-alloc_data_header_space(data_header *header, size_t size)
+static uint8*
+alloc_data_header_space(data_header* header, size_t size)
{
if (size < sizeof(free_data))
size = sizeof(free_data);
@@ -801,25 +802,26 @@
if (header->first_free != NULL && header->first_free->size >= size) {
// the first entry of the header space matches the allocation's needs
-// TODO: If the free space is greater than what shall be allocated, we leak
-// the remainder of the space. We should only allocate multiples of
-// _ALIGN(sizeof(free_data)) and split free space in this case. It's not that
-// pressing, since the only thing allocated ATM are data_nodes, and thus the
-// free space entries will always have the right size.
- uint8 *data = (uint8 *)header->first_free;
+
+ // TODO: If the free space is greater than what shall be allocated, we
+ // leak the remainder of the space. We should only allocate multiples of
+ // _ALIGN(sizeof(free_data)) and split free space in this case. It's not
+ // that pressing, since the only thing allocated ATM are data_nodes, and
+ // thus the free space entries will always have the right size.
+ uint8* data = (uint8*)header->first_free;
header->first_free = header->first_free->next;
return data;
}
if (header->space.free < size) {
// there is no free space left, search free list
- free_data *freeData = header->first_free;
- free_data *last = NULL;
+ free_data* freeData = header->first_free;
+ free_data* last = NULL;
while (freeData != NULL) {
if (last != NULL && freeData->size >= size) {
// take this one
last->next = freeData->next;
- return (uint8 *)freeData;
+ return (uint8*)freeData;
}
last = freeData;
@@ -831,7 +833,7 @@
// allocate new space
- uint8 *data = header->data_end;
+ uint8* data = header->data_end;
header->data_end += size;
header->space.free -= size;
@@ -839,15 +841,15 @@
}
-static uint8 *
-alloc_data_header_space(net_buffer_private *buffer, size_t size,
- data_header **_header = NULL)
+static uint8*
+alloc_data_header_space(net_buffer_private* buffer, size_t size,
[... truncated: 873 lines follow ...]
More information about the Haiku-commits
mailing list