SWAMPy

✎ CARVE FLESH

EDITING: chunkbuf.c

#include "osapi.h"
#include "chunkbuf.h"
#include "debug.h"

#define MAX_CPUS_PER_CB (4)

// Use care when changing -- the microverifier depends on these values.
#define CHUNK_SIZE PAGE_SIZE
#define MAX_CHUNKS ((8*1024*1024)/PAGE_SIZE)
#ifdef _SOLARIS
#define MIN_CHUNKS MAX_CHUNKS
#else
#define MIN_CHUNKS ((64*1024)/PAGE_SIZE)
#endif

typedef struct {
    int chunk;
    unsigned int pos;
} chunk_pos_t;

typedef struct {
    chunk_pos_t position;
    unsigned int readable_bytes;
} read_state_t;

typedef struct {
    bs_spinlock_t buffer_lock;

chunk_pos_t active_write;
    read_state_t active_read, read_transaction;
    unsigned int highwater;
    unsigned int total_events;
    unsigned int chunk_allocs, chunk_frees;
    unsigned int total_reads, spanning_reads;

u64 total_bytes;
    char* chunk_array[MAX_CHUNKS];
} chunkbuf_t;

/*
 * This data type is used for tracking the "total" alloc/free
 * activity across all the chunkbufs for generating driver stats.
 *
 * Assumptions:
 * 1. In the driver stats reporting time period, the allocs or frees for an
 *    individual chunkbuf will not exceed the max value for unsigned int.
 * 2. The sum of the changes in the allocs or frees in a reporting period,
 *    totaled across all chunkbufs, will not exceed the max value for unsigned int.
 *
 * Given the above assumptions, modulo mathematics ensure the total allocs and frees
 * reported for a period will be correct.
 */
typedef struct {
    unsigned int allocs, frees;
} alloc_stats_t;

#define NEXT_CHUNK(idx) ((idx+1) % MAX_CHUNKS)
#define ADVANCE_TO_NEXT_CHUNK(idx_ptr) (*(idx_ptr) = NEXT_CHUNK(*(idx_ptr)))
// NOTE: See cb_internal_write_data. The active write position is not
// allowed to wrap around and write behind the active read position on the
// same chunk. Therefore, the two chunk number can only be the same
// when less than one chunk of data was consumed.
#define CHUNK_DISTANCE(from, to) (((to) + MAX_CHUNKS - (from)) % MAX_CHUNKS)
#define ADVANCE_TO_NEXT_CB(idx_ptr)  (*(idx_ptr) = (*(idx_ptr) + 1) & cb_mask)

static chunkbuf_t* *cb_array;
static notify_readable_func notify_readable;
static unsigned cb_read_index;
static unsigned cb_mask;
static atomic_t cb_write_index, missed_events, total_readable_bytes;
static alloc_stats_t total_previous;

#define NUMBER_OF_CHUNKBUFS (cb_mask + 1)

// Initialize the chunkbuffer
// @param nfunc - a callback invoked when data is available to be read [optional]
static chunkbuf_t* cb_internal_init(void) {
	int i;
	chunkbuf_t *cb;
	cb = (chunkbuf_t*)kernel_malloc(sizeof(chunkbuf_t));
	if (cb == NULL) {
		err_msg("msda: chunkbuf initialization failed, memory unavailable");
		return NULL;
	}

(void)bzero((void*)cb, (size_t)sizeof(chunkbuf_t));

for (i=0;i<MIN_CHUNKS; i++) {
		cb->chunk_array[i] = (char*)kernel_page_alloc(KPAGE_DEFAULT);
		if (cb->chunk_array[i] == NULL) {
			err_msg("msda: chunkbuf page allocation failure (chunk %d)", i);
			while (i) {
				kernel_page_free(cb->chunk_array[i-1], KPAGE_DEFAULT);
				cb->chunk_array[i-1] = NULL;
				i--;
			}
			kernel_free(cb);
			return NULL;
		}
	}
	// the bzero above ensures all other chunk_array elements are NULL
	
	bs_init_spinlock(&cb->buffer_lock);
	return cb;
}

