haiku.git

/*
 * Copyright 2007 Oliver Ruiz Dorantes, oliver.ruiz.dorantes_at_gmail.com
 *
 * All rights reserved. Distributed under the terms of the MIT License.
 *
 */


#include "snet_buffer.h"

#include <malloc.h>
#include <string.h>
#include <KernelExport.h>


struct snet_buffer {
	struct list_link	link;

	uint8*				buffer;

	uint16				allocatedSize;
	uint16				expectedSize;
	uint16				puttingSize;
	uint16				pullingSize;

	void*				cookie;
};


snet_buffer*
snb_create(uint16 size)
{
	// TODO: pointer checking

#ifdef SNB_BUFFER_ATTACHED
	// Allocating these 2 buffers together might prevent memory fragmentation
	snet_buffer* snb = (snet_buffer*) malloc(sizeof(snet_buffer) + size);
	snb->buffer = ((uint8*)snb) + sizeof(snet_buffer);
#else
	snet_buffer* snb = malloc(sizeof (snet_buffer));
	snb->buffer = malloc(size);
#endif

	snb->pullingSize = snb->puttingSize = 0;
	snb->expectedSize = snb->allocatedSize = size;

	return snb;
}


void
snb_put(snet_buffer* snb, void* data, uint16 size)
{
	// TODO: check overflow
	memcpy( &snb->buffer[snb->puttingSize], data, size);
	snb->puttingSize+=size;
}


void*
snb_pull(snet_buffer* snb, uint16 size)
{
	// TODO: check overflow
	snb->pullingSize+=size;
	return &snb->buffer[snb->pullingSize - size];
	
}


void
snb_reset(snet_buffer* snb)
{
	snb->puttingSize = snb->pullingSize = 0;
}


void
snb_free(snet_buffer* snb)
{
	if (snb == NULL)
		return;

#ifdef SNB_BUFFER_ATTACHED
	free(snb);
#else
	free(snb->buffer);
	free(snb);
#endif

}


void*
snb_get(snet_buffer* snb)
{
	// TODO: pointer checking
	return snb->buffer;
}


uint16
snb_size(snet_buffer* snb)
{
	// TODO: pointer checking
	return snb->expectedSize;
}


void*
snb_cookie(snet_buffer* snb)
{
	// TODO: pointer checking
	return snb->cookie;
}


void
snb_set_cookie(snet_buffer* snb, void* cookie)
{
	// TODO: pointer checking
	snb->cookie = cookie;
}


// Return true if we canot "put" more data in the buffer
bool
snb_completed(snet_buffer* snb)
{
	return (snb->expectedSize == snb->puttingSize);
}


// Return true if we cannot pull more more data from the buffer
bool
snb_finished(snet_buffer* snb)
{
	return (snb->expectedSize == snb->pullingSize);
}


uint16
snb_remaining_to_put(snet_buffer* snb)
{
	return (snb->expectedSize - snb->puttingSize);
}


uint16
snb_remaining_to_pull(snet_buffer* snb)
{
	return (snb->expectedSize - snb->pullingSize);
}

/*
	ISSUE1: Number of packets in the worst case(we always need a bigger 
	buffer than before) increases, never decreases:

	SOL1: Delete the smallest when the queue is bigger than X elements 
	SOL2: ? 

	ISSUE2: If the queue is not gonna be used for long time. Memory c
	ould be freed

	SOL1: Provide purge func.
	SOL2: ?
*/


static snet_buffer*
snb_attempt_reuse(snet_buffer* snb, uint16 size)
{
	if (snb == NULL || (snb->allocatedSize < size)) {

		// Impossible or not worth, Creating a new one
		snb_free(snb);
		return snb_create(size);

	} else {
		snb_reset(snb);
		snb->expectedSize = size;
		return snb;
	}

}


void
snb_park(struct list* l, snet_buffer* snb)
{
	snet_buffer* item = NULL;

	// insert it by order
	while ((item = (snet_buffer*)list_get_next_item(l, item)) != NULL) {
		// This one has allocated more than us place us back
		if (item->allocatedSize > snb->allocatedSize) {
			list_insert_item_before(l, item, snb);
			return;
		}
	}
	// no buffer bigger than us(or empty).. then at the end
	list_add_item(l, snb);
}


snet_buffer*
snb_fetch(struct list* l, uint16 size)
{
	snet_buffer* item = NULL;
	snet_buffer* newitem = NULL;

	if (!list_is_empty(l))
	while ((item = (snet_buffer*)list_get_next_item(l, item)) != NULL) {
		if (item->allocatedSize >= size) {
			// This one is for us
			break;
		}
	}
	
	newitem = snb_attempt_reuse(item, size); 
	
	/* the resulting reused one is the same 
	 * as we fetched? => remove it from list
	 */
	if (item == newitem) {
		list_remove_item(l, item);
	}

	return newitem;
}


uint16
snb_packets(struct list* l)
{
	uint16 count = 0;
	snet_buffer* item = NULL;
	
	while ((item = (snet_buffer*)list_get_next_item(l, item)) != NULL)
		count++;
	
	return count;
}


void
snb_dump(snet_buffer* snb)
{
	kprintf("item=%p\tprev=%p\tnext=%p\tallocated=%d\n", snb, snb->link.prev,
		snb->link.next, snb->allocatedSize);
}