Implement vectored I/O.
[monolithium.git] / sdk / vector.h
1 /*
2  * vector.h
3  *
4  * Copyright (C) 2018 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
5  *
6  * This program is free software: you can redistribute it and/or modify
7  * it under the terms of the GNU Affero General Public License as
8  * published by the Free Software Foundation, either version 3 of the
9  * License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Affero General Public License for more details.
15  *
16  * You should have received a copy of the GNU Affero General Public License
17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #ifndef __MONOLITHIUM_VECTOR_H__
21 #define __MONOLITHIUM_VECTOR_H__
22
23 #include "defs.h"
24 #include "list.h"
25
26 #ifndef VECTOR_REALLOC
27 extern void *realloc(void*, size_t);
28 #define VECTOR_REALLOC(p, s) realloc((p), (s))
29 #endif
30
31 typedef struct
32 {
33     void *address;
34     size_t length;
35 } vector_buffer_t;
36
37 typedef struct
38 {
39     list_entry_t link;
40     vector_buffer_t buf;
41 } vector_buffer_entry_t;
42
43 typedef struct
44 {
45     size_t position;
46     size_t size;
47     list_entry_t buffer_list;
48 } vector_t;
49
50 static bool_t vector_insert_buffer(vector_t *vector, size_t position, const vector_buffer_t *buffer)
51 {
52     if (!buffer->length) return TRUE;
53     list_entry_t *ptr = &vector->buffer_list;
54
55     while (position)
56     {
57         list_entry_t *next = ptr->next;
58         if (next == &vector->buffer_list) return FALSE;
59
60         vector_buffer_entry_t *entry = CONTAINER_OF(next, vector_buffer_entry_t, link);
61         if (entry->buf.length > position)
62         {
63             vector_buffer_entry_t *remaining = VECTOR_REALLOC(NULL, sizeof(vector_buffer_entry_t));
64             if (!remaining) return FALSE;
65
66             remaining->buf.address = (void*)((uintptr_t)entry->buf.address + position);
67             remaining->buf.length = entry->buf.length - position;
68             entry->buf.length = position;
69
70             list_put_after(next, &remaining->link);
71         }
72
73         position -= entry->buf.length;
74         ptr = next;
75     }
76
77     vector_buffer_entry_t *entry = VECTOR_REALLOC(NULL, sizeof(vector_buffer_entry_t));
78     entry->buf = *buffer;
79     list_put_after(ptr, &entry->link);
80     vector->size += buffer->length;
81     return TRUE;
82 }
83
84 static inline void vector_clear(vector_t *vector)
85 {
86     vector->position = vector->size = 0;
87
88     while (vector->buffer_list.next != &vector->buffer_list)
89     {
90         list_entry_t *ptr = vector->buffer_list.next;
91         list_remove(ptr);
92         ptr = VECTOR_REALLOC(ptr, 0);
93     }
94 }
95
96 static inline bool_t vector_init(vector_t *vector, vector_buffer_t *buffers, size_t num_buffers)
97 {
98     vector->position = vector->size = 0;
99     list_init(&vector->buffer_list);
100
101     int i;
102     for (i = 0; i < num_buffers; i++)
103     {
104         if (!vector_insert_buffer(vector, vector->size, &buffers[i]))
105         {
106             vector_clear(vector);
107             return FALSE;
108         }
109     }
110
111     return TRUE;
112 }
113
114 static inline void vector_read_gather(vector_t *vector, void *data, size_t size)
115 {
116     size_t position = 0;
117     list_entry_t *ptr;
118
119     for (ptr = vector->buffer_list.next; ptr != &vector->buffer_list && position < vector->position + size; ptr = ptr->next)
120     {
121         vector_buffer_t *buffer = &CONTAINER_OF(ptr, vector_buffer_entry_t, link)->buf;
122         uintptr_t start = position > vector->position ? position : vector->position;
123         uintptr_t end = position + buffer->length < vector->position + size ? position + buffer->length : vector->position + size;
124
125         if (start < end)
126         {
127             __builtin_memcpy((void*)((uintptr_t)data + start - vector->position),
128                              (void*)((uintptr_t)buffer->address + start - position),
129                              end - start);
130         }
131
132         position += buffer->length;
133     }
134
135     vector->position += size;
136 }
137
138 static inline void vector_write_scatter(vector_t *vector, const void *data, size_t size)
139 {
140     size_t position = 0;
141     list_entry_t *ptr;
142
143     for (ptr = vector->buffer_list.next; ptr != &vector->buffer_list && position < vector->position + size; ptr = ptr->next)
144     {
145         vector_buffer_t *buffer = &CONTAINER_OF(ptr, vector_buffer_entry_t, link)->buf;
146         uintptr_t start = position > vector->position ? position : vector->position;
147         uintptr_t end = position + buffer->length < vector->position + size ? position + buffer->length : vector->position + size;
148
149         if (start < end)
150         {
151             __builtin_memcpy((void*)((uintptr_t)buffer->address + start - position),
152                              (void*)((uintptr_t)data + start - vector->position),
153                              end - start);
154         }
155
156         position += buffer->length;
157     }
158
159     vector->position += size;
160 }
161
162 static inline void vector_seek(vector_t *vector, size_t position)
163 {
164     vector->position = position < vector->size ? position : vector->size;
165 }
166
167 #endif