static void clear_buffer(chunkbuf_t* cb) {
	int i;	
	for (i=0; i<MAX_CHUNKS; i++) {
		if (cb->chunk_array[i] != 0) kernel_page_free(cb->chunk_array[i], KPAGE_DEFAULT);
		cb->chunk_array[i] = 0;
	}
	
	cb->active_write.chunk = 0;
	cb->active_write.pos = 0;

cb->active_read.position.chunk = 0;
	cb->active_read.position.pos = 0;
	cb->active_read.readable_bytes = 0;
}

// Destroy the chunkbuffer
void cb_internal_destroy(chunkbuf_t* cb) {
	if (cb == NULL) return;

bs_acquire_spinlock(&cb->buffer_lock);
	{
		// Once we've gotten this lock,
		// any outstanding operations have completed
	}
	bs_release_spinlock(&cb->buffer_lock);

dbg_msg("msda: cb Highwater=%u bytes Dynamic allocs=%u frees=%u",
			cb->highwater, cb->chunk_allocs, cb->chunk_frees);
	dbg_msg("msda: cb Events: Total=%u Bytes=%llu", cb->total_events, (unsigned long long)cb->total_bytes);
	dbg_msg("msda: cb Reads:  Total=%u Spans=%u", cb->total_reads,  cb->spanning_reads);
	clear_buffer(cb);
	bs_destroy_spinlock(&cb->buffer_lock);
	kernel_free(cb);		
}

static void cb_internal_start_read(chunkbuf_t* cb) {
    dbg_msg("msda %p: cb_internal_start_read (%d, %u, %u)",
            cb,
            cb->active_read.position.chunk, cb->active_read.position.pos,
            cb->active_read.readable_bytes);
    cb->read_transaction = cb->active_read;
}

// MUST
// * call cb_internal_start_read
// * call cb_internal_read_data zero or more times
// * call cb_internal_commit_read to complete the read transaction
//
// NOTE:
// if -EINVAL is returned, the transaction may be aborted by not calling cb_internal_commit_read
//
// Read data into the buffer specified by the user
// @param buffer - the user space buffer into which data will be read
// @param buflen - the size of the data buffer, in bytes
// @param copier - the function used to copy data from the chunkbuffer address space into the supplied buffer
static int cb_internal_read_data(chunkbuf_t* cb, char *buffer, size_t buflen, copyfunc copier) {
	int rem_to_copy, copied=0, bytes_to_end, to_copy;

if (unlikely(cb->read_transaction.readable_bytes < sizeof(event_common_hdr_t))) {
		dbg_msg("msda %p: read from empty chunkbuf", cb);
		return -EAGAIN;
	}
	cb->total_reads++;

dbg_msg("msda %p: begin read(%u), rd chunk=%d pos=%u readable=%u",
			  cb, (unsigned int) buflen,
			  cb->read_transaction.position.chunk, cb->read_transaction.position.pos, cb->read_transaction.readable_bytes);
	/*
	 * Microevents sizes are always rounded up to a multiple of 8, the size of the event_common_hdr_t.
	 * The CHUNK_SIZE is also a multiple of 8. Chunks are aligned on memory addresses that are a multiple of 8.
	 * So, we can safely peek at the current read position as a event_common_hdr_t to get the microevent size.
	 */
	rem_to_copy = (int) (unsigned int) (((event_common_hdr_t *) (cb->chunk_array[cb->read_transaction.position.chunk] + cb->read_transaction.position.pos))->eventsz);
	// cb->read_transaction.readable_bytes better be >= the event size!
	if (unlikely(buflen < rem_to_copy)) {
		dbg_msg("msda %p: buflen too small (%d < %d)", cb, (int) buflen, rem_to_copy);
		return -EMSGSIZE;
	}

while (rem_to_copy > 0) {
		bytes_to_end = CHUNK_SIZE - cb->read_transaction.position.pos;
		to_copy = MIN(bytes_to_end, rem_to_copy);
		if (unlikely(copier(buffer, cb->chunk_array[cb->read_transaction.position.chunk] + cb->read_transaction.position.pos, to_copy, copied))) {
			err_msg("msda: copy to userspace failed");
			return -EINVAL;
		}

copied += to_copy;
		cb->read_transaction.position.pos += to_copy;
		rem_to_copy -= to_copy;

if (cb->read_transaction.position.pos >= CHUNK_SIZE) {
			ADVANCE_TO_NEXT_CHUNK(&cb->read_transaction.position.chunk);
			cb->read_transaction.position.pos = 0;
			if (rem_to_copy > 0) cb->spanning_reads++;
		}
	}

cb->read_transaction.readable_bytes -= copied;

dbg_msg("msda %p: read complete %d bytes, rd chunk=%d pos=%u",
			  cb, copied, cb->read_transaction.position.chunk, cb->read_transaction.position.pos);

return copied;
}

