Changeset 25275

Timestamp:

04/30/08 14:47:11 (7 months ago)

Author:

bonefish

Message:

Following Axel's suggestions:
* Added data_node::flags field and currently only flag

DATA_NODE_READ_ONLY, indicating that the node is read-only (i.e.
a clone). If set, the node won't have any header or tail space. Not
being able to write to it is not yet enforced, though.

* Moved data_node::tail_space to data_header.
* Removed data_node:used_header_space/own_header_space.

Files:

• haiku/trunk/src/add-ons/kernel/network/stack/net_buffer.cpp (modified) (13 diffs)

haiku/trunk/src/add-ons/kernel/network/stack/net_buffer.cpp

@@ -45 +45 @@
 #include <debug_paranoia.h>
 
+#define DATA_NODE_READ_ONLY             0x1
 
 struct header_space {
         uint16  size;
         uint16  free;
+};
+
+struct free_data {
+        struct free_data *next;
+        uint16          size;
+};
+
+struct data_header {
+        int32           ref_count;
+        addr_t          physical_address;
+        free_data       *first_free;
+        uint8           *data_end;
+        header_space    space;
+        uint16          tail_space;
 };
 
@@ -57 +72 @@
         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          tail_space;
-        header_space    own_header_space;
-        header_space    *used_header_space;     // For the "first node" this points to
-                                                                                // the header's space otherwise to
-                                                                                // own_header_space.
-
-        uint16  HeaderSpace() const     { return used_header_space->free; }
+
+        uint16 HeaderSpace() const
+        {
+                if ((flags & DATA_NODE_READ_ONLY) != 0)
+                        return 0;
+                return header->space.free;
+        }
 
         void AddHeaderSpace(uint16 toAdd)
         {
-                used_header_space->size += toAdd;
-                used_header_space->free += toAdd;
+                if ((flags & DATA_NODE_READ_ONLY) == 0) {
+                        header->space.size += toAdd;
+                        header->space.free += toAdd;
+                }
         }
 
         void SubtractHeaderSpace(uint16 toSubtract)
         {
-                used_header_space->size -= toSubtract;
-                used_header_space->free -= toSubtract;
-        }
-};
-
-struct free_data {
-        struct free_data *next;
-        uint16          size;
-};
-
-struct data_header {
-        int32           ref_count;
-        addr_t          physical_address;
-        free_data       *first_free;
-        uint8           *data_end;
-        header_space    space;
+                if ((flags & DATA_NODE_READ_ONLY) == 0) {
+                        header->space.size -= toSubtract;
+                        header->space.free -= toSubtract;
+                }
+        }
+
+        uint16 TailSpace() const
+        {
+                if ((flags & DATA_NODE_READ_ONLY) != 0)
+                        return 0;
+                return header->tail_space;
+        }
+
+        void SetTailSpace(uint16 space)
+        {
+                if ((flags & DATA_NODE_READ_ONLY) == 0)
+                        header->tail_space = space;
+        }
+
+        void FreeSpace()
+        {
+                if ((flags & DATA_NODE_READ_ONLY) == 0) {
+                        uint16 space = used + header->tail_space;
+                        header->space.size += space;
+                        header->space.free += space;
+                        header->tail_space = 0;
+                }
+        }
 };
 
@@ -568 +598 @@
         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->tail_space, node->header);
+                        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), "    ");
@@ -731 +761 @@
         header->space.free = headerSpace;
         header->data_end = (uint8 *)header + DATA_HEADER_SIZE;
+        header->tail_space = (uint8 *)header + BUFFER_SIZE - header->data_end
+                - headerSpace;
         header->first_free = NULL;
 
@@ -873 +905 @@
         node->start = header->data_end + header->space.free;
         node->used = 0;
-        node->used_header_space = &header->space;
-        node->tail_space = (uint8 *)header + BUFFER_SIZE - node->start;
+        node->flags = 0;
 
         return node;
@@ -899 +930 @@
         node->located = located;
         node->header = header;
-        node->used_header_space = &node->own_header_space;
+        node->flags = 0;
         return node;
 }
@@ -915 +946 @@
         // this is the first node of a buffer (i.e. the header is an allocation
         // header).
-        node->used_header_space->size += node->used + node->tail_space;
+        node->FreeSpace();
 
         if (located != node->header)
@@ -1435 +1466 @@
 
         TRACE(("%ld: prepend_size(buffer %p, size %ld) [has %u]\n",
-                find_thread(NULL), buffer, size, node->used_header_space.free));
+                find_thread(NULL), buffer, size, node->HeaderSpace()));
         //dump_buffer(buffer);
 
@@ -1545 +1576 @@
         //dump_buffer(buffer);
 
-        if (node->tail_space < size) {
+        if (node->TailSpace() < size) {
                 // we need to append at least one new buffer
-                uint32 previousTailSpace = node->tail_space;
+                uint32 previousTailSpace = node->TailSpace();
                 uint32 headerSpace = DATA_NODE_SIZE;
                 uint32 sizeUsed = MAX_FREE_BUFFER_SIZE - headerSpace;
 
                 // allocate space left in the node
-                node->tail_space = 0;
+                node->SetTailSpace(0);
                 node->used += previousTailSpace;
                 buffer->size += previousTailSpace;
@@ -1575 +1606 @@
                         node = add_first_data_node(header);
 
-                        node->tail_space -= sizeUsed;
+                        node->SetTailSpace(node->TailSpace() - sizeUsed);
                         node->used = sizeUsed;
                         node->offset = buffer->size;
@@ -1602 +1633 @@
 
         // the data fits into this buffer
-        node->tail_space -= size;
+        node->SetTailSpace(node->TailSpace() - size);
 
         if (_contiguousBuffer)
@@ -1747 +1778 @@
 
         int32 diff = node->used + node->offset - newSize;
-        node->tail_space += diff;
+        node->SetTailSpace(node->TailSpace() + diff);
         node->used -= diff;
 
@@ -1818 +1849 @@
                 clone->start = node->start + offset;
                 clone->used = min_c(bytes, node->used - offset);
-                clone->used_header_space->size = 0;
-                clone->used_header_space->free = 0;
-                clone->tail_space = 0;
+                clone->flags |= DATA_NODE_READ_ONLY;
 
                 list_add_item(&buffer->buffers, clone);