diff options
Diffstat (limited to 'src/shctx.c')
| -rw-r--r-- | src/shctx.c | 355 |
1 files changed, 355 insertions, 0 deletions
diff --git a/src/shctx.c b/src/shctx.c new file mode 100644 index 0000000..d114d46 --- /dev/null +++ b/src/shctx.c @@ -0,0 +1,355 @@ +/* + * shctx.c - shared context management functions for SSL + * + * Copyright (C) 2011-2012 EXCELIANCE + * + * Author: Emeric Brun - emeric@exceliance.fr + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version + * 2 of the License, or (at your option) any later version. + */ + +#include <sys/mman.h> +#include <arpa/inet.h> +#include <import/ebmbtree.h> +#include <haproxy/list.h> +#include <haproxy/shctx.h> + +int use_shared_mem = 0; + +/* + * Reserve a new row if <first> is null, put it in the hotlist, set the refcount to 1 + * or append new blocks to the row with <first> as first block if non null. + * + * Reserve blocks in the avail list and put them in the hot list + * Return the first block put in the hot list or NULL if not enough blocks available + */ +struct shared_block *shctx_row_reserve_hot(struct shared_context *shctx, + struct shared_block *first, int data_len) +{ + struct shared_block *last = NULL, *block, *sblock, *ret = NULL, *next; + int enough = 0; + int freed = 0; + int remain; + + BUG_ON(data_len < 0); + + /* not enough usable blocks */ + if (data_len > shctx->nbav * shctx->block_size) + goto out; + + /* Check the object size limit. */ + if (shctx->max_obj_size > 0) { + if ((first && first->len + data_len > shctx->max_obj_size) || + (!first && data_len > shctx->max_obj_size)) + goto out; + } + + /* Note that <remain> is nul only if <first> is not nul. */ + remain = 1; + if (first) { + /* Check that there is some block to reserve. + * In this first block of code we compute the remaining room in the + * current list of block already reserved for this object. + * We return asap if there is enough room to copy <data_len> bytes. + */ + last = first->last_reserved; + /* Remaining room. */ + remain = (shctx->block_size * first->block_count - first->len); + if (remain) { + if (remain > data_len) { + return last ? last : first; + } else { + data_len -= remain; + if (data_len <= 0) + return last ? last : first; + } + } + } + + while (!enough && !LIST_ISEMPTY(&shctx->avail)) { + int count = 0; + int first_count = 0, first_len = 0; + + next = block = LIST_NEXT(&shctx->avail, struct shared_block *, list); + if (ret == NULL) + ret = next; + + first_count = next->block_count; + first_len = next->len; + /* + Should never been set to 0. + if (next->block_count == 0) + next->block_count = 1; + */ + + list_for_each_entry_safe_from(block, sblock, &shctx->avail, list) { + + /* release callback */ + if (first_len && shctx->free_block) + shctx->free_block(next, block); + + block->block_count = 1; + block->len = 0; + + freed++; + + BUG_ON(data_len < 0); + data_len -= shctx->block_size; + + if (data_len > 0 || !enough) { + if (last) { + shctx_block_append_hot(shctx, &last->list, block); + last = block; + } else { + shctx_block_set_hot(shctx, block); + } + if (!remain) { + first->last_append = block; + remain = 1; + } + if (data_len <= 0) { + ret->block_count = freed; + ret->refcount = 1; + ret->last_reserved = block; + enough = 1; + break; + } + } + count++; + if (count >= first_count) + break; + } + } + + if (first) { + first->block_count += ret->block_count; + first->last_reserved = ret->last_reserved; + /* Reset this block. */ + ret->last_reserved = NULL; + ret->block_count = 1; + ret->refcount = 0; + /* Return the first block. */ + ret = first; + } + +out: + return ret; +} + +/* + * if the refcount is 0 move the row to the hot list. Increment the refcount + */ +void shctx_row_inc_hot(struct shared_context *shctx, struct shared_block *first) +{ + struct shared_block *block, *sblock; + int count = 0; + + if (first->refcount <= 0) { + + block = first; + + list_for_each_entry_safe_from(block, sblock, &shctx->avail, list) { + + shctx_block_set_hot(shctx, block); + + count++; + if (count >= first->block_count) + break; + } + } + + first->refcount++; +} + +/* + * decrement the refcount and move the row at the end of the avail list if it reaches 0. + */ +void shctx_row_dec_hot(struct shared_context *shctx, struct shared_block *first) +{ + struct shared_block *block, *sblock; + int count = 0; + + first->refcount--; + + if (first->refcount <= 0) { + + block = first; + + list_for_each_entry_safe_from(block, sblock, &shctx->hot, list) { + + shctx_block_set_avail(shctx, block); + + count++; + if (count >= first->block_count) + break; + } + } + +} + + +/* + * Append data in the row if there is enough space. + * The row should be in the hot list + * + * Return the amount of appended data if ret >= 0 + * or how much more space it needs to contains the data if < 0. + */ +int shctx_row_data_append(struct shared_context *shctx, + struct shared_block *first, struct shared_block *from, + unsigned char *data, int len) +{ + int remain, start; + struct shared_block *block; + + /* return -<len> needed to work */ + if (len > first->block_count * shctx->block_size - first->len) + return (first->block_count * shctx->block_size - first->len) - len; + + block = from ? from : first; + list_for_each_entry_from(block, &shctx->hot, list) { + /* end of copy */ + if (len <= 0) + break; + + /* remaining written bytes in the current block. */ + remain = (shctx->block_size * first->block_count - first->len) % shctx->block_size; + BUG_ON(remain < 0); + + /* if remain == 0, previous buffers are full, or first->len == 0 */ + if (!remain) { + remain = shctx->block_size; + start = 0; + } + else { + /* start must be calculated before remain is modified */ + start = shctx->block_size - remain; + BUG_ON(start < 0); + } + + /* must not try to copy more than len */ + remain = MIN(remain, len); + + memcpy(block->data + start, data, remain); + + data += remain; + len -= remain; + first->len += remain; /* update len in the head of the row */ + first->last_append = block; + } + + return len; +} + +/* + * Copy <len> data from a row of blocks, return the remaining data to copy + * If 0 is returned, the full data has successfully been copied + * + * The row should be in the hot list + */ +int shctx_row_data_get(struct shared_context *shctx, struct shared_block *first, + unsigned char *dst, int offset, int len) +{ + int count = 0, size = 0, start = -1; + struct shared_block *block; + + /* can't copy more */ + if (len > first->len) + len = first->len; + + block = first; + count = 0; + /* Pass through the blocks to copy them */ + list_for_each_entry_from(block, &shctx->hot, list) { + if (count >= first->block_count || len <= 0) + break; + + count++; + /* continue until we are in right block + corresponding to the offset */ + if (count < offset / shctx->block_size + 1) + continue; + + /* on the first block, data won't possibly began at offset 0 */ + if (start == -1) + start = offset - (count - 1) * shctx->block_size; + + BUG_ON(start < 0); + + /* size can be lower than a block when copying the last block */ + size = MIN(shctx->block_size - start, len); + BUG_ON(size < 0); + + memcpy(dst, block->data + start, size); + dst += size; + len -= size; + start = 0; + } + return len; +} + +/* Allocate shared memory context. + * <maxblocks> is maximum blocks. + * If <maxblocks> is set to less or equal to 0, ssl cache is disabled. + * Returns: -1 on alloc failure, <maxblocks> if it performs context alloc, + * and 0 if cache is already allocated. + */ +int shctx_init(struct shared_context **orig_shctx, int maxblocks, int blocksize, + unsigned int maxobjsz, int extra, int shared) +{ + int i; + struct shared_context *shctx; + int ret; + void *cur; + int maptype = MAP_PRIVATE; + + if (maxblocks <= 0) + return 0; + + /* make sure to align the records on a pointer size */ + blocksize = (blocksize + sizeof(void *) - 1) & -sizeof(void *); + extra = (extra + sizeof(void *) - 1) & -sizeof(void *); + + if (shared) { + maptype = MAP_SHARED; + use_shared_mem = 1; + } + + shctx = (struct shared_context *)mmap(NULL, sizeof(struct shared_context) + extra + (maxblocks * (sizeof(struct shared_block) + blocksize)), + PROT_READ | PROT_WRITE, maptype | MAP_ANON, -1, 0); + if (!shctx || shctx == MAP_FAILED) { + shctx = NULL; + ret = SHCTX_E_ALLOC_CACHE; + goto err; + } + + HA_SPIN_INIT(&shctx->lock); + shctx->nbav = 0; + + LIST_INIT(&shctx->avail); + LIST_INIT(&shctx->hot); + + shctx->block_size = blocksize; + shctx->max_obj_size = maxobjsz == (unsigned int)-1 ? 0 : maxobjsz; + + /* init the free blocks after the shared context struct */ + cur = (void *)shctx + sizeof(struct shared_context) + extra; + for (i = 0; i < maxblocks; i++) { + struct shared_block *cur_block = (struct shared_block *)cur; + cur_block->len = 0; + cur_block->refcount = 0; + cur_block->block_count = 1; + LIST_APPEND(&shctx->avail, &cur_block->list); + shctx->nbav++; + cur += sizeof(struct shared_block) + blocksize; + } + ret = maxblocks; + +err: + *orig_shctx = shctx; + return ret; +} + |