#define CB_NO_RECLAIM (0)
#define CB_RECLAIM (1)
#define CB_RECYCLE (2)

// must be called with cb spinlock held
// returns:
//  CB_NO_RECLAIM - nothing to do, leave chunks where they are
//  CB_RECYCLE - number_of_unused_chunks and free_slot are set and should be used to recycle blocks
//               after reaching the recycling limit, treat as CB_RECLAIM;
//  CB_RECLAIM - unused chunks should be reclaimed.
static int find_free_slot(chunkbuf_t* cb, int *number_of_unused_chunks, int *free_slot) {
    int count = 0;
    int slot = cb->active_write.chunk;
    int action = CB_RECLAIM;

do {
        ADVANCE_TO_NEXT_CHUNK(&slot);

// head bite tail
        if (unlikely(slot == cb->active_read.position.chunk)) {
            action = CB_NO_RECLAIM;
            break;
        }

// found an empty
        if (cb->chunk_array[slot] == NULL) {
            action =  CB_RECYCLE;
            break;
        }
    } while (++count < MIN_CHUNKS);

*free_slot = slot;
    *number_of_unused_chunks = count;

return action;
}

static void cb_internal_commit_read(chunkbuf_t* cb) {
    // move the active_read position to the read_transaction position
    dbg_msg("msda %p: commit read (%d, %d) -> (%d, %d)",
            cb,
            cb->active_read.position.chunk, cb->active_read.position.pos,
            cb->read_transaction.position.chunk, cb->read_transaction.position.pos);
    bs_acquire_spinlock(&cb->buffer_lock);
    {
        int chunks_consumed = CHUNK_DISTANCE(cb->active_read.position.chunk, cb->read_transaction.position.chunk);

if (chunks_consumed > 0) {
            int empty_slot, number_of_unused_chunks;
            int action = find_free_slot(cb, &number_of_unused_chunks, &empty_slot);
            dbg_msg("msda %p: %d = find_free_slot(..., %d, %d); MIN_CHUNKS = %d",
                    cb,
                    action, number_of_unused_chunks, empty_slot,
                    (int) MIN_CHUNKS);
            // if active_write is close to active_read, there may be no empty slots
            if (likely(action != CB_NO_RECLAIM)) {
                int chunk = cb->active_read.position.chunk;
                int stop_chunk = cb->read_transaction.position.chunk;
                if (action == CB_RECYCLE) {
                    // recycle until we have enough free
                    for ( ; number_of_unused_chunks < MIN_CHUNKS && chunk != stop_chunk; number_of_unused_chunks++) {
                        cb->chunk_array[empty_slot] = cb->chunk_array[chunk];
                        cb->chunk_array[chunk] = NULL;
                        ADVANCE_TO_NEXT_CHUNK(&empty_slot);
                        ADVANCE_TO_NEXT_CHUNK(&chunk);
                    }
                }
                // release any additional
                for ( ; chunk != stop_chunk; ) {
                    kernel_page_free(cb->chunk_array[chunk], KPAGE_DEFAULT);
                    cb->chunk_array[chunk] = NULL;
                    cb->chunk_frees++;
                    ADVANCE_TO_NEXT_CHUNK(&chunk);
                }
            }
        }

// bytes_consumed = CHUNK_SIZE * ((transaction chunk - active chunk) mod MAX_CHUNKS) - active pos + transaction pos
        cb->active_read.readable_bytes -=
            (CHUNK_SIZE * chunks_consumed)
            - cb->active_read.position.pos
            + cb->read_transaction.position.pos;
        cb->active_read.position = cb->read_transaction.position;
    }
    bs_release_spinlock(&cb->buffer_lock);
}

static void increment_missed_events(void) {
    // prevent overflow even if every chunkbuf is updated simultaneously
    int current_missed_events = atomic_read(&missed_events);
    if (current_missed_events < (INT_MAX - NUMBER_OF_CHUNKBUFS)) {
        atomic_inc(&missed_events);
    }
}

