1 2 /* 3 * Copyright (C) Igor Sysoev 4 * Copyright (C) NGINX, Inc. 5 */ 6 7 #include <nxt_main.h> 8 9 10 static void nxt_buf_completion(nxt_task_t *task, void *obj, void *data); 11 static void nxt_buf_ts_completion(nxt_task_t *task, void *obj, void *data); 12 13 14 typedef struct { 15 nxt_work_t work; 16 nxt_event_engine_t *engine; 17 } nxt_buf_ts_t; 18 19 20 void 21 nxt_buf_mem_init(nxt_buf_t *b, void *start, size_t size) 22 { 23 b->mem.start = start; 24 b->mem.pos = start; 25 b->mem.free = start; 26 b->mem.end = nxt_pointer_to(start, size); 27 } 28 29 30 nxt_buf_t * 31 nxt_buf_mem_alloc(nxt_mp_t *mp, size_t size, nxt_uint_t flags) 32 { 33 nxt_buf_t *b; 34 35 b = nxt_mp_alloc(mp, NXT_BUF_MEM_SIZE + size); 36 if (nxt_slow_path(b == NULL)) { 37 return NULL; 38 } 39 40 nxt_memzero(b, NXT_BUF_MEM_SIZE); 41 42 b->data = mp; 43 b->completion_handler = nxt_buf_completion; 44 45 if (size != 0) { 46 b->mem.start = nxt_pointer_to(b, NXT_BUF_MEM_SIZE); 47 b->mem.pos = b->mem.start; 48 b->mem.free = b->mem.start; 49 b->mem.end = b->mem.start + size; 50 } 51 52 return b; 53 } 54 55 56 nxt_buf_t * 57 nxt_buf_mem_ts_alloc(nxt_task_t *task, nxt_mp_t *mp, size_t size) 58 { 59 nxt_buf_t *b; 60 nxt_buf_ts_t *ts; 61 62 b = nxt_mp_alloc(mp, NXT_BUF_MEM_SIZE + sizeof(nxt_buf_ts_t) + size); 63 if (nxt_slow_path(b == NULL)) { 64 return NULL; 65 } 66 67 nxt_mp_retain(mp); 68 69 nxt_memzero(b, NXT_BUF_MEM_SIZE + sizeof(nxt_buf_ts_t)); 70 71 b->data = mp; 72 b->completion_handler = nxt_buf_ts_completion; 73 b->is_ts = 1; 74 75 if (size != 0) { 76 b->mem.start = nxt_pointer_to(b, NXT_BUF_MEM_SIZE 77 + sizeof(nxt_buf_ts_t)); 78 b->mem.pos = b->mem.start; 79 b->mem.free = b->mem.start; 80 b->mem.end = b->mem.start + size; 81 } 82 83 ts = nxt_pointer_to(b, NXT_BUF_MEM_SIZE); 84 ts->engine = task->thread->engine; 85 86 ts->work.handler = nxt_buf_ts_completion; 87 ts->work.task = task; 88 ts->work.obj = b; 89 ts->work.data = b->parent; 90 91 return b; 92 } 93 94 95 nxt_buf_t * 96 nxt_buf_file_alloc(nxt_mp_t *mp, size_t size, nxt_uint_t flags) 97 { 98 nxt_buf_t *b; 99 100 b = nxt_mp_alloc(mp, NXT_BUF_FILE_SIZE + size); 101 if (nxt_slow_path(b == NULL)) { 102 return NULL; 103 } 104 105 nxt_memzero(b, NXT_BUF_FILE_SIZE); 106 107 b->data = mp; 108 b->completion_handler = nxt_buf_completion; 109 nxt_buf_set_file(b); 110 111 if (size != 0) { 112 b->mem.start = nxt_pointer_to(b, NXT_BUF_FILE_SIZE); 113 b->mem.pos = b->mem.start; 114 b->mem.free = b->mem.start; 115 b->mem.end = b->mem.start + size; 116 } 117 118 return b; 119 } 120 121 122 nxt_buf_t * 123 nxt_buf_mmap_alloc(nxt_mp_t *mp, size_t size) 124 { 125 nxt_buf_t *b; 126 127 b = nxt_mp_zalloc(mp, NXT_BUF_MMAP_SIZE); 128 129 if (nxt_fast_path(b != NULL)) { 130 b->data = mp; 131 b->completion_handler = nxt_buf_completion; 132 133 nxt_buf_set_file(b); 134 nxt_buf_set_mmap(b); 135 nxt_buf_mem_set_size(&b->mem, size); 136 } 137 138 return b; 139 } 140 141 142 nxt_buf_t * 143 nxt_buf_sync_alloc(nxt_mp_t *mp, nxt_uint_t flags) 144 { 145 nxt_buf_t *b; 146 147 b = nxt_mp_zalloc(mp, NXT_BUF_MEM_SIZE); 148 149 if (nxt_fast_path(b != NULL)) { 150 b->data = mp; 151 b->completion_handler = nxt_buf_completion; 152 153 nxt_buf_set_sync(b); 154 b->is_nobuf = ((flags & NXT_BUF_SYNC_NOBUF) != 0); 155 b->is_flush = ((flags & NXT_BUF_SYNC_FLUSH) != 0); 156 b->is_last = ((flags & NXT_BUF_SYNC_LAST) != 0); 157 } 158 159 return b; 160 } 161 162 163 void 164 nxt_buf_chain_add(nxt_buf_t **head, nxt_buf_t *in) 165 { 166 nxt_buf_t *b, **prev; 167 168 prev = head; 169 170 for (b = *head; b != NULL; b = b->next) { 171 prev = &b->next; 172 } 173 174 *prev = in; 175 } 176 177 178 size_t 179 nxt_buf_chain_length(nxt_buf_t *b) 180 { 181 size_t length; 182 183 length = 0; 184 185 while (b != NULL) { 186 length += b->mem.free - b->mem.pos; 187 b = b->next; 188 } 189 190 return length; 191 } 192 193 194 static void 195 nxt_buf_completion(nxt_task_t *task, void *obj, void *data) 196 { 197 nxt_mp_t *mp; 198 nxt_buf_t *b, *parent; 199 200 b = obj; 201 parent = data; 202 203 nxt_debug(task, "buf completion: %p %p", b, b->mem.start); 204 205 nxt_assert(data == b->parent); 206 207 mp = b->data; 208 nxt_mp_free(mp, b); 209 210 if (parent != NULL) { 211 nxt_debug(task, "parent retain:%uD", parent->retain); 212 213 parent->retain--; 214 215 if (parent->retain == 0) { 216 parent->mem.pos = parent->mem.free; 217 218 parent->completion_handler(task, parent, parent->parent); 219 } 220 } 221 } 222 223 224 nxt_int_t 225 nxt_buf_ts_handle(nxt_task_t *task, void *obj, void *data) 226 { 227 nxt_buf_t *b; 228 nxt_buf_ts_t *ts; 229 230 b = obj; 231 232 nxt_assert(b->is_ts != 0); 233 234 ts = nxt_pointer_to(b, NXT_BUF_MEM_SIZE); 235 236 if (ts->engine != task->thread->engine) { 237 238 nxt_debug(task, "buf ts: %p current engine is %p, expected %p", 239 b, task->thread->engine, ts->engine); 240 241 ts->work.handler = b->completion_handler; 242 ts->work.obj = obj; 243 ts->work.data = data; 244 245 nxt_event_engine_post(ts->engine, &ts->work); 246 247 return 1; 248 } 249 250 return 0; 251 } 252 253 254 static void 255 nxt_buf_ts_completion(nxt_task_t *task, void *obj, void *data) 256 { 257 nxt_mp_t *mp; 258 nxt_buf_t *b, *parent; 259 260 b = obj; 261 parent = data; 262 263 if (nxt_buf_ts_handle(task, obj, data)) { 264 return; 265 } 266 267 nxt_debug(task, "buf ts completion: %p %p", b, b->mem.start); 268 269 nxt_assert(data == b->parent); 270 271 mp = b->data; 272 nxt_mp_free(mp, b); 273 nxt_mp_release(mp); 274 275 if (parent != NULL) { 276 nxt_debug(task, "parent retain:%uD", parent->retain); 277 278 parent->retain--; 279 280 if (parent->retain == 0) { 281 parent->mem.pos = parent->mem.free; 282 283 parent->completion_handler(task, parent, parent->parent); 284 } 285 } 286 } 287 288 289 nxt_buf_t * 290 nxt_buf_make_plain(nxt_mp_t *mp, nxt_buf_t *src, size_t size) 291 { 292 nxt_buf_t *b, *i; 293 294 if (nxt_slow_path(size == 0)) { 295 for (i = src; i != NULL; i = i->next) { 296 size += nxt_buf_used_size(i); 297 } 298 } 299 300 b = nxt_buf_mem_alloc(mp, size, 0); 301 302 if (nxt_slow_path(b == NULL)) { 303 return NULL; 304 } 305 306 for (i = src; i != NULL; i = i->next) { 307 if (nxt_slow_path(nxt_buf_mem_free_size(&b->mem) 308 < nxt_buf_used_size(i))) 309 { 310 break; 311 } 312 313 b->mem.free = nxt_cpymem(b->mem.free, i->mem.pos, nxt_buf_used_size(i)); 314 } 315 316 return b; 317 } 318