// addition of modulus of bigInts without saving first bigInt
bigInt *add_modulus_fast(bigInt *first, const bigInt *second) {
int transfer = 0;
int digit_index;
for(digit_index = 0; digit_index < second->length; digit_index++) {
transfer = add_overflow(first->digits + digit_index, second->digits[digit_index] + transfer, first->radix);
}
while(transfer) {
transfer = add_overflow(first->digits + digit_index, transfer, first->radix);
digit_index++;
}
first->length = digit_index;
return first;
}
void *lwan_array_append(struct lwan_array *a, size_t element_size)
{
if (!(a->elements % INCREMENT)) {
void *new_base;
size_t new_cap;
if (UNLIKELY(add_overflow(a->elements, INCREMENT, &new_cap))) {
errno = EOVERFLOW;
return NULL;
}
new_base = reallocarray(a->base, new_cap, element_size);
if (UNLIKELY(!new_base))
return NULL;
a->base = new_base;
}
return ((unsigned char *)a->base) + a->elements++ * element_size;
}
void PagerSource::QueueMessageLocked(page_request_t* request) {
if (packet_busy_) {
list_add_tail(&pending_requests_, &request->node);
return;
}
packet_busy_ = true;
active_request_ = request;
uint64_t offset, length;
uint16_t cmd;
if (request != &complete_request_) {
cmd = ZX_PAGER_VMO_READ;
offset = request->offset;
length = request->length;
// The vm subsystem should guarantee this
uint64_t unused;
DEBUG_ASSERT(!add_overflow(offset, length, &unused));
} else {
offset = length = 0;
cmd = ZX_PAGER_VMO_COMPLETE;
}
zx_port_packet_t packet = {};
packet.key = key_;
packet.type = ZX_PKT_TYPE_PAGE_REQUEST;
packet.page_request.command = cmd;
packet.page_request.offset = offset;
packet.page_request.length = length;
packet_.packet = packet;
// We can treat ZX_ERR_BAD_STATE as if the packet was queued
// but the pager service never responds.
// TODO: Bypass the port's max queued packet count to prevent ZX_ERR_SHOULD_WAIT
ASSERT(port_->Queue(&packet_, ZX_SIGNAL_NONE, 0) != ZX_ERR_SHOULD_WAIT);
}
struct queue *queue_init(int size)
{
struct queue *queue = malloc(sizeof(struct queue));
if(queue == NULL)
MEM_ERROR();
if(add_overflow(size, 1) ||
multiply_overflow(size + 1, sizeof(void *)))
BAD_ERROR("Size too large in queue_init\n");
queue->data = malloc(sizeof(void *) * (size + 1));
if(queue->data == NULL)
MEM_ERROR();
queue->size = size + 1;
queue->readp = queue->writep = 0;
pthread_mutex_init(&queue->mutex, NULL);
pthread_cond_init(&queue->empty, NULL);
pthread_cond_init(&queue->full, NULL);
return queue;
}