static inline void maybe_wake_reader(int wake_reader, int bytes) {
    if (wake_reader & BS_WAKE_READER) {
        notify_readable(wake_reader, bytes); // wake up anyone in select
    }
}

static inline void wake_reader_for_error(void) {
    notify_readable(BS_WAKE_READER | BS_WAKE_ERROR, INT_MAX);
}

// Write the specified data into the chunk buffer
static int cb_internal_write_data(chunkbuf_t* cb, void* vdata, size_t sz, int wake_reader) {
    int space_to_end, to_copy, written=0;
    char* data=(char*)vdata;
    bs_acquire_spinlock(&cb->buffer_lock);
    {
        if (unlikely((cb->active_read.readable_bytes+sz > MAX_CHUNKS*CHUNK_SIZE) || atomic_read(&missed_events))) {
            increment_missed_events();
            bs_release_spinlock(&cb->buffer_lock);
            wake_reader_for_error();
            return -1;
        }

while (sz > 0) {
            space_to_end = CHUNK_SIZE - cb->active_write.pos;
            to_copy = MIN(space_to_end, sz);
            memcpy(cb->chunk_array[cb->active_write.chunk]+cb->active_write.pos, &data[written], to_copy);
            sz -= to_copy;
            cb->active_write.pos += to_copy;
            written += to_copy;

if (cb->active_write.pos >= CHUNK_SIZE) {

/* DATA CORRECTNESS NOTE:
                 * Any of the error/overflow code paths that call increment_missed_events()
                 * make no attempt to unwind the active writing position. The number of
                 * bytes available to read is valid if we should ever decide to drain
                 * the buffer of all valid data before indicating the error condition
                 * to the reader.
                 */
                if (NEXT_CHUNK(cb->active_write.chunk) == cb->active_read.position.chunk) {
                    increment_missed_events();
                    bs_release_spinlock(&cb->buffer_lock);
                    wake_reader_for_error();
                    return -1;
                }

ADVANCE_TO_NEXT_CHUNK(&cb->active_write.chunk);
                cb->active_write.pos = 0;
                if (cb->chunk_array[cb->active_write.chunk] == 0) {
                    cb->chunk_array[cb->active_write.chunk] = kernel_page_alloc(KPAGE_DEFAULT);
                    if (unlikely(cb->chunk_array[cb->active_write.chunk] == 0)) {
                        err_msg("msda: failure to allocate additional buffer space (in use=%d)", cb->active_read.readable_bytes);
                        increment_missed_events();
                        bs_release_spinlock(&cb->buffer_lock);
                        wake_reader_for_error();
                        return -1;
                    }
                    cb->chunk_allocs++;
                }
            }
        }

// always keep the global number smaller than what may be seen by traversing all the chunkbufs
        cb->active_read.readable_bytes += written;
        smp_mb();
        atomic_add(written, &total_readable_bytes);
        cb->total_bytes += written;
        cb->total_events++;
        if (cb->active_read.readable_bytes > cb->highwater) {
            // For debugging purposes, log whenever the new highwater mark exceeds the next 256K boundary
            if (debug) {
                if ((cb->active_read.readable_bytes >> 18) - (cb->highwater >> 18)) {
                    dbg_msg("msda: driver highwater reached %d bytes", cb->active_read.readable_bytes);
                }
            }
            cb->highwater = cb->active_read.readable_bytes;
        }

}
    bs_release_spinlock(&cb->buffer_lock);

maybe_wake_reader(wake_reader, atomic_read(&total_readable_bytes));

return written;
}

static void destroy_cbs(chunkbuf_t *cbs[], int how_many) {
    while (--how_many >= 0) {
        cb_internal_destroy(cbs[how_many]);
    }
}

static int build_cb_collection(int how_many) {
    int idx;

cb_array = kernel_malloc(sizeof(cb_array[0]) * how_many);
    if (cb_array == NULL) {
        err_msg("msda: chunkbuf collection initialization failed, memory unavailable");
        return 0;
    }

for (idx = 0; idx < how_many; idx++) {
        cb_array[idx] = cb_internal_init();
        if (cb_array[idx] == NULL) {
            destroy_cbs(cb_array, idx);
            kernel_free(cb_array);
            cb_array = NULL;
            return 0;
        }
    }

return 1;
}

