Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 54cc1bac authored by Sharvil Nanavati's avatar Sharvil Nanavati Committed by Andre Eisenbach
Browse files

Add a reference counted buffer implementation. 

This implementation introduces the notion of a 'slice'. A slice is
simply a sub-buffer of the original buffer. Slices refer to their
parent buffer so no memory is copied and slice creation becomes an
O(1) operation. Although I'm introducing a new concept, in practice,
a slice is indistinguishable from a buffer (they share a type and
all operations).

I expect slices to be used heavily during packet construction. For
example, an RFCOMM implementation would request a buffer from the
L2CAP layer (which may in turn request a buffer from the HCI layer).
The L2CAP layer would reserve some space in the buffer for its header
and return a slice to the RFCOMM layer.
parent 0814caf3

system/osi/Android.mk

+1 −0
Original line number Diff line number Diff line
@@ -29,6 +29,7 @@ LOCAL_SRC_FILES := \ 
    ./src/allocation_tracker.c \

    ./src/allocator.c \

    ./src/array.c \

    ./src/buffer.c \

    ./src/config.c \

    ./src/data_dispatcher.c \

    ./src/eager_reader.c \

system/osi/include/buffer.h

0 → 100644
+56 −0
Original line number Diff line number Diff line 
/******************************************************************************

 *

 *  Copyright (C) 2014 Google, Inc.

 *

 *  Licensed under the Apache License, Version 2.0 (the "License");

 *  you may not use this file except in compliance with the License.

 *  You may obtain a copy of the License at:

 *

 *  http://www.apache.org/licenses/LICENSE-2.0

 *

 *  Unless required by applicable law or agreed to in writing, software

 *  distributed under the License is distributed on an "AS IS" BASIS,

 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 *  See the License for the specific language governing permissions and

 *  limitations under the License.

 *

 ******************************************************************************/



#pragma once



#include <stdbool.h>

#include <stddef.h>



typedef struct buffer_t buffer_t;



// Returns a new buffer of |size| bytes. Returns NULL if a buffer could not be

// allocated. |size| must be non-zero. The caller must release this buffer with

// |buffer_free|.

buffer_t *buffer_new(size_t size);



// Creates a new reference to the buffer |buf|. A reference is indistinguishable

// from the original: writes to the original will be reflected in the reference

// and vice versa. In other words, this function creates an alias to |buf|. The

// caller must release the returned buffer with |buffer_free|. Note that releasing

// the returned buffer does not release |buf|. |buf| must not be NULL.

buffer_t *buffer_new_ref(const buffer_t *buf);



// Creates a new reference to the last |slice_size| bytes of |buf|. See

// |buffer_new_ref| for a description of references. |slice_size| must be

// greater than 0 and may be at most |buffer_length|

// (0 < slice_size <= buffer_length). |buf| must not be NULL.

buffer_t *buffer_new_slice(const buffer_t *buf, size_t slice_size);



// Frees a buffer object. |buf| may be NULL.

void buffer_free(buffer_t *buf);



// Returns a pointer to a writeable memory region for |buf|. All references

// and slices that share overlapping bytes will also be written to when

// writing to the returned pointer. The caller may safely write up to

// |buffer_length| consecutive bytes starting at the address returned by

// this function. |buf| must not be NULL.

void *buffer_ptr(const buffer_t *buf);



// Returns the length of the writeable memory region referred to by |buf|.

// |buf| must not be NULL.

size_t buffer_length(const buffer_t *buf);

system/osi/src/buffer.c

0 → 100644
+99 −0
Original line number Diff line number Diff line 
/******************************************************************************

 *

 *  Copyright (C) 2014 Google, Inc.

 *

 *  Licensed under the Apache License, Version 2.0 (the "License");

 *  you may not use this file except in compliance with the License.

 *  You may obtain a copy of the License at:

 *

 *  http://www.apache.org/licenses/LICENSE-2.0

 *

 *  Unless required by applicable law or agreed to in writing, software

 *  distributed under the License is distributed on an "AS IS" BASIS,

 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 *  See the License for the specific language governing permissions and

 *  limitations under the License.

 *

 ******************************************************************************/



#define LOG_TAG "bt_buffer"



#include <assert.h>

#include <stdint.h>



#include "osi/include/allocator.h"

#include "osi/include/buffer.h"

#include "osi/include/log.h"



struct buffer_t {

  buffer_t *root;

  size_t refcount;

  size_t length;

  uint8_t data[];

};



buffer_t *buffer_new(size_t size) {

  assert(size > 0);



  buffer_t *buffer = osi_calloc(sizeof(buffer_t) + size);

  if (!buffer) {

    LOG_ERROR("%s unable to allocate buffer of %zu bytes.", __func__, size);

    return NULL;

  }



  buffer->root = buffer;

  buffer->refcount = 1;

  buffer->length = size;



  return buffer;

}



buffer_t *buffer_new_ref(const buffer_t *buf) {

  assert(buf != NULL);

  return buffer_new_slice(buf, buf->length);

}



buffer_t *buffer_new_slice(const buffer_t *buf, size_t slice_size) {

  assert(buf != NULL);

  assert(slice_size > 0);

  assert(slice_size <= buf->length);



  buffer_t *ret = osi_calloc(sizeof(buffer_t));

  if (!ret) {

    LOG_ERROR("%s unable to allocate new buffer for slice of length %zu.", __func__, slice_size);

    return NULL;

  }



  ret->root = buf->root;

  ret->refcount = SIZE_MAX;

  ret->length = slice_size;



  ++buf->root->refcount;



  return ret;

}



void buffer_free(buffer_t *buffer) {

  if (!buffer)

    return;



  if (buffer->root != buffer) {

    // We're a leaf node. Delete the root node if we're the last referent.

    if (--buffer->root->refcount == 0)

      osi_free(buffer->root);

    osi_free(buffer);

  } else if (--buffer->refcount == 0) {

    // We're a root node. Roots are only deleted when their refcount goes to 0.

    osi_free(buffer);

  }

}



void *buffer_ptr(const buffer_t *buf) {

  assert(buf != NULL);

  return buf->root->data + buf->root->length - buf->length;

}



size_t buffer_length(const buffer_t *buf) {

  assert(buf != NULL);

  return buf->length;

}