Merge "Remove unused osi buffer library" into main

        "src/alarm.cc",

        "src/allocation_tracker.cc",

        "src/allocator.cc",

        "src/buffer.cc",

        "src/config.cc",

        "src/fixed_queue.cc",

        "src/future.cc",

    "src/alarm.cc",

    "src/allocation_tracker.cc",

    "src/allocator.cc",

    "src/buffer.cc",

    "src/compat.cc",

    "src/config.cc",

    "src/fixed_queue.cc",

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

 *

 *  Copyright 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);

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

 *

 *  Copyright 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_osi_buffer"

#include "osi/include/buffer.h"

#include <base/logging.h>

#include <stdint.h>

#include "check.h"

#include "osi/include/allocator.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) {

  CHECK(size > 0);

  buffer_t* buffer =

      static_cast<buffer_t*>(osi_calloc(sizeof(buffer_t) + size));

  buffer->root = buffer;

  buffer->refcount = 1;

  buffer->length = size;

  return buffer;

}

buffer_t* buffer_new_ref(const buffer_t* buf) {

  CHECK(buf != NULL);

  return buffer_new_slice(buf, buf->length);

}

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

  CHECK(buf != NULL);

  CHECK(slice_size > 0);

  CHECK(slice_size <= buf->length);

  buffer_t* ret = static_cast<buffer_t*>(osi_calloc(sizeof(buffer_t)));

  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) {

  CHECK(buf != NULL);

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

}

size_t buffer_length(const buffer_t* buf) {

  CHECK(buf != NULL);

  return buf->length;

}

package {

    // See: http://go/android-license-faq

    // A large-scale-change added 'default_applicable_licenses' to import

    // all of the 'license_kinds' from "system_bt_license"

    // to get the below license kinds:

    //   SPDX-license-identifier-Apache-2.0

    default_applicable_licenses: ["system_bt_license"],

}

cc_fuzz {

    name: "libosi_fuzz_buffer",

    defaults: ["libosi_fuzz_defaults"],

    host_supported: true,

    srcs: [

        "fuzz_buffer.cc",

    ],

    shared_libs: [

        "liblog",

    ],

    static_libs: [

        "libchrome",

        "libosi",

    ],

}