static int compute_cpu_mask(void) {
    unsigned int mask = 1;
    unsigned int cpus = number_of_cpus();
    // scale by the max CPUs per chunkbuf
    unsigned int cpu_scaling = cpus / MAX_CPUS_PER_CB;

// find minimum power of two >= the minimum number of chunkbufs
    while (mask < cpu_scaling) { mask <<= 1; }

dbg_msg("msda: chunkbuf config: CPUs=%u cb_make=%u", cpus, mask);

// 2s complement math to create a bit mask that will implement modulo math
    return (int) (mask - 1);
}

int cb_init(notify_readable_func nfunc) {
    cb_mask = compute_cpu_mask();
    // Because the atomic increment returns the post-increment value, the
    // write counter needs to be initialized to one less than the read index.
    // Note: In a small machine, there may only be one chunkbuf, and the index
    // will repeatedly be zero.
    cb_read_index = 0;
    atomic_set(&cb_write_index, ((int) cb_read_index) - 1);
    atomic_set(&missed_events, 0);
    atomic_set(&total_readable_bytes, 0);
    total_previous.allocs = 0;
    total_previous.frees = 0;

if (! build_cb_collection(NUMBER_OF_CHUNKBUFS)) {
        return 0;
    }

notify_readable = nfunc;

return 1;
}

void cb_destroy(void) {
    if (cb_array != NULL) {
        destroy_cbs(cb_array, NUMBER_OF_CHUNKBUFS);
        kernel_free(cb_array);
        cb_array = NULL;
    }
}

int cb_read_data(char *buffer, size_t buflen, copyfunc copier) {
    unsigned cb_read_count = 0;
    unsigned first_cb_index = cb_read_index;
    unsigned cb_index = first_cb_index;
    int bytes_to_read = atomic_read(&total_readable_bytes);
    int local_missed_events = atomic_read(&missed_events);
    char *write_ptr = buffer;

if (unlikely(local_missed_events > 0)) {
        err_msg("msda: overflow detected - %d events lost", local_missed_events);
        return 0;
    }

if (unlikely(buflen < sizeof(event_common_hdr_t))) {
        return -EMSGSIZE;
    }

if (unlikely(bytes_to_read < sizeof(event_common_hdr_t))) {
        dbg_msg("msda: read from empty chunkbuf (%d)", bytes_to_read);
        return -EAGAIN;
    }

// don't read more data than was available when we started
    // this helps prevent race conditions with the writers
    if (bytes_to_read < buflen) {
        buflen = (unsigned int) bytes_to_read;
    }

while (likely(buflen >= sizeof(event_common_hdr_t))) {
        int bytes;
        chunkbuf_t *cb = cb_array[cb_index];
        // first time looking at this cb, start a read transaction
        if (cb_read_count <= cb_mask) {
            cb_internal_start_read(cb);
        }
        bytes = cb_internal_read_data(cb, write_ptr, buflen, copier);
        if (likely(bytes > 0)) {
            write_ptr += bytes;
            buflen -= bytes;
            ADVANCE_TO_NEXT_CB(&cb_index);
            cb_read_count++;
        }
        else if (bytes == -EAGAIN) {
            // no more data available
            if (write_ptr > buffer) {
                break; // good enough
            }
            dbg_msg("msda: read from exhausted chunkbuf");
            return -EAGAIN;
        }
        else if (bytes == -EMSGSIZE) {
            // there is data, but it is too big to fit in the buffer
            if (write_ptr > buffer) {
                break; // good enough
            }
            return -EMSGSIZE;
        }
        else if (bytes < 0) {
            // other error
            return bytes;
        }
        else {
            // EOF (i.e. == 0)
            break;
        }
    }

// commit the reads
    {
        int total_bytes_read = write_ptr - buffer;

// Because we're in the read path, we can wait until the end to reduce the total
        atomic_sub(total_bytes_read, &total_readable_bytes);

{
            // do the commits in the same order
            // if every cb was read at least once, then do the commit only once per cb
            int last_cb_index = (cb_read_count > cb_mask) ? first_cb_index : cb_index ;
            dbg_msg("msda: cb_read_data commit: count=%d mask=%d index=%d first=%d last=%d",
                    cb_read_count, cb_mask, cb_index, first_cb_index, last_cb_index);
            do {
                cb_internal_commit_read(cb_array[first_cb_index]);
                ADVANCE_TO_NEXT_CB(&first_cb_index);
            } while (first_cb_index != last_cb_index);
            cb_read_index = cb_index;
        }

return total_bytes_read;
    }

#define WRITE_INDEX_WRAP    (1 << 30)
    // Being extra careful about overflow.
    // Doing this here because the read path run far less often than the write path
    // and don't want to add overhead on the monitored applications threads.
    // ((i - n) mod m) == (i mod m) whenever (n mod m) == 0
    // The number of chunkbufs, (NUMBER_OF_CHUNKBUFS), is a power of two.
    // Therefore, any power of 2 > NUMBER_OF_CHUNKBUFS is suitable for n.
    if (unlikely(atomic_read(&cb_write_index) >= WRITE_INDEX_WRAP)) {
        atomic_sub(WRITE_INDEX_WRAP, &cb_write_index);
    }
}

static unsigned get_next_write_cb_index(void) {
    unsigned idx = (unsigned) atomic_inc_return(&cb_write_index);

return idx & cb_mask;
}

int cb_write_microevent(event_common_hdr_t* evt, int wake_reader) {
    return cb_internal_write_data(cb_array[get_next_write_cb_index()], evt, evt->eventsz, wake_reader);
}

int cb_is_readable(void) {
	if (atomic_read(&missed_events) > 0) return INT_MAX;
    return atomic_read(&total_readable_bytes);
}

void cb_force_miss(void) {
    if (cb_array != NULL) increment_missed_events();
}

void cb_get_stats(uint32_t *readable_bytes, uint32_t *highwater, uint32_t *total_bytes, uint32_t *total_events,
                    unsigned int *buffers, unsigned int *allocs_since_last, unsigned int *frees_since_last) {
    unsigned idx;
    alloc_stats_t total = { 0, 0 };

*buffers = cb_mask + 1;
    *readable_bytes = *highwater = *total_bytes = *total_events = 0;
    *allocs_since_last = *frees_since_last = 0;

if (cb_array == NULL) {
        return;
    }

for (idx = 0; idx <= cb_mask; idx++) {
        chunkbuf_t *cb = cb_array[idx];
        bs_acquire_spinlock(&cb->buffer_lock);
        {
            *readable_bytes += cb->active_read.readable_bytes;
            // simplifying assumption: approximately uniform distribution of
            // microevents, so the all CBs reached their highwater mark
            // at about the same time. Therefore, THE highwater mark is the
            // sum of the indivdual highwater marks.
            *highwater += cb->highwater;
            *total_bytes += cb->total_bytes;
            *total_events += cb->total_events;
            total.allocs += cb->chunk_allocs;
            total.frees += cb->chunk_frees;
        }
        bs_release_spinlock(&cb->buffer_lock);
    }

*allocs_since_last = (total.allocs - total_previous.allocs);
    *frees_since_last  = (total.frees - total_previous.frees);

total_previous = total;
}

void cb_dump_stats(void)
{
    unsigned idx;

if (cb_array == NULL) {
        return;
    }

info_msg("msda: cb: me=%d trb=%d", atomic_read(&missed_events), atomic_read(&total_readable_bytes));
    for (idx = 0; idx <= cb_mask; idx++) {
        chunkbuf_t *cb = cb_array[idx];
        info_msg("msda: cb[%d]: rb=%u hw=%u tb=%llu te=%u tr=%u sr=%u ca=%d cf=%u",
                idx,
                cb->active_read.readable_bytes,
                cb->highwater,
                cb->total_bytes,
                cb->total_events,
                cb->total_reads,
                cb->spanning_reads,
                cb->chunk_allocs,
                cb->chunk_frees);
    }
}

#if 0 // DEAD CODE - need to find a way to create a user-space unit test for the chunkbuf code

#define TEST_CHUNK_SIZE ((PAGE_SIZE/2)-1)

#define CHUNK_BUG(x) if (x) goto chunk_err

static unsigned long kcopyfunc(void * to, void * from, unsigned int n, unsigned int offset) {
	memcpy(((char*)to)+offset, from, n);
	return 0;
}

int cb_test(void) {
	unsigned char *data_block;
	chunkbuf_t* cb;
	int count=0;
	int ret=0;
	int writes_fit;
	
	data_block = (char*)kernel_malloc(TEST_CHUNK_SIZE);
	if (!data_block) return 1;
	
	cb = cb_internal_init();
	
	info_msg("Testing chunkbuf overflow handling");
	while (cb_internal_write_data(cb, data_block, TEST_CHUNK_SIZE, 1) > 0) { count++; }
	CHUNK_BUG(cb->missed_events != 1);

info_msg("Verifying read EOF");
	CHUNK_BUG(cb_internal_read_data(cb, data_block, TEST_CHUNK_SIZE, 1, kcopyfunc) != 0);
	
	writes_fit = count;

cb_internal_destroy(cb);
	cb = cb_internal_init();

// Set up some specific write data
	data_block[1] = 0xaa;
	data_block[12] = 0x55;
	data_block[30] = 0x33;
	data_block[(TEST_CHUNK_SIZE - 1) - 1] = 0xed;

info_msg("Verifying %d writes", writes_fit);
	while (writes_fit-- > 0) {
		data_block[0] = (writes_fit & 0xff);
		data_block[TEST_CHUNK_SIZE - 1] = 0xff ^ (writes_fit & 0xff);
		CHUNK_BUG(cb_internal_write_data(cb, data_block, TEST_CHUNK_SIZE, 1) != TEST_CHUNK_SIZE);
	}
	
	info_msg("Verifying %d reads", count);
	while (count-- > 0) {
		CHUNK_BUG(cb_internal_read_data(cb, data_block, TEST_CHUNK_SIZE, 1, kcopyfunc) != TEST_CHUNK_SIZE);
		CHUNK_BUG(data_block[0] != (count & 0xff));
		CHUNK_BUG(data_block[1] != 0xaa);
		CHUNK_BUG(data_block[12] != 0x55);
		CHUNK_BUG(data_block[30] != 0x33);
		CHUNK_BUG(data_block[(TEST_CHUNK_SIZE - 1) - 1] != 0xed);
		CHUNK_BUG(data_block[TEST_CHUNK_SIZE - 1] != (0xff ^ (count & 0xff)));
	}
	if (debug) dbg_msg("msda: chunkbuf tests passed");
	goto complete;
chunk_err:
	if (debug) dbg_msg("msda: chunkbuf tests failed");
	ret = 1;
complete:
	cb_internal_destroy(cb);
	kernel_free(data_block);
	return ret;
}
#endif

CANCEL

Name	Type	Size	Modified	Actions
↩ ..	DIR	—	—
📁 arch/	DIR	—	2023-11-30 04:08
📁 protocol/	DIR	—	2023-11-30 04:08
📄 bitarray.c	C	1.3 KB	2023-11-01 09:12	EDIT
📄 bitarray.h	H	498 B	2023-11-01 09:12	EDIT
📄 bluechannel.c	C	17.1 KB	2023-11-01 09:12	EDIT
📄 bluechannel.h	H	7.5 KB	2023-11-01 09:12	EDIT
📄 chunkbuf.c	C	24.5 KB	2023-11-01 09:12	EDIT
📄 chunkbuf.h	H	1.8 KB	2023-11-01 09:12	EDIT
📄 compiler.h	H	1.4 KB	2023-11-01 09:12	EDIT
📄 connid.c	C	4.2 KB	2023-11-01 09:12	EDIT
📄 connid.h	H	559 B	2023-11-01 09:12	EDIT
📄 debug.h	H	231 B	2023-11-01 09:12	EDIT
📄 event_names.h	H	432 B	2023-11-01 09:12	EDIT
📄 event_protocol.c	C	11.1 KB	2023-11-01 09:12	EDIT
📄 event_protocol.h	H	18 KB	2023-11-01 09:12	EDIT
📄 hash.c	C	10.9 KB	2023-11-01 09:12	EDIT
📄 hash.h	H	3.1 KB	2023-11-01 09:12	EDIT
📄 osapi.h	H	6 KB	2023-11-01 09:12	EDIT
📄 proto.h	H	228 B	2023-11-01 09:12	EDIT
📄 supertramp.c	C	11.5 KB	2023-11-01 09:12	EDIT
📄 supertramp.h	H	7.6 KB	2023-11-01 09:12	EDIT