From b55040cc6448a8847490da807d2b6362aa8cb8d9 Mon Sep 17 00:00:00 2001 From: Myles Watson Date: Wed, 19 Oct 2016 13:15:34 -0700 Subject: [PATCH] osi: Apply clang-format cd osi/ clang-format -i --style=file include/*.h include/socket_utils/* src/*.cc \ src/socket_utils/* src/protos/* test/* Test: mma -j32 Change-Id: I659e586076f1e2ec8f687cd33f441700b8d1f823 --- osi/include/alarm.h | 27 ++- osi/include/allocation_tracker.h | 8 +- osi/include/allocator.h | 18 +- osi/include/array.h | 32 +-- osi/include/buffer.h | 15 +- osi/include/compat.h | 4 +- osi/include/config.h | 104 ++++++---- osi/include/data_dispatcher.h | 14 +- osi/include/eager_reader.h | 39 ++-- osi/include/fixed_queue.h | 52 ++--- osi/include/future.h | 12 +- osi/include/hash_map_utils.h | 6 +- osi/include/list.h | 99 +++++---- osi/include/log.h | 63 +++--- osi/include/metrics.h | 22 +- osi/include/osi.h | 15 +- osi/include/properties.h | 4 +- osi/include/reactor.h | 89 +++++---- osi/include/ringbuffer.h | 15 +- osi/include/semaphore.h | 15 +- osi/include/socket.h | 75 ++++--- osi/include/socket_utils/socket_local.h | 4 +- osi/include/socket_utils/sockets.h | 12 +- osi/include/thread.h | 25 +-- osi/include/wakelock.h | 6 +- osi/src/alarm.cc | 268 ++++++++++++------------- osi/src/allocation_tracker.cc | 66 +++--- osi/src/allocator.cc | 54 ++--- osi/src/array.cc | 47 ++--- osi/src/buffer.cc | 25 ++- osi/src/compat.cc | 36 ++-- osi/src/config.cc | 299 ++++++++++++++-------------- osi/src/data_dispatcher.cc | 38 ++-- osi/src/eager_reader.cc | 129 ++++++------ osi/src/fixed_queue.cc | 121 +++++------ osi/src/future.cc | 31 ++- osi/src/hash_map_utils.cc | 18 +- osi/src/list.cc | 120 ++++++----- osi/src/metrics.cc | 74 +++---- osi/src/metrics_linux.cc | 35 ++-- osi/src/mutex.cc | 12 +- osi/src/osi.cc | 5 +- osi/src/properties.cc | 28 ++- osi/src/protos/bluetooth.proto | 70 +++---- osi/src/reactor.cc | 111 ++++++----- osi/src/ringbuffer.cc | 53 +++-- osi/src/semaphore.cc | 43 ++-- osi/src/socket.cc | 94 ++++----- osi/src/socket_utils/README | 37 ++-- osi/src/socket_utils/socket_local_client.cc | 12 +- osi/src/socket_utils/socket_local_server.cc | 12 +- osi/src/thread.cc | 93 ++++----- osi/src/time.cc | 4 +- osi/src/wakelock.cc | 81 ++++---- osi/test/AlarmTestHarness.cc | 16 +- osi/test/AlarmTestHarness.h | 12 +- osi/test/AllocationTestHarness.cc | 3 +- osi/test/AllocationTestHarness.h | 6 +- osi/test/alarm_test.cc | 142 ++++++------- osi/test/allocation_tracker_test.cc | 18 +- osi/test/allocator_test.cc | 2 +- osi/test/array_test.cc | 30 +-- osi/test/config_test.cc | 77 +++---- osi/test/data_dispatcher_test.cc | 88 ++++---- osi/test/eager_reader_test.cc | 119 +++++------ osi/test/fixed_queue_test.cc | 113 +++++------ osi/test/future_test.cc | 15 +- osi/test/hash_map_utils_test.cc | 4 +- osi/test/list_test.cc | 95 +++++---- osi/test/reactor_test.cc | 36 ++-- osi/test/ringbuffer_test.cc | 22 +- osi/test/semaphore_test.cc | 40 ++-- osi/test/test_stubs.h | 42 ++-- osi/test/thread_test.cc | 20 +- osi/test/wakelock_test.cc | 34 ++-- 75 files changed, 1866 insertions(+), 1859 deletions(-) diff --git a/osi/include/alarm.h b/osi/include/alarm.h index dc7464999..5899d15fd 100644 --- a/osi/include/alarm.h +++ b/osi/include/alarm.h @@ -31,7 +31,7 @@ typedef struct fixed_queue_t fixed_queue_t; typedef struct thread_t thread_t; // Prototype for the alarm callback function. -typedef void (*alarm_callback_t)(void *data); +typedef void (*alarm_callback_t)(void* data); // Creates a new one-time off alarm object with user-assigned // |name|. |name| may not be NULL, and a copy of the string will @@ -40,7 +40,7 @@ typedef void (*alarm_callback_t)(void *data); // better debuggability), but that is not enforced. The returned // object must be freed by calling |alarm_free|. Returns NULL on // failure. -alarm_t *alarm_new(const char *name); +alarm_t* alarm_new(const char* name); // Creates a new periodic alarm object with user-assigned |name|. // |name| may not be NULL, and a copy of the string will be @@ -49,13 +49,13 @@ alarm_t *alarm_new(const char *name); // debuggability), but that is not enforced. The returned object // must be freed by calling |alarm_free|. Returns NULL on // failure. -alarm_t *alarm_new_periodic(const char *name); +alarm_t* alarm_new_periodic(const char* name); // Frees an |alarm| object created by |alarm_new| or // |alarm_new_periodic|. |alarm| may be NULL. If the alarm is // pending, it will be cancelled first. It is not safe to call // |alarm_free| from inside the callback of |alarm|. -void alarm_free(alarm_t *alarm); +void alarm_free(alarm_t* alarm); // Sets an |alarm| to execute a callback in the future. The |cb| // callback is called after the given |interval_ms|, where @@ -75,8 +75,8 @@ void alarm_free(alarm_t *alarm); // thread is not same as the caller’s thread. If two (or more) // alarms are set back-to-back with the same |interval_ms|, the // callbacks will be called in the order the alarms are set. -void alarm_set(alarm_t *alarm, period_ms_t interval_ms, - alarm_callback_t cb, void *data); +void alarm_set(alarm_t* alarm, period_ms_t interval_ms, alarm_callback_t cb, + void* data); // Sets an |alarm| to execute a callback in the future on a // specific |queue|. This function is same as |alarm_set| except @@ -85,34 +85,33 @@ void alarm_set(alarm_t *alarm, period_ms_t interval_ms, // Also, the callback execution ordering guarantee exists only // among alarms that are scheduled on the same queue. |queue| // may not be NULL. -void alarm_set_on_queue(alarm_t *alarm, period_ms_t interval_ms, - alarm_callback_t cb, void *data, - fixed_queue_t *queue); +void alarm_set_on_queue(alarm_t* alarm, period_ms_t interval_ms, + alarm_callback_t cb, void* data, fixed_queue_t* queue); // This function cancels the |alarm| if it was previously set. // When this call returns, the caller has a guarantee that the // callback is not in progress and will not be called if it // hasn't already been called. This function is idempotent. // |alarm| may not be NULL. -void alarm_cancel(alarm_t *alarm); +void alarm_cancel(alarm_t* alarm); // Tests whether the |alarm| is scheduled. // Return true if the |alarm| is scheduled or NULL, otherwise false. -bool alarm_is_scheduled(const alarm_t *alarm); +bool alarm_is_scheduled(const alarm_t* alarm); // Registers |queue| for processing alarm callbacks on |thread|. // |queue| may not be NULL. |thread| may not be NULL. -void alarm_register_processing_queue(fixed_queue_t *queue, thread_t *thread); +void alarm_register_processing_queue(fixed_queue_t* queue, thread_t* thread); // Unregisters |queue| for processing alarm callbacks on whichever thread // it is registered with. All alarms currently set for execution on |queue| // will be canceled. |queue| may not be NULL. This function is idempotent. -void alarm_unregister_processing_queue(fixed_queue_t *queue); +void alarm_unregister_processing_queue(fixed_queue_t* queue); // Figure out how much time until next expiration. // Returns 0 if not armed. |alarm| may not be NULL. // TODO: Remove this function once PM timers can be re-factored -period_ms_t alarm_get_remaining_ms(const alarm_t *alarm); +period_ms_t alarm_get_remaining_ms(const alarm_t* alarm); // Cleanup the alarm internal state. // This function should be called by the OSI module cleanup during diff --git a/osi/include/allocation_tracker.h b/osi/include/allocation_tracker.h index b07ec4f5c..9496ce69d 100644 --- a/osi/include/allocation_tracker.h +++ b/osi/include/allocation_tracker.h @@ -48,16 +48,18 @@ size_t allocation_tracker_expect_no_allocations(void); // enough memory for canaries; the total allocation size can be determined // by calling |allocation_tracker_resize_for_canary|. Returns |ptr| offset // to the the beginning of the uncanaried region. -void *allocation_tracker_notify_alloc(allocator_id_t allocator_id, void *ptr, size_t requested_size); +void* allocation_tracker_notify_alloc(allocator_id_t allocator_id, void* ptr, + size_t requested_size); // Notify the tracker of an allocation that is being freed. |ptr| must be a // pointer returned by a call to |allocation_tracker_notify_alloc| with the // same |allocator_id|. If |ptr| is NULL, this function does nothing. Returns // |ptr| offset to the real beginning of the allocation including any canary // space. -void *allocation_tracker_notify_free(allocator_id_t allocator_id, void *ptr); +void* allocation_tracker_notify_free(allocator_id_t allocator_id, void* ptr); -// Get the full size for an allocation, taking into account the size of canaries. +// Get the full size for an allocation, taking into account the size of +// canaries. size_t allocation_tracker_resize_for_canary(size_t size); #ifdef __cplusplus diff --git a/osi/include/allocator.h b/osi/include/allocator.h index 518fc762a..c7e870ab8 100644 --- a/osi/include/allocator.h +++ b/osi/include/allocator.h @@ -26,30 +26,30 @@ extern "C" { #endif -typedef void *(*alloc_fn)(size_t size); -typedef void (*free_fn)(void *ptr); +typedef void* (*alloc_fn)(size_t size); +typedef void (*free_fn)(void* ptr); typedef struct { alloc_fn alloc; - free_fn free; + free_fn free; } allocator_t; // allocator_t abstractions for the osi_*alloc and osi_free functions extern const allocator_t allocator_malloc; extern const allocator_t allocator_calloc; -char *osi_strdup(const char *str); -char *osi_strndup(const char *str, size_t len); +char* osi_strdup(const char* str); +char* osi_strndup(const char* str, size_t len); -void *osi_malloc(size_t size); -void *osi_calloc(size_t size); -void osi_free(void *ptr); +void* osi_malloc(size_t size); +void* osi_calloc(size_t size); +void osi_free(void* ptr); // Free a buffer that was previously allocated with function |osi_malloc| // or |osi_calloc| and reset the pointer to that buffer to NULL. // |p_ptr| is a pointer to the buffer pointer to be reset. // |p_ptr| cannot be NULL. -void osi_free_and_reset(void **p_ptr); +void osi_free_and_reset(void** p_ptr); #ifdef __cplusplus } diff --git a/osi/include/array.h b/osi/include/array.h index d275c4171..fa05d879b 100644 --- a/osi/include/array.h +++ b/osi/include/array.h @@ -28,23 +28,27 @@ extern "C" { typedef struct array_t array_t; -// Returns a new array object that stores elements of size |element_size|. The returned -// object must be freed with |array_free|. |element_size| must be greater than 0. Returns +// Returns a new array object that stores elements of size |element_size|. The +// returned +// object must be freed with |array_free|. |element_size| must be greater than +// 0. Returns // NULL on failure. -array_t *array_new(size_t element_size); +array_t* array_new(size_t element_size); // Frees an array that was allocated with |array_new|. |array| may be NULL. -void array_free(array_t *array); +void array_free(array_t* array); -// Returns a pointer to the first stored element in |array|. |array| must not be NULL. -void *array_ptr(const array_t *array); +// Returns a pointer to the first stored element in |array|. |array| must not be +// NULL. +void* array_ptr(const array_t* array); -// Returns a pointer to the |index|th element of |array|. |index| must be less than +// Returns a pointer to the |index|th element of |array|. |index| must be less +// than // the array's length. |array| must not be NULL. -void *array_at(const array_t *array, size_t index); +void* array_at(const array_t* array, size_t index); // Returns the number of elements stored in |array|. |array| must not be NULL. -size_t array_length(const array_t *array); +size_t array_length(const array_t* array); // Inserts an element to the end of |array| by value. For example, a caller // may simply call array_append_value(array, 5) instead of storing 5 into a @@ -52,13 +56,15 @@ size_t array_length(const array_t *array); // only the lowest |element_size| bytes will be stored. |array| must not be // NULL. Returns true if the element could be inserted into the array, false // on error. -bool array_append_value(array_t *array, uint32_t value); +bool array_append_value(array_t* array, uint32_t value); // Inserts an element to the end of |array|. The value pointed to by |data| must -// be at least |element_size| bytes long and will be copied into the array. Neither -// |array| nor |data| may be NULL. Returns true if the element could be inserted into +// be at least |element_size| bytes long and will be copied into the array. +// Neither +// |array| nor |data| may be NULL. Returns true if the element could be inserted +// into // the array, false on error. -bool array_append_ptr(array_t *array, void *data); +bool array_append_ptr(array_t* array, void* data); #ifdef __cplusplus } diff --git a/osi/include/buffer.h b/osi/include/buffer.h index 0abae36da..211f0d6c7 100644 --- a/osi/include/buffer.h +++ b/osi/include/buffer.h @@ -30,34 +30,35 @@ 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); +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 +// 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); +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); +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); +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); +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); +size_t buffer_length(const buffer_t* buf); #ifdef __cplusplus } diff --git a/osi/include/compat.h b/osi/include/compat.h index f25513de3..981c45235 100644 --- a/osi/include/compat.h +++ b/osi/include/compat.h @@ -33,10 +33,10 @@ extern "C" { pid_t gettid(void); /* Copy src to string dst of size siz. */ -size_t strlcpy(char *dst, const char *src, size_t siz); +size_t strlcpy(char* dst, const char* src, size_t siz); /* Appends src to string dst of size siz. */ -size_t strlcat(char *dst, const char *src, size_t siz); +size_t strlcat(char* dst, const char* src, size_t siz); #endif diff --git a/osi/include/config.h b/osi/include/config.h index 970c0cc16..2243c27a5 100644 --- a/osi/include/config.h +++ b/osi/include/config.h @@ -32,14 +32,14 @@ typedef struct config_section_node_t config_section_node_t; // Creates a new config object with no entries (i.e. not backed by a file). // This function returns a config object or NULL on error. Clients must call // |config_free| on the returned handle when it is no longer required. -config_t *config_new_empty(void); +config_t* config_new_empty(void); // Loads the specified file and returns a handle to the config file. If there // was a problem loading the file or allocating memory, this function returns // NULL. Clients must call |config_free| on the returned handle when it is no // longer required. |filename| must not be NULL and must point to a readable // file on the filesystem. -config_t *config_new(const char *filename); +config_t* config_new(const char* filename); // Clones |src|, including all of it's sections, keys, and values. // Returns a new config which is a copy and separated from the original; @@ -48,96 +48,122 @@ config_t *config_new(const char *filename); // |src| must not be NULL // This function will not return NULL. // Clients must call config_free on the returned object. -config_t *config_new_clone(const config_t *src); +config_t* config_new_clone(const config_t* src); // Frees resources associated with the config file. No further operations may // be performed on the |config| object after calling this function. |config| // may be NULL. -void config_free(config_t *config); +void config_free(config_t* config); // Returns true if the config file contains a section named |section|. If // the section has no key/value pairs in it, this function will return false. // |config| and |section| must not be NULL. -bool config_has_section(const config_t *config, const char *section); +bool config_has_section(const config_t* config, const char* section); // Returns true if the config file has a key named |key| under |section|. // Returns false otherwise. |config|, |section|, and |key| must not be NULL. -bool config_has_key(const config_t *config, const char *section, const char *key); +bool config_has_key(const config_t* config, const char* section, + const char* key); // Returns the integral value for a given |key| in |section|. If |section| // or |key| do not exist, or the value cannot be fully converted to an integer, // this function returns |def_value|. |config|, |section|, and |key| must not // be NULL. -int config_get_int(const config_t *config, const char *section, const char *key, int def_value); +int config_get_int(const config_t* config, const char* section, const char* key, + int def_value); // Returns the boolean value for a given |key| in |section|. If |section| // or |key| do not exist, or the value cannot be converted to a boolean, this -// function returns |def_value|. |config|, |section|, and |key| must not be NULL. -bool config_get_bool(const config_t *config, const char *section, const char *key, bool def_value); +// function returns |def_value|. |config|, |section|, and |key| must not be +// NULL. +bool config_get_bool(const config_t* config, const char* section, + const char* key, bool def_value); // Returns the string value for a given |key| in |section|. If |section| or // |key| do not exist, this function returns |def_value|. The returned string // is owned by the config module and must not be freed. |config|, |section|, // and |key| must not be NULL. |def_value| may be NULL. -const char *config_get_string(const config_t *config, const char *section, const char *key, const char *def_value); +const char* config_get_string(const config_t* config, const char* section, + const char* key, const char* def_value); // Sets an integral value for the |key| in |section|. If |key| or |section| do // not already exist, this function creates them. |config|, |section|, and |key| // must not be NULL. -void config_set_int(config_t *config, const char *section, const char *key, int value); +void config_set_int(config_t* config, const char* section, const char* key, + int value); // Sets a boolean value for the |key| in |section|. If |key| or |section| do // not already exist, this function creates them. |config|, |section|, and |key| // must not be NULL. -void config_set_bool(config_t *config, const char *section, const char *key, bool value); +void config_set_bool(config_t* config, const char* section, const char* key, + bool value); // Sets a string value for the |key| in |section|. If |key| or |section| do -// not already exist, this function creates them. |config|, |section|, |key|, and +// not already exist, this function creates them. |config|, |section|, |key|, +// and // |value| must not be NULL. -void config_set_string(config_t *config, const char *section, const char *key, const char *value); +void config_set_string(config_t* config, const char* section, const char* key, + const char* value); -// Removes |section| from the |config| (and, as a result, all keys in the section). -// Returns true if |section| was found and removed from |config|, false otherwise. +// Removes |section| from the |config| (and, as a result, all keys in the +// section). +// Returns true if |section| was found and removed from |config|, false +// otherwise. // Neither |config| nor |section| may be NULL. -bool config_remove_section(config_t *config, const char *section); +bool config_remove_section(config_t* config, const char* section); -// Removes one specific |key| residing in |section| of the |config|. Returns true +// Removes one specific |key| residing in |section| of the |config|. Returns +// true // if the section and key were found and the key was removed, false otherwise. // None of |config|, |section|, or |key| may be NULL. -bool config_remove_key(config_t *config, const char *section, const char *key); +bool config_remove_key(config_t* config, const char* section, const char* key); // Returns an iterator to the first section in the config file. If there are no // sections, the iterator will equal the return value of |config_section_end|. -// The returned pointer must be treated as an opaque handle and must not be freed. -// The iterator is invalidated on any config mutating operation. |config| may not +// The returned pointer must be treated as an opaque handle and must not be +// freed. +// The iterator is invalidated on any config mutating operation. |config| may +// not // be NULL. -const config_section_node_t *config_section_begin(const config_t *config); - -// Returns an iterator to one past the last section in the config file. It does not -// represent a valid section, but can be used to determine if all sections have been -// iterated over. The returned pointer must be treated as an opaque handle and must -// not be freed and must not be iterated on (must not call |config_section_next| on +const config_section_node_t* config_section_begin(const config_t* config); + +// Returns an iterator to one past the last section in the config file. It does +// not +// represent a valid section, but can be used to determine if all sections have +// been +// iterated over. The returned pointer must be treated as an opaque handle and +// must +// not be freed and must not be iterated on (must not call |config_section_next| +// on // it). |config| may not be NULL. -const config_section_node_t *config_section_end(const config_t *config); +const config_section_node_t* config_section_end(const config_t* config); // Moves |iter| to the next section. If there are no more sections, |iter| will // equal the value of |config_section_end|. |iter| may not be NULL and must be // a pointer returned by either |config_section_begin| or |config_section_next|. -const config_section_node_t *config_section_next(const config_section_node_t *iter); - -// Returns the name of the section referred to by |iter|. The returned pointer is -// owned by the config module and must not be freed by the caller. The pointer will -// remain valid until |config_free| is called. |iter| may not be NULL and must not +const config_section_node_t* config_section_next( + const config_section_node_t* iter); + +// Returns the name of the section referred to by |iter|. The returned pointer +// is +// owned by the config module and must not be freed by the caller. The pointer +// will +// remain valid until |config_free| is called. |iter| may not be NULL and must +// not // equal the value returned by |config_section_end|. -const char *config_section_name(const config_section_node_t *iter); +const char* config_section_name(const config_section_node_t* iter); -// Saves |config| to a file given by |filename|. Note that this could be a destructive +// Saves |config| to a file given by |filename|. Note that this could be a +// destructive // operation: if |filename| already exists, it will be overwritten. The config -// module does not preserve comments or formatting so if a config file was opened -// with |config_new| and subsequently overwritten with |config_save|, all comments -// and special formatting in the original file will be lost. Neither |config| nor +// module does not preserve comments or formatting so if a config file was +// opened +// with |config_new| and subsequently overwritten with |config_save|, all +// comments +// and special formatting in the original file will be lost. Neither |config| +// nor // |filename| may be NULL. -bool config_save(const config_t *config, const char *filename); +bool config_save(const config_t* config, const char* filename); #ifdef __cplusplus } diff --git a/osi/include/data_dispatcher.h b/osi/include/data_dispatcher.h index 838ee31ef..7349444ef 100644 --- a/osi/include/data_dispatcher.h +++ b/osi/include/data_dispatcher.h @@ -35,29 +35,33 @@ typedef uintptr_t data_dispatcher_type_t; // Creates a new data dispatcher object, with the given name. // The returned object must be freed by calling |data_dispatcher_free|. // Returns NULL on failure. |name| may not be NULL. -data_dispatcher_t *data_dispatcher_new(const char *name); +data_dispatcher_t* data_dispatcher_new(const char* name); // Frees a data dispatcher object created by |data_dispatcher_new|. // |data_dispatcher| may be NULL. -void data_dispatcher_free(data_dispatcher_t *dispatcher); +void data_dispatcher_free(data_dispatcher_t* dispatcher); // Registers |type| and |queue| with the data dispatcher so that data // sent under |type| ends up in |queue|. If |type| is already registered, // it is replaced. If |queue| is NULL, the existing registration is // removed, if it exists. |dispatcher| may not be NULL. -void data_dispatcher_register(data_dispatcher_t *dispatcher, data_dispatcher_type_t type, fixed_queue_t *queue); +void data_dispatcher_register(data_dispatcher_t* dispatcher, + data_dispatcher_type_t type, + fixed_queue_t* queue); // Registers a default queue to send data to when there is not a specific // type/queue relationship registered. If a default queue is already registered, // it is replaced. If |queue| is NULL, the existing registration is // removed, if it exists. |dispatcher| may not be NULL. -void data_dispatcher_register_default(data_dispatcher_t *dispatcher, fixed_queue_t *queue); +void data_dispatcher_register_default(data_dispatcher_t* dispatcher, + fixed_queue_t* queue); // Dispatches |data| to the queue registered for |type|. If no such registration // exists, it is dispatched to the default queue if it exists. // Neither |dispatcher| nor |data| may be NULL. // Returns true if data dispatch was successful. -bool data_dispatcher_dispatch(data_dispatcher_t *dispatcher, data_dispatcher_type_t type, void *data); +bool data_dispatcher_dispatch(data_dispatcher_t* dispatcher, + data_dispatcher_type_t type, void* data); #ifdef __cplusplus } diff --git a/osi/include/eager_reader.h b/osi/include/eager_reader.h index 8e5ee6049..ad4887be0 100644 --- a/osi/include/eager_reader.h +++ b/osi/include/eager_reader.h @@ -32,43 +32,46 @@ extern "C" { typedef struct eager_reader_t eager_reader_t; typedef struct reactor_t reactor_t; -typedef void (*eager_reader_cb)(eager_reader_t *reader, void *context); +typedef void (*eager_reader_cb)(eager_reader_t* reader, void* context); // Creates a new eager reader object, which pulls data from |fd_to_read| into // buffers of size |buffer_size| allocated using |allocator|, and has an -// internal read thread named |thread_name|. The returned object must be freed using -// |eager_reader_free|. |fd_to_read| must be valid, |buffer_size| and |max_buffer_count| +// internal read thread named |thread_name|. The returned object must be freed +// using +// |eager_reader_free|. |fd_to_read| must be valid, |buffer_size| and +// |max_buffer_count| // must be greater than zero. |allocator| and |thread_name| may not be NULL. -eager_reader_t *eager_reader_new( - int fd_to_read, - const allocator_t *allocator, - size_t buffer_size, - size_t max_buffer_count, - const char *thread_name -); +eager_reader_t* eager_reader_new(int fd_to_read, const allocator_t* allocator, + size_t buffer_size, size_t max_buffer_count, + const char* thread_name); // Frees an eager reader object, and associated internal resources. // |reader| may be NULL. -void eager_reader_free(eager_reader_t *reader); +void eager_reader_free(eager_reader_t* reader); // Registers |reader| with the |reactor|. When the reader has data -// |read_cb| will be called. The |context| parameter is passed, untouched, to |read_cb|. -// Neither |reader|, nor |reactor|, nor |read_cb| may be NULL. |context| may be NULL. -void eager_reader_register(eager_reader_t *reader, reactor_t *reactor, eager_reader_cb read_cb, void *context); +// |read_cb| will be called. The |context| parameter is passed, untouched, to +// |read_cb|. +// Neither |reader|, nor |reactor|, nor |read_cb| may be NULL. |context| may be +// NULL. +void eager_reader_register(eager_reader_t* reader, reactor_t* reactor, + eager_reader_cb read_cb, void* context); -// Unregisters |reader| from whichever reactor it is registered with, if any. This +// Unregisters |reader| from whichever reactor it is registered with, if any. +// This // function is idempotent. -void eager_reader_unregister(eager_reader_t *reader); +void eager_reader_unregister(eager_reader_t* reader); // Reads up to |max_size| bytes into |buffer| from currently available bytes. // NOT SAFE FOR READING FROM MULTIPLE THREADS // but you should probably only be reading from one thread anyway, // otherwise the byte stream probably doesn't make sense. -size_t eager_reader_read(eager_reader_t *reader, uint8_t *buffer, size_t max_size); +size_t eager_reader_read(eager_reader_t* reader, uint8_t* buffer, + size_t max_size); // Returns the inbound read thread for a given |reader| or NULL if the thread // is not running. -thread_t* eager_reader_get_read_thread(const eager_reader_t *reader); +thread_t* eager_reader_get_read_thread(const eager_reader_t* reader); #ifdef __cplusplus } diff --git a/osi/include/fixed_queue.h b/osi/include/fixed_queue.h index 54f0093bb..c067e630e 100644 --- a/osi/include/fixed_queue.h +++ b/osi/include/fixed_queue.h @@ -31,76 +31,76 @@ struct fixed_queue_t; typedef struct fixed_queue_t fixed_queue_t; typedef struct reactor_t reactor_t; -typedef void (*fixed_queue_free_cb)(void *data); -typedef void (*fixed_queue_cb)(fixed_queue_t *queue, void *context); +typedef void (*fixed_queue_free_cb)(void* data); +typedef void (*fixed_queue_cb)(fixed_queue_t* queue, void* context); // Creates a new fixed queue with the given |capacity|. If more elements than // |capacity| are added to the queue, the caller is blocked until space is // made available in the queue. Returns NULL on failure. The caller must free // the returned queue with |fixed_queue_free|. -fixed_queue_t *fixed_queue_new(size_t capacity); +fixed_queue_t* fixed_queue_new(size_t capacity); // Frees a queue and (optionally) the enqueued elements. // |queue| is the queue to free. If the |free_cb| callback is not null, // it is called on each queue element to free it. // Freeing a queue that is currently in use (i.e. has waiters // blocked on it) results in undefined behaviour. -void fixed_queue_free(fixed_queue_t *queue, fixed_queue_free_cb free_cb); +void fixed_queue_free(fixed_queue_t* queue, fixed_queue_free_cb free_cb); // Flushes a queue and (optionally) frees the enqueued elements. // |queue| is the queue to flush. If the |free_cb| callback is not null, // it is called on each queue element to free it. -void fixed_queue_flush(fixed_queue_t *queue, fixed_queue_free_cb free_cb); +void fixed_queue_flush(fixed_queue_t* queue, fixed_queue_free_cb free_cb); // Returns a value indicating whether the given |queue| is empty. If |queue| // is NULL, the return value is true. -bool fixed_queue_is_empty(fixed_queue_t *queue); +bool fixed_queue_is_empty(fixed_queue_t* queue); // Returns the length of the |queue|. If |queue| is NULL, the return value // is 0. -size_t fixed_queue_length(fixed_queue_t *queue); +size_t fixed_queue_length(fixed_queue_t* queue); // Returns the maximum number of elements this queue may hold. |queue| may // not be NULL. -size_t fixed_queue_capacity(fixed_queue_t *queue); +size_t fixed_queue_capacity(fixed_queue_t* queue); // Enqueues the given |data| into the |queue|. The caller will be blocked // if no more space is available in the queue. Neither |queue| nor |data| // may be NULL. -void fixed_queue_enqueue(fixed_queue_t *queue, void *data); +void fixed_queue_enqueue(fixed_queue_t* queue, void* data); // Dequeues the next element from |queue|. If the queue is currently empty, // this function will block the caller until an item is enqueued. This // function will never return NULL. |queue| may not be NULL. -void *fixed_queue_dequeue(fixed_queue_t *queue); +void* fixed_queue_dequeue(fixed_queue_t* queue); // Tries to enqueue |data| into the |queue|. This function will never block // the caller. If the queue capacity would be exceeded by adding one more // element, this function returns false immediately. Otherwise, this function // returns true. Neither |queue| nor |data| may be NULL. -bool fixed_queue_try_enqueue(fixed_queue_t *queue, void *data); +bool fixed_queue_try_enqueue(fixed_queue_t* queue, void* data); // Tries to dequeue an element from |queue|. This function will never block // the caller. If the queue is empty or NULL, this function returns NULL // immediately. Otherwise, the next element in the queue is returned. -void *fixed_queue_try_dequeue(fixed_queue_t *queue); +void* fixed_queue_try_dequeue(fixed_queue_t* queue); // Returns the first element from |queue|, if present, without dequeuing it. // This function will never block the caller. Returns NULL if there are no // elements in the queue or |queue| is NULL. -void *fixed_queue_try_peek_first(fixed_queue_t *queue); +void* fixed_queue_try_peek_first(fixed_queue_t* queue); // Returns the last element from |queue|, if present, without dequeuing it. // This function will never block the caller. Returns NULL if there are no // elements in the queue or |queue| is NULL. -void *fixed_queue_try_peek_last(fixed_queue_t *queue); +void* fixed_queue_try_peek_last(fixed_queue_t* queue); // Tries to remove a |data| element from the middle of the |queue|. This // function will never block the caller. If the queue is empty or NULL, this // function returns NULL immediately. |data| may not be NULL. If the |data| // element is found in the queue, a pointer to the removed data is returned, // otherwise NULL. -void *fixed_queue_try_remove_from_queue(fixed_queue_t *queue, void *data); +void* fixed_queue_try_remove_from_queue(fixed_queue_t* queue, void* data); // Returns the iterateable list with all entries in the |queue|. This function // will never block the caller. |queue| may not be NULL. @@ -109,31 +109,35 @@ void *fixed_queue_try_remove_from_queue(fixed_queue_t *queue, void *data); // be modified by another thread, and the result would be unpredictable. // TODO: The usage of this function should be refactored, and the function // itself should be removed. -list_t *fixed_queue_get_list(fixed_queue_t *queue); +list_t* fixed_queue_get_list(fixed_queue_t* queue); // This function returns a valid file descriptor. Callers may perform one // operation on the fd: select(2). If |select| indicates that the file // descriptor is readable, the caller may call |fixed_queue_enqueue| without // blocking. The caller must not close the returned file descriptor. |queue| // may not be NULL. -int fixed_queue_get_enqueue_fd(const fixed_queue_t *queue); +int fixed_queue_get_enqueue_fd(const fixed_queue_t* queue); // This function returns a valid file descriptor. Callers may perform one // operation on the fd: select(2). If |select| indicates that the file // descriptor is readable, the caller may call |fixed_queue_dequeue| without // blocking. The caller must not close the returned file descriptor. |queue| // may not be NULL. -int fixed_queue_get_dequeue_fd(const fixed_queue_t *queue); - -// Registers |queue| with |reactor| for dequeue operations. When there is an element -// in the queue, ready_cb will be called. The |context| parameter is passed, untouched, -// to the callback routine. Neither |queue|, nor |reactor|, nor |read_cb| may be NULL. +int fixed_queue_get_dequeue_fd(const fixed_queue_t* queue); + +// Registers |queue| with |reactor| for dequeue operations. When there is an +// element +// in the queue, ready_cb will be called. The |context| parameter is passed, +// untouched, +// to the callback routine. Neither |queue|, nor |reactor|, nor |read_cb| may be +// NULL. // |context| may be NULL. -void fixed_queue_register_dequeue(fixed_queue_t *queue, reactor_t *reactor, fixed_queue_cb ready_cb, void *context); +void fixed_queue_register_dequeue(fixed_queue_t* queue, reactor_t* reactor, + fixed_queue_cb ready_cb, void* context); // Unregisters the dequeue ready callback for |queue| from whichever reactor // it is registered with, if any. This function is idempotent. -void fixed_queue_unregister_dequeue(fixed_queue_t *queue); +void fixed_queue_unregister_dequeue(fixed_queue_t* queue); #ifdef __cplusplus } diff --git a/osi/include/future.h b/osi/include/future.h index c57ba17f9..e9928d305 100644 --- a/osi/include/future.h +++ b/osi/include/future.h @@ -24,25 +24,25 @@ extern "C" { typedef struct future_t future_t; -#define FUTURE_SUCCESS ((void *)1) -#define FUTURE_FAIL ((void *)0) +#define FUTURE_SUCCESS ((void*)1) +#define FUTURE_FAIL ((void*)0) // Constructs a new future_t object. Returns NULL on failure. -future_t *future_new(void); +future_t* future_new(void); // Constructs a new future_t object with an immediate |value|. No waiting will // occur in the call to |future_await| because the value is already present. // Returns NULL on failure. -future_t *future_new_immediate(void *value); +future_t* future_new_immediate(void* value); // Signals that the |future| is ready, passing |value| back to the context // waiting for the result. Must only be called once for every future. // |future| may not be NULL. -void future_ready(future_t *future, void *value); +void future_ready(future_t* future, void* value); // Waits for the |future| to be ready. Returns the value set in |future_ready|. // Frees the future before return. |future| may not be NULL. -void *future_await(future_t *async_result); +void* future_await(future_t* async_result); #ifdef __cplusplus } diff --git a/osi/include/hash_map_utils.h b/osi/include/hash_map_utils.h index 8a46617bf..1ea39960e 100644 --- a/osi/include/hash_map_utils.h +++ b/osi/include/hash_map_utils.h @@ -18,8 +18,8 @@ #pragma once -#include #include +#include // Creates a hash map based on the |params| string containing key and value // pairs. Pairs are expected in the form "key=value" separated by the ';' @@ -31,10 +31,10 @@ // "=value0;key1=value1;" -> map: [key1]="value1" // A new hash map or NULL is returned and is owned by the caller. std::unordered_map -hash_map_utils_new_from_string_params(const char *params); +hash_map_utils_new_from_string_params(const char* params); // Dumps the contents of the hash_map to the log for debugging purposes. // If |map| is not NULL, all entries of |map| will be dumped, otherwise nothing // will be dumped. Note that this function does not take the ownership of |map|. void hash_map_utils_dump_string_keys_string_values( - std::unordered_map &map); + std::unordered_map& map); diff --git a/osi/include/list.h b/osi/include/list.h index 254e36ead..1ecded9a1 100644 --- a/osi/include/list.h +++ b/osi/include/list.h @@ -31,109 +31,128 @@ typedef struct list_node_t list_node_t; struct list_t; typedef struct list_t list_t; -typedef void (*list_free_cb)(void *data); +typedef void (*list_free_cb)(void* data); // Iterator callback prototype used for |list_foreach|. // |data| represents the list item currently being iterated, |context| is a // user defined value passed into |list_foreach|. // Callback must return true to continue iterating or false to stop iterating. -typedef bool (*list_iter_cb)(void *data, void *context); +typedef bool (*list_iter_cb)(void* data, void* context); -// Returns a new, empty list. Returns NULL if not enough memory could be allocated +// Returns a new, empty list. Returns NULL if not enough memory could be +// allocated // for the list structure. The returned list must be freed with |list_free|. The -// |callback| specifies a function to be called whenever a list element is removed -// from the list. It can be used to release resources held by the list element, e.g. -// memory or file descriptor. |callback| may be NULL if no cleanup is necessary on +// |callback| specifies a function to be called whenever a list element is +// removed +// from the list. It can be used to release resources held by the list element, +// e.g. +// memory or file descriptor. |callback| may be NULL if no cleanup is necessary +// on // element removal. -list_t *list_new(list_free_cb callback); +list_t* list_new(list_free_cb callback); // Frees the list. This function accepts NULL as an argument, in which case it // behaves like a no-op. -void list_free(list_t *list); +void list_free(list_t* list); // Returns true if |list| is empty (has no elements), false otherwise. // |list| may not be NULL. -bool list_is_empty(const list_t *list); +bool list_is_empty(const list_t* list); // Returns true if the list contains |data|, false otherwise. // |list| may not be NULL. -bool list_contains(const list_t *list, const void *data); +bool list_contains(const list_t* list, const void* data); // Returns the length of the |list|. |list| may not be NULL. -size_t list_length(const list_t *list); +size_t list_length(const list_t* list); // Returns the first element in the list without removing it. |list| may not // be NULL or empty. -void *list_front(const list_t *list); +void* list_front(const list_t* list); // Returns the last element in the list without removing it. |list| may not // be NULL or empty. -void *list_back(const list_t *list); +void* list_back(const list_t* list); // Returns the last node in the list without removing it. |list| may not // be NULL or empty. -list_node_t *list_back_node(const list_t *list); +list_node_t* list_back_node(const list_t* list); // Inserts |data| after |prev_node| in |list|. |data|, |list|, and |prev_node| // may not be NULL. This function does not make a copy of |data| so the pointer // must remain valid at least until the element is removed from the list or the // list is freed. Returns true if |data| could be inserted, false otherwise // (e.g. out of memory). -bool list_insert_after(list_t *list, list_node_t *prev_node, void *data); +bool list_insert_after(list_t* list, list_node_t* prev_node, void* data); -// Inserts |data| at the beginning of |list|. Neither |data| nor |list| may be NULL. +// Inserts |data| at the beginning of |list|. Neither |data| nor |list| may be +// NULL. // This function does not make a copy of |data| so the pointer must remain valid // at least until the element is removed from the list or the list is freed. -// Returns true if |data| could be inserted, false otherwise (e.g. out of memory). -bool list_prepend(list_t *list, void *data); +// Returns true if |data| could be inserted, false otherwise (e.g. out of +// memory). +bool list_prepend(list_t* list, void* data); // Inserts |data| at the end of |list|. Neither |data| nor |list| may be NULL. // This function does not make a copy of |data| so the pointer must remain valid // at least until the element is removed from the list or the list is freed. -// Returns true if |data| could be inserted, false otherwise (e.g. out of memory). -bool list_append(list_t *list, void *data); - -// Removes |data| from the list. Neither |list| nor |data| may be NULL. If |data| -// is inserted multiple times in the list, this function will only remove the first -// instance. If a free function was specified in |list_new|, it will be called back -// with |data|. This function returns true if |data| was found in the list and removed, +// Returns true if |data| could be inserted, false otherwise (e.g. out of +// memory). +bool list_append(list_t* list, void* data); + +// Removes |data| from the list. Neither |list| nor |data| may be NULL. If +// |data| +// is inserted multiple times in the list, this function will only remove the +// first +// instance. If a free function was specified in |list_new|, it will be called +// back +// with |data|. This function returns true if |data| was found in the list and +// removed, // false otherwise. -bool list_remove(list_t *list, void *data); +bool list_remove(list_t* list, void* data); -// Removes all elements in the list. Calling this function will return the list to the +// Removes all elements in the list. Calling this function will return the list +// to the // same state it was in after |list_new|. |list| may not be NULL. -void list_clear(list_t *list); - -// Iterates through the |list| and calls |callback| for each data element. Iteration -// continues until |callback| returns false. The function returns the pointer to last -// processed element, or NULL if the list is empty, or all calls to |callback| returned +void list_clear(list_t* list); + +// Iterates through the |list| and calls |callback| for each data element. +// Iteration +// continues until |callback| returns false. The function returns the pointer to +// last +// processed element, or NULL if the list is empty, or all calls to |callback| +// returned // true. |context| is passed to |callback| on each iteration. -// If the list is empty, |callback| will never be called. It is safe to mutate the -// list inside the callback. If an element is added before the node being visited, +// If the list is empty, |callback| will never be called. It is safe to mutate +// the +// list inside the callback. If an element is added before the node being +// visited, // there will be no callback for the newly-inserted node. Neither |list| nor // |callback| may be NULL. -list_node_t *list_foreach(const list_t *list, list_iter_cb callback, void *context); +list_node_t* list_foreach(const list_t* list, list_iter_cb callback, + void* context); // Returns an iterator to the first element in |list|. |list| may not be NULL. -// The returned iterator is valid as long as it does not equal the value returned +// The returned iterator is valid as long as it does not equal the value +// returned // by |list_end|. -list_node_t *list_begin(const list_t *list); +list_node_t* list_begin(const list_t* list); // Returns an iterator that points past the end of the list. In other words, // this function returns the value of an invalid iterator for the given list. // When an iterator has the same value as what's returned by this function, you // may no longer call |list_next| with the iterator. |list| may not be NULL. -list_node_t *list_end(const list_t *list); +list_node_t* list_end(const list_t* list); // Given a valid iterator |node|, this function returns the next value for the // iterator. If the returned value equals the value returned by |list_end|, the // iterator has reached the end of the list and may no longer be used for any // purpose. -list_node_t *list_next(const list_node_t *node); +list_node_t* list_next(const list_node_t* node); // Returns the value stored at the location pointed to by the iterator |node|. // |node| must not equal the value returned by |list_end|. -void *list_node(const list_node_t *node); +void* list_node(const list_node_t* node); #ifdef __cplusplus } diff --git a/osi/include/log.h b/osi/include/log.h index 20499e44c..9f0f8218a 100644 --- a/osi/include/log.h +++ b/osi/include/log.h @@ -27,7 +27,8 @@ /* syslog didn't work well here since we would be redefining LOG_DEBUG. */ #include -#define LOGWRAPPER(tag, fmt, args...) fprintf(stderr, "%s: " fmt "\n", tag, ## args) +#define LOGWRAPPER(tag, fmt, args...) \ + fprintf(stderr, "%s: " fmt "\n", tag, ##args) #define LOG_VERBOSE(...) LOGWRAPPER(__VA_ARGS__) #define LOG_DEBUG(...) LOGWRAPPER(__VA_ARGS__) @@ -35,43 +36,49 @@ #define LOG_WARN(...) LOGWRAPPER(__VA_ARGS__) #define LOG_ERROR(...) LOGWRAPPER(__VA_ARGS__) -#else /* !defined(OS_GENERIC) */ +#else /* !defined(OS_GENERIC) */ #include /** - * These log statements are effectively executing only ALOG(_________, tag, fmt, ## args ). + * These log statements are effectively executing only ALOG(_________, tag, fmt, + * ## args ). * fprintf is only to cause compilation error when LOG_TAG is not provided, * which breaks build on Linux (for OS_GENERIC). */ #if LOG_NDEBUG -#define LOG_VERBOSE(tag, fmt, args...) \ - do { \ - (true) ? ((int)0) : fprintf(stderr, "%s" fmt , tag, ## args); \ - } while (0) +#define LOG_VERBOSE(tag, fmt, args...) \ + do { \ + (true) ? ((int)0) : fprintf(stderr, "%s" fmt, tag, ##args); \ + } while (0) #else // LOG_NDEBUG -#define LOG_VERBOSE(tag, fmt, args...) \ - do { \ - (true) ? ALOG(LOG_VERBOSE, tag, fmt, ## args) : fprintf(stderr, "%s" fmt , tag, ## args); \ - } while (0) +#define LOG_VERBOSE(tag, fmt, args...) \ + do { \ + (true) ? ALOG(LOG_VERBOSE, tag, fmt, ##args) \ + : fprintf(stderr, "%s" fmt, tag, ##args); \ + } while (0) #endif // !LOG_NDEBUG -#define LOG_DEBUG(tag, fmt, args...) \ - do { \ - (true) ? ALOG(LOG_DEBUG, tag, fmt, ## args ) : fprintf(stderr, "%s" fmt , tag, ## args); \ - } while (0) -#define LOG_INFO(tag, fmt, args...) \ - do { \ - (true) ? ALOG(LOG_INFO, tag, fmt, ## args) : fprintf(stderr, "%s" fmt , tag, ## args); \ - } while (0) -#define LOG_WARN(tag, fmt, args...) \ - do { \ - (true) ? ALOG(LOG_WARN, tag, fmt, ## args) : fprintf(stderr, "%s" fmt , tag, ## args); \ - } while (0) -#define LOG_ERROR(tag, fmt, args...) \ - do { \ - (true) ? ALOG(LOG_ERROR, tag, fmt, ## args) : fprintf(stderr, "%s" fmt , tag, ## args); \ - } while (0) +#define LOG_DEBUG(tag, fmt, args...) \ + do { \ + (true) ? ALOG(LOG_DEBUG, tag, fmt, ##args) \ + : fprintf(stderr, "%s" fmt, tag, ##args); \ + } while (0) +#define LOG_INFO(tag, fmt, args...) \ + do { \ + (true) ? ALOG(LOG_INFO, tag, fmt, ##args) \ + : fprintf(stderr, "%s" fmt, tag, ##args); \ + } while (0) +#define LOG_WARN(tag, fmt, args...) \ + do { \ + (true) ? ALOG(LOG_WARN, tag, fmt, ##args) \ + : fprintf(stderr, "%s" fmt, tag, ##args); \ + } while (0) +#define LOG_ERROR(tag, fmt, args...) \ + do { \ + (true) ? ALOG(LOG_ERROR, tag, fmt, ##args) \ + : fprintf(stderr, "%s" fmt, tag, ##args); \ + } while (0) -#endif /* defined(OS_GENERIC) */ +#endif /* defined(OS_GENERIC) */ diff --git a/osi/include/metrics.h b/osi/include/metrics.h index f0aee3c8f..644a8f753 100644 --- a/osi/include/metrics.h +++ b/osi/include/metrics.h @@ -48,8 +48,8 @@ typedef enum { // |type| specifies whether it was acquired or relased, // |requestor| if provided is the service requesting the wake lock. // |name| is the name of the wake lock held. -void metrics_wake_event(wake_event_type_t type, const char *requestor, - const char *name, uint64_t timestamp_ms); +void metrics_wake_event(wake_event_type_t type, const char* requestor, + const char* name, uint64_t timestamp_ms); typedef enum { SCAN_TYPE_UNKNOWN, @@ -63,7 +63,7 @@ typedef enum { // |initiator| is a unique ID identifying the app starting the scan. // |type| is whether the scan reports BR/EDR, LE, or both. // |results| is the number of results to be reported. -void metrics_scan_event(bool start, const char *initator, scan_tech_t type, +void metrics_scan_event(bool start, const char* initator, scan_tech_t type, uint32_t results, uint64_t timestamp_ms); // Record A2DP session information. @@ -81,16 +81,12 @@ void metrics_scan_event(bool start, const char *initator, scan_tech_t type, // |buffer_underruns_average| - TODO - not clear what this is. // |buffer_underruns_count| is the number of times there was no enough // audio data to add to the media buffer. -void metrics_a2dp_session(int64_t session_duration_sec, - const char *disconnect_reason, - uint32_t device_class, - int32_t media_timer_min_ms, - int32_t media_timer_max_ms, - int32_t media_timer_avg_ms, - int32_t buffer_overruns_max_count, - int32_t buffer_overruns_total, - float buffer_underruns_average, - int32_t buffer_underruns_count); +void metrics_a2dp_session( + int64_t session_duration_sec, const char* disconnect_reason, + uint32_t device_class, int32_t media_timer_min_ms, + int32_t media_timer_max_ms, int32_t media_timer_avg_ms, + int32_t buffer_overruns_max_count, int32_t buffer_overruns_total, + float buffer_underruns_average, int32_t buffer_underruns_count); // Writes the metrics, in packed protobuf format, into the descriptor |fd|. // If |clear| is true, metrics events are cleared afterwards. diff --git a/osi/include/osi.h b/osi/include/osi.h index 966c617f5..c54081244 100644 --- a/osi/include/osi.h +++ b/osi/include/osi.h @@ -44,7 +44,8 @@ extern "C" { // C++ code that includes base and osi/include/osi.h can thus easily default to // the definition from libbase but we should check here to avoid compile errors. #ifndef COMPILE_ASSERT -#define COMPILE_ASSERT(COND) typedef int failed_compile_assert[(COND) ? 1 : -1] __attribute__ ((unused)) +#define COMPILE_ASSERT(COND) \ + typedef int failed_compile_assert[(COND) ? 1 : -1] __attribute__((unused)) #endif // COMPILE_ASSERT // Macros for safe integer to pointer conversion. In the C language, data is @@ -52,11 +53,11 @@ extern "C" { // passing in callbacks. These macros should be used sparingly in new code // (never in C++ code). Whenever integers need to be passed as a pointer, use // these macros. -#define PTR_TO_UINT(p) ((unsigned int) ((uintptr_t) (p))) -#define UINT_TO_PTR(u) ((void *) ((uintptr_t) (u))) +#define PTR_TO_UINT(p) ((unsigned int)((uintptr_t)(p))) +#define UINT_TO_PTR(u) ((void*)((uintptr_t)(u))) -#define PTR_TO_INT(p) ((int) ((intptr_t) (p))) -#define INT_TO_PTR(i) ((void *) ((intptr_t) (i))) +#define PTR_TO_INT(p) ((int)((intptr_t)(p))) +#define INT_TO_PTR(i) ((void*)((intptr_t)(i))) // Obtain a random number between 0 and INT_MAX inclusive. // Taken from a system random source such as /dev/random. @@ -65,7 +66,9 @@ extern "C" { int osi_rand(void); // Re-run |fn| system call until the system call doesn't cause EINTR. -#define OSI_NO_INTR(fn) do {} while ((fn) == -1 && errno == EINTR) +#define OSI_NO_INTR(fn) \ + do { \ + } while ((fn) == -1 && errno == EINTR) #ifdef __cplusplus } diff --git a/osi/include/properties.h b/osi/include/properties.h index 35c21e100..c20a3f814 100644 --- a/osi/include/properties.h +++ b/osi/include/properties.h @@ -34,11 +34,11 @@ extern "C" { // (the length does not include the terminating zero). // If the property read fails or returns an empty value, the |default_value| // is used (if nonnull). -int osi_property_get(const char *key, char *value, const char *default_value); +int osi_property_get(const char* key, char* value, const char* default_value); // Write value of property associated with key |key| to |value|. // Returns 0 on success, < 0 on failure -int osi_property_set(const char *key, const char *value); +int osi_property_set(const char* key, const char* value); #ifdef __cplusplus } diff --git a/osi/include/reactor.h b/osi/include/reactor.h index a8739688a..d3eca37eb 100644 --- a/osi/include/reactor.h +++ b/osi/include/reactor.h @@ -35,55 +35,72 @@ typedef struct reactor_object_t reactor_object_t; // Enumerates the reasons a reactor has stopped. typedef enum { - REACTOR_STATUS_STOP, // |reactor_stop| was called. - REACTOR_STATUS_ERROR, // there was an error during the operation. - REACTOR_STATUS_DONE, // the reactor completed its work (for the _run_once* variants). + REACTOR_STATUS_STOP, // |reactor_stop| was called. + REACTOR_STATUS_ERROR, // there was an error during the operation. + REACTOR_STATUS_DONE, // the reactor completed its work (for the _run_once* + // variants). } reactor_status_t; // Creates a new reactor object. Returns NULL on failure. The returned object // must be freed by calling |reactor_free|. -reactor_t *reactor_new(void); +reactor_t* reactor_new(void); // Frees a reactor object created with |reactor_new|. |reactor| may be NULL. -void reactor_free(reactor_t *reactor); +void reactor_free(reactor_t* reactor); -// Starts the reactor. This function blocks the caller until |reactor_stop| is called +// Starts the reactor. This function blocks the caller until |reactor_stop| is +// called // from another thread or in a callback. |reactor| may not be NULL. -reactor_status_t reactor_start(reactor_t *reactor); +reactor_status_t reactor_start(reactor_t* reactor); -// Runs one iteration of the reactor. This function blocks until at least one registered object +// Runs one iteration of the reactor. This function blocks until at least one +// registered object // becomes ready. |reactor| may not be NULL. -reactor_status_t reactor_run_once(reactor_t *reactor); +reactor_status_t reactor_run_once(reactor_t* reactor); -// Immediately unblocks the reactor. This function is safe to call from any thread. +// Immediately unblocks the reactor. This function is safe to call from any +// thread. // |reactor| may not be NULL. -void reactor_stop(reactor_t *reactor); - -// Registers a file descriptor with the reactor. The file descriptor, |fd|, must be valid -// when this function is called and its ownership is not transferred to the reactor. The -// |context| variable is a user-defined opaque handle that is passed back to the |read_ready| -// and |write_ready| functions. It is not copied or even dereferenced by the reactor so it -// may contain any value including NULL. The |read_ready| and |write_ready| arguments are -// optional and may be NULL. This function returns an opaque object that represents the -// file descriptor's registration with the reactor. When the caller is no longer interested -// in events on the |fd|, it must free the returned object by calling |reactor_unregister|. -reactor_object_t *reactor_register(reactor_t *reactor, - int fd, void *context, - void (*read_ready)(void *context), - void (*write_ready)(void *context)); - -// Changes the subscription mode for the file descriptor represented by |object|. If the -// caller has already registered a file descriptor with a reactor, has a valid |object|, -// and decides to change the |read_ready| and/or |write_ready| callback routines, they -// can call this routine. Returns true if the subscription was changed, false otherwise. +void reactor_stop(reactor_t* reactor); + +// Registers a file descriptor with the reactor. The file descriptor, |fd|, must +// be valid +// when this function is called and its ownership is not transferred to the +// reactor. The +// |context| variable is a user-defined opaque handle that is passed back to the +// |read_ready| +// and |write_ready| functions. It is not copied or even dereferenced by the +// reactor so it +// may contain any value including NULL. The |read_ready| and |write_ready| +// arguments are +// optional and may be NULL. This function returns an opaque object that +// represents the +// file descriptor's registration with the reactor. When the caller is no longer +// interested +// in events on the |fd|, it must free the returned object by calling +// |reactor_unregister|. +reactor_object_t* reactor_register(reactor_t* reactor, int fd, void* context, + void (*read_ready)(void* context), + void (*write_ready)(void* context)); + +// Changes the subscription mode for the file descriptor represented by +// |object|. If the +// caller has already registered a file descriptor with a reactor, has a valid +// |object|, +// and decides to change the |read_ready| and/or |write_ready| callback +// routines, they +// can call this routine. Returns true if the subscription was changed, false +// otherwise. // |object| may not be NULL, |read_ready| and |write_ready| may be NULL. -bool reactor_change_registration(reactor_object_t *object, - void (*read_ready)(void *context), - void (*write_ready)(void *context)); - -// Unregisters a previously registered file descriptor with its reactor. |obj| may not be NULL. -// |obj| is invalid after calling this function so the caller must drop all references to it. -void reactor_unregister(reactor_object_t *obj); +bool reactor_change_registration(reactor_object_t* object, + void (*read_ready)(void* context), + void (*write_ready)(void* context)); + +// Unregisters a previously registered file descriptor with its reactor. |obj| +// may not be NULL. +// |obj| is invalid after calling this function so the caller must drop all +// references to it. +void reactor_unregister(reactor_object_t* obj); #ifdef __cplusplus } diff --git a/osi/include/ringbuffer.h b/osi/include/ringbuffer.h index f1c381282..34d8dc429 100644 --- a/osi/include/ringbuffer.h +++ b/osi/include/ringbuffer.h @@ -38,31 +38,32 @@ ringbuffer_t* ringbuffer_init(const size_t size); // Frees the ringbuffer structure and buffer // Save to call with NULL. -void ringbuffer_free(ringbuffer_t *rb); +void ringbuffer_free(ringbuffer_t* rb); // Returns remaining buffer size -size_t ringbuffer_available(const ringbuffer_t *rb); +size_t ringbuffer_available(const ringbuffer_t* rb); // Returns size of data in buffer -size_t ringbuffer_size(const ringbuffer_t *rb); +size_t ringbuffer_size(const ringbuffer_t* rb); // Attempts to insert up to |length| bytes of data at |p| into the buffer // Return actual number of bytes added. Can be less than |length| if buffer // is full. -size_t ringbuffer_insert(ringbuffer_t *rb, const uint8_t *p, size_t length); +size_t ringbuffer_insert(ringbuffer_t* rb, const uint8_t* p, size_t length); // Peek |length| number of bytes from the ringbuffer, starting at |offset|, // into the buffer |p|. Return the actual number of bytes peeked. Can be less // than |length| if there is less than |length| data available. |offset| must // be non-negative. -size_t ringbuffer_peek(const ringbuffer_t *rb, off_t offset, uint8_t *p, size_t length); +size_t ringbuffer_peek(const ringbuffer_t* rb, off_t offset, uint8_t* p, + size_t length); // Does the same as |ringbuffer_peek|, but also advances the ring buffer head -size_t ringbuffer_pop(ringbuffer_t *rb, uint8_t *p, size_t length); +size_t ringbuffer_pop(ringbuffer_t* rb, uint8_t* p, size_t length); // Deletes |length| bytes from the ringbuffer starting from the head // Return actual number of bytes deleted. -size_t ringbuffer_delete(ringbuffer_t *rb, size_t length); +size_t ringbuffer_delete(ringbuffer_t* rb, size_t length); #ifdef __cplusplus } diff --git a/osi/include/semaphore.h b/osi/include/semaphore.h index 4ce373ad8..29d03fd02 100644 --- a/osi/include/semaphore.h +++ b/osi/include/semaphore.h @@ -30,23 +30,24 @@ typedef struct semaphore_t semaphore_t; // Creates a new semaphore with an initial value of |value|. // Returns NULL on failure. The returned object must be released // with |semaphore_free|. -semaphore_t *semaphore_new(unsigned int value); +semaphore_t* semaphore_new(unsigned int value); // Frees a semaphore allocated with |semaphore_new|. |semaphore| may // be NULL. -void semaphore_free(semaphore_t *semaphore); +void semaphore_free(semaphore_t* semaphore); // Decrements the value of |semaphore|. If it is 0, this call blocks until // it becomes non-zero. |semaphore| may not be NULL. -void semaphore_wait(semaphore_t *semaphore); +void semaphore_wait(semaphore_t* semaphore); // Tries to decrement the value of |semaphore|. Returns true if the value was -// decremented, false if the value was 0. This function never blocks. |semaphore| +// decremented, false if the value was 0. This function never blocks. +// |semaphore| // may not be NULL. -bool semaphore_try_wait(semaphore_t *semaphore); +bool semaphore_try_wait(semaphore_t* semaphore); // Increments the value of |semaphore|. |semaphore| may not be NULL. -void semaphore_post(semaphore_t *semaphore); +void semaphore_post(semaphore_t* semaphore); // Returns a file descriptor representing this semaphore. The caller may // only perform one operation on the file descriptor: select(2). If |select| @@ -58,7 +59,7 @@ void semaphore_post(semaphore_t *semaphore); // // The caller must not close the returned file descriptor. |semaphore| may not // be NULL. -int semaphore_get_fd(const semaphore_t *semaphore); +int semaphore_get_fd(const semaphore_t* semaphore); #ifdef __cplusplus } diff --git a/osi/include/socket.h b/osi/include/socket.h index 2ba3f0cbf..e5d4c8e1f 100644 --- a/osi/include/socket.h +++ b/osi/include/socket.h @@ -31,32 +31,37 @@ typedef struct reactor_t reactor_t; typedef struct socket_t socket_t; typedef uint16_t port_t; -typedef void (*socket_cb)(socket_t *socket, void *context); +typedef void (*socket_cb)(socket_t* socket, void* context); -// Returns a new socket object. The socket is in an idle, disconnected state when +// Returns a new socket object. The socket is in an idle, disconnected state +// when // it is returned by this function. The returned object must be freed by calling // |socket_free|. Returns NULL on failure. -socket_t *socket_new(void); +socket_t* socket_new(void); // Returns a new socket object backed by |fd|. The socket object is in whichever -// state |fd| is in when it was passed to this function. The returned object must +// state |fd| is in when it was passed to this function. The returned object +// must // be freed by calling |socket_free|. Returns NULL on failure. If this function -// is successful, ownership of |fd| is transferred and the caller must not close it. -socket_t *socket_new_from_fd(int fd); +// is successful, ownership of |fd| is transferred and the caller must not close +// it. +socket_t* socket_new_from_fd(int fd); -// Frees a socket object created by |socket_new| or |socket_accept|. |socket| may +// Frees a socket object created by |socket_new| or |socket_accept|. |socket| +// may // be NULL. If the socket was connected, it will be disconnected. -void socket_free(socket_t *socket); +void socket_free(socket_t* socket); // Puts |socket| in listening mode for incoming TCP connections on the specified // |port| and the loopback IPv4 address. Returns true on success, false on // failure (e.g. |port| is bound by another socket). |socket| may not be NULL. -bool socket_listen(const socket_t *socket, port_t port); +bool socket_listen(const socket_t* socket, port_t port); -// Blocks on a listening socket, |socket|, until a client connects to it. Returns +// Blocks on a listening socket, |socket|, until a client connects to it. +// Returns // a connected socket on success, NULL on failure. The returned object must be // freed by calling |socket_free|. |socket| may not be NULL. -socket_t *socket_accept(const socket_t *socket); +socket_t* socket_accept(const socket_t* socket); // Reads up to |count| bytes from |socket| into |buf|. This function will not // block. This function returns a positive integer representing the number @@ -68,7 +73,7 @@ socket_t *socket_accept(const socket_t *socket); // restarted internally without propagating EINTR back to the caller. If there // were no bytes available to be read, this function returns -1 and sets errno // to EWOULDBLOCK. Neither |socket| nor |buf| may be NULL. -ssize_t socket_read(const socket_t *socket, void *buf, size_t count); +ssize_t socket_read(const socket_t* socket, void* buf, size_t count); // Writes up to |count| bytes from |buf| into |socket|. This function will not // block. Returns a positive integer representing the number of bytes written @@ -80,32 +85,44 @@ ssize_t socket_read(const socket_t *socket, void *buf, size_t count); // internally without propagating EINTR back to the caller. If no bytes could // be written without blocking, this function will return -1 and set errno to // EWOULDBLOCK. Neither |socket| nor |buf| may be NULL. -ssize_t socket_write(const socket_t *socket, const void *buf, size_t count); +ssize_t socket_write(const socket_t* socket, const void* buf, size_t count); // This function performs the same write operation as |socket_write| and also // sends the file descriptor |fd| over the socket to a remote process. Ownership -// of |fd| transfers to this function and the descriptor must not be used any longer. +// of |fd| transfers to this function and the descriptor must not be used any +// longer. // If |fd| is INVALID_FD, this function behaves the same as |socket_write|. -ssize_t socket_write_and_transfer_fd(const socket_t *socket, const void *buf, size_t count, int fd); +ssize_t socket_write_and_transfer_fd(const socket_t* socket, const void* buf, + size_t count, int fd); -// Returns the number of bytes that can be read from |socket| without blocking. On error, +// Returns the number of bytes that can be read from |socket| without blocking. +// On error, // this function returns -1. |socket| may not be NULL. // -// Note: this function should not be part of the socket interface. It is only provided as -// a stop-gap until we can refactor away code that depends on a priori knowledge of -// the byte count. Do not use this function unless you need it while refactoring +// Note: this function should not be part of the socket interface. It is only +// provided as +// a stop-gap until we can refactor away code that depends on a priori +// knowledge of +// the byte count. Do not use this function unless you need it while +// refactoring // legacy bluedroid code. -ssize_t socket_bytes_available(const socket_t *socket); - -// Registers |socket| with the |reactor|. When the socket becomes readable, |read_cb| -// will be called. When the socket becomes writeable, |write_cb| will be called. The -// |context| parameter is passed, untouched, to each of the callback routines. Neither -// |socket| nor |reactor| may be NULL. |read_cb|, |write_cb|, and |context| may be NULL. -void socket_register(socket_t *socket, reactor_t *reactor, void *context, socket_cb read_cb, socket_cb write_cb); - -// Unregisters |socket| from whichever reactor it is registered with, if any. This +ssize_t socket_bytes_available(const socket_t* socket); + +// Registers |socket| with the |reactor|. When the socket becomes readable, +// |read_cb| +// will be called. When the socket becomes writeable, |write_cb| will be called. +// The +// |context| parameter is passed, untouched, to each of the callback routines. +// Neither +// |socket| nor |reactor| may be NULL. |read_cb|, |write_cb|, and |context| may +// be NULL. +void socket_register(socket_t* socket, reactor_t* reactor, void* context, + socket_cb read_cb, socket_cb write_cb); + +// Unregisters |socket| from whichever reactor it is registered with, if any. +// This // function is idempotent. -void socket_unregister(socket_t *socket); +void socket_unregister(socket_t* socket); #ifdef __cplusplus } diff --git a/osi/include/socket_utils/socket_local.h b/osi/include/socket_utils/socket_local.h index a44bb0c26..08b20c337 100644 --- a/osi/include/socket_utils/socket_local.h +++ b/osi/include/socket_utils/socket_local.h @@ -36,8 +36,8 @@ extern "C" { * * @return 0 on success or -1 on failure */ -int osi_socket_make_sockaddr_un(const char *name, int namespaceId, - struct sockaddr_un *p_addr, socklen_t *alen); +int osi_socket_make_sockaddr_un(const char* name, int namespaceId, + struct sockaddr_un* p_addr, socklen_t* alen); #ifdef __cplusplus } diff --git a/osi/include/socket_utils/sockets.h b/osi/include/socket_utils/sockets.h index 5f0ac3a04..4508a3036 100644 --- a/osi/include/socket_utils/sockets.h +++ b/osi/include/socket_utils/sockets.h @@ -38,11 +38,11 @@ extern "C" { * This is inline and not in libcutils proper because we want to use this in * third-party daemons with minimal modification. */ -static inline int osi_android_get_control_socket(const char *name) { +static inline int osi_android_get_control_socket(const char* name) { char key[64]; snprintf(key, sizeof(key), ANDROID_SOCKET_ENV_PREFIX "%s", name); - const char *val = getenv(key); + const char* val = getenv(key); if (!val) { return -1; } @@ -66,12 +66,12 @@ static inline int osi_android_get_control_socket(const char *name) { // Normal filesystem namespace #define ANDROID_SOCKET_NAMESPACE_FILESYSTEM 2 -extern int osi_socket_local_server(const char *name, int namespaceId, int type); -extern int osi_socket_local_server_bind(int s, const char *name, +extern int osi_socket_local_server(const char* name, int namespaceId, int type); +extern int osi_socket_local_server_bind(int s, const char* name, int namespaceId); -extern int osi_socket_local_client_connect(int fd, const char *name, +extern int osi_socket_local_client_connect(int fd, const char* name, int namespaceId, int type); -extern int osi_socket_local_client(const char *name, int namespaceId, int type); +extern int osi_socket_local_client(const char* name, int namespaceId, int type); #ifdef __cplusplus } diff --git a/osi/include/thread.h b/osi/include/thread.h index 5ca0fa85d..7f9ef8086 100644 --- a/osi/include/thread.h +++ b/osi/include/thread.h @@ -30,54 +30,55 @@ extern "C" { typedef struct reactor_t reactor_t; typedef struct thread_t thread_t; -typedef void (*thread_fn)(void *context); +typedef void (*thread_fn)(void* context); // Creates and starts a new thread with the given name. Only THREAD_NAME_MAX // bytes from |name| will be assigned to the newly-created thread. Returns a // thread object if the thread was successfully started, NULL otherwise. The // returned thread object must be freed with |thread_free|. |name| may not // be NULL. -thread_t *thread_new(const char *name); +thread_t* thread_new(const char* name); // Similar to |thread_new| but creates with a given queue |size|. -thread_t *thread_new_sized(const char *name, size_t size); +thread_t* thread_new_sized(const char* name, size_t size); // Frees the given |thread|. If the thread is still running, it is stopped // and the calling thread will block until |thread| terminates. |thread| // may be NULL. -void thread_free(thread_t *thread); +void thread_free(thread_t* thread); // Waits for |thread_stop|. Upon returning, the only other operations a caller // may perform on |thread| are |thread_free| and |thread_join|. |thread_join| // is idempotent and may be called from any thread. |thread| may not be NULL. -void thread_join(thread_t *thread); +void thread_join(thread_t* thread); // Call |func| with the argument |context| on |thread|. This function typically // does not block unless there are an excessive number of functions posted to // |thread| that have not been dispatched yet. Neither |thread| nor |func| may // be NULL. |context| may be NULL. // Return true on success, otherwise false. -bool thread_post(thread_t *thread, thread_fn func, void *context); +bool thread_post(thread_t* thread, thread_fn func, void* context); // Requests |thread| to stop. Only |thread_free| and |thread_name| may be called // after calling |thread_stop|. This function is guaranteed to not block. // |thread| may not be NULL. -void thread_stop(thread_t *thread); +void thread_stop(thread_t* thread); // Attempts to sets the |priority| of a given |thread|. // The |thread| has to be running for this call to succeed. // Returns true on success. -bool thread_set_priority(thread_t *thread, int priority); +bool thread_set_priority(thread_t* thread, int priority); -// Returns true if the current thread is the same as the one represented by |thread|. +// Returns true if the current thread is the same as the one represented by +// |thread|. // |thread| may not be NULL. -bool thread_is_self(const thread_t *thread); +bool thread_is_self(const thread_t* thread); // Returns the reactor for the given |thread|. |thread| may not be NULL. -reactor_t *thread_get_reactor(const thread_t *thread); +reactor_t* thread_get_reactor(const thread_t* thread); // Returns the name of the given |thread|. |thread| may not be NULL. -const char *thread_name(const thread_t *thread); +const char* thread_name(const thread_t* thread); #ifdef __cplusplus } diff --git a/osi/include/wakelock.h b/osi/include/wakelock.h index e3cbfb03d..0d8415f53 100644 --- a/osi/include/wakelock.h +++ b/osi/include/wakelock.h @@ -18,8 +18,8 @@ #pragma once -#include #include +#include #ifdef __cplusplus extern "C" { @@ -29,7 +29,7 @@ extern "C" { // This function should be called when native kernel wakelocks are not used // directly. If this function is not called, or |callouts| is NULL, then native // kernel wakelocks will be used. -void wakelock_set_os_callouts(bt_os_callouts_t *callouts); +void wakelock_set_os_callouts(bt_os_callouts_t* callouts); // Acquire the Bluetooth wakelock. // The function is thread safe. @@ -51,7 +51,7 @@ void wakelock_cleanup(void); // This is not guaranteed to have any effect after an alarm has been // set with alarm_set. // If |lock_path| or |unlock_path| are NULL, that path is not changed. -void wakelock_set_paths(const char *lock_path, const char *unlock_path); +void wakelock_set_paths(const char* lock_path, const char* unlock_path); // Dump wakelock-related debug info to the |fd| file descriptor. // The caller is responsible for closing the |fd|. diff --git a/osi/src/alarm.cc b/osi/src/alarm.cc index 390bb4525..dfe7a8563 100644 --- a/osi/src/alarm.cc +++ b/osi/src/alarm.cc @@ -58,7 +58,7 @@ typedef struct { // Alarm-related information and statistics typedef struct { - const char *name; + const char* name; size_t scheduled_count; size_t canceled_count; size_t rescheduled_count; @@ -79,16 +79,15 @@ struct alarm_t { period_ms_t creation_time; period_ms_t period; period_ms_t deadline; - period_ms_t prev_deadline; // Previous deadline - used for accounting of - // periodic timers + period_ms_t prev_deadline; // Previous deadline - used for accounting of + // periodic timers bool is_periodic; - fixed_queue_t *queue; // The processing queue to add this alarm to + fixed_queue_t* queue; // The processing queue to add this alarm to alarm_callback_t callback; - void *data; + void* data; alarm_stats_t stats; }; - // If the next wakeup time is less than this threshold, we should acquire // a wakelock instead of setting a wake alarm so we're not bouncing in // and out of suspend frequently. This value is externally visible to allow @@ -106,80 +105,75 @@ static const clockid_t CLOCK_ID_ALARM = CLOCK_BOOTTIME_ALARM; // functions execute serially and not concurrently. As a result, this mutex // also protects the |alarms| list. static pthread_mutex_t monitor; -static list_t *alarms; +static list_t* alarms; static timer_t timer; static timer_t wakeup_timer; static bool timer_set; // All alarm callbacks are dispatched from |dispatcher_thread| -static thread_t *dispatcher_thread; +static thread_t* dispatcher_thread; static bool dispatcher_thread_active; -static semaphore_t *alarm_expired; +static semaphore_t* alarm_expired; // Default alarm callback thread and queue -static thread_t *default_callback_thread; -static fixed_queue_t *default_callback_queue; +static thread_t* default_callback_thread; +static fixed_queue_t* default_callback_queue; -static alarm_t *alarm_new_internal(const char *name, bool is_periodic); +static alarm_t* alarm_new_internal(const char* name, bool is_periodic); static bool lazy_initialize(void); static period_ms_t now(void); -static void alarm_set_internal(alarm_t *alarm, period_ms_t period, - alarm_callback_t cb, void *data, - fixed_queue_t *queue); -static void alarm_cancel_internal(alarm_t *alarm); -static void remove_pending_alarm(alarm_t *alarm); -static void schedule_next_instance(alarm_t *alarm); +static void alarm_set_internal(alarm_t* alarm, period_ms_t period, + alarm_callback_t cb, void* data, + fixed_queue_t* queue); +static void alarm_cancel_internal(alarm_t* alarm); +static void remove_pending_alarm(alarm_t* alarm); +static void schedule_next_instance(alarm_t* alarm); static void reschedule_root_alarm(void); -static void alarm_queue_ready(fixed_queue_t *queue, void *context); -static void timer_callback(void *data); -static void callback_dispatch(void *context); -static bool timer_create_internal(const clockid_t clock_id, timer_t *timer); -static void update_scheduling_stats(alarm_stats_t *stats, - period_ms_t now_ms, +static void alarm_queue_ready(fixed_queue_t* queue, void* context); +static void timer_callback(void* data); +static void callback_dispatch(void* context); +static bool timer_create_internal(const clockid_t clock_id, timer_t* timer); +static void update_scheduling_stats(alarm_stats_t* stats, period_ms_t now_ms, period_ms_t deadline_ms, period_ms_t execution_delta_ms); -static void update_stat(stat_t *stat, period_ms_t delta) -{ - if (stat->max_ms < delta) - stat->max_ms = delta; +static void update_stat(stat_t* stat, period_ms_t delta) { + if (stat->max_ms < delta) stat->max_ms = delta; stat->total_ms += delta; stat->count++; } -alarm_t *alarm_new(const char *name) { - return alarm_new_internal(name, false); -} +alarm_t* alarm_new(const char* name) { return alarm_new_internal(name, false); } -alarm_t *alarm_new_periodic(const char *name) { +alarm_t* alarm_new_periodic(const char* name) { return alarm_new_internal(name, true); } -static alarm_t *alarm_new_internal(const char *name, bool is_periodic) { +static alarm_t* alarm_new_internal(const char* name, bool is_periodic) { // Make sure we have a list we can insert alarms into. if (!alarms && !lazy_initialize()) { - assert(false); // if initialization failed, we should not continue + assert(false); // if initialization failed, we should not continue return NULL; } pthread_mutexattr_t attr; pthread_mutexattr_init(&attr); - alarm_t *ret = static_cast(osi_calloc(sizeof(alarm_t))); + alarm_t* ret = static_cast(osi_calloc(sizeof(alarm_t))); // Make this a recursive mutex to make it safe to call |alarm_cancel| from // within the callback function of the alarm. int error = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); if (error) { - LOG_ERROR(LOG_TAG, "%s unable to create a recursive mutex: %s", - __func__, strerror(error)); + LOG_ERROR(LOG_TAG, "%s unable to create a recursive mutex: %s", __func__, + strerror(error)); goto error; } error = pthread_mutex_init(&ret->callback_lock, &attr); if (error) { - LOG_ERROR(LOG_TAG, "%s unable to initialize mutex: %s", - __func__, strerror(error)); + LOG_ERROR(LOG_TAG, "%s unable to initialize mutex: %s", __func__, + strerror(error)); goto error; } @@ -196,45 +190,42 @@ error: return NULL; } -void alarm_free(alarm_t *alarm) { - if (!alarm) - return; +void alarm_free(alarm_t* alarm) { + if (!alarm) return; alarm_cancel(alarm); pthread_mutex_destroy(&alarm->callback_lock); - osi_free((void *)alarm->stats.name); + osi_free((void*)alarm->stats.name); osi_free(alarm); } -period_ms_t alarm_get_remaining_ms(const alarm_t *alarm) { +period_ms_t alarm_get_remaining_ms(const alarm_t* alarm) { assert(alarm != NULL); period_ms_t remaining_ms = 0; period_ms_t just_now = now(); pthread_mutex_lock(&monitor); - if (alarm->deadline > just_now) - remaining_ms = alarm->deadline - just_now; + if (alarm->deadline > just_now) remaining_ms = alarm->deadline - just_now; pthread_mutex_unlock(&monitor); return remaining_ms; } -void alarm_set(alarm_t *alarm, period_ms_t interval_ms, - alarm_callback_t cb, void *data) { +void alarm_set(alarm_t* alarm, period_ms_t interval_ms, alarm_callback_t cb, + void* data) { alarm_set_on_queue(alarm, interval_ms, cb, data, default_callback_queue); } -void alarm_set_on_queue(alarm_t *alarm, period_ms_t interval_ms, - alarm_callback_t cb, void *data, - fixed_queue_t *queue) { +void alarm_set_on_queue(alarm_t* alarm, period_ms_t interval_ms, + alarm_callback_t cb, void* data, fixed_queue_t* queue) { assert(queue != NULL); alarm_set_internal(alarm, interval_ms, cb, data, queue); } // Runs in exclusion with alarm_cancel and timer_callback. -static void alarm_set_internal(alarm_t *alarm, period_ms_t period, - alarm_callback_t cb, void *data, - fixed_queue_t *queue) { +static void alarm_set_internal(alarm_t* alarm, period_ms_t period, + alarm_callback_t cb, void* data, + fixed_queue_t* queue) { assert(alarms != NULL); assert(alarm != NULL); assert(cb != NULL); @@ -253,10 +244,9 @@ static void alarm_set_internal(alarm_t *alarm, period_ms_t period, pthread_mutex_unlock(&monitor); } -void alarm_cancel(alarm_t *alarm) { +void alarm_cancel(alarm_t* alarm) { assert(alarms != NULL); - if (!alarm) - return; + if (!alarm) return; pthread_mutex_lock(&monitor); alarm_cancel_internal(alarm); @@ -269,8 +259,9 @@ void alarm_cancel(alarm_t *alarm) { // Internal implementation of canceling an alarm. // The caller must hold the |monitor| lock. -static void alarm_cancel_internal(alarm_t *alarm) { - bool needs_reschedule = (!list_is_empty(alarms) && list_front(alarms) == alarm); +static void alarm_cancel_internal(alarm_t* alarm) { + bool needs_reschedule = + (!list_is_empty(alarms) && list_front(alarms) == alarm); remove_pending_alarm(alarm); @@ -281,20 +272,17 @@ static void alarm_cancel_internal(alarm_t *alarm) { alarm->stats.canceled_count++; alarm->queue = NULL; - if (needs_reschedule) - reschedule_root_alarm(); + if (needs_reschedule) reschedule_root_alarm(); } -bool alarm_is_scheduled(const alarm_t *alarm) { - if ((alarms == NULL) || (alarm == NULL)) - return false; +bool alarm_is_scheduled(const alarm_t* alarm) { + if ((alarms == NULL) || (alarm == NULL)) return false; return (alarm->callback != NULL); } void alarm_cleanup(void) { // If lazy_initialize never ran there is nothing else to do - if (!alarms) - return; + if (!alarms) return; dispatcher_thread_active = false; semaphore_post(alarm_expired); @@ -336,12 +324,10 @@ static bool lazy_initialize(void) { goto error; } - if (!timer_create_internal(CLOCK_ID, &timer)) - goto error; + if (!timer_create_internal(CLOCK_ID, &timer)) goto error; timer_initialized = true; - if (!timer_create_internal(CLOCK_ID_ALARM, &wakeup_timer)) - goto error; + if (!timer_create_internal(CLOCK_ID_ALARM, &wakeup_timer)) goto error; wakeup_timer_initialized = true; alarm_expired = semaphore_new(0); @@ -350,8 +336,8 @@ static bool lazy_initialize(void) { goto error; } - default_callback_thread = thread_new_sized("alarm_default_callbacks", - SIZE_MAX); + default_callback_thread = + thread_new_sized("alarm_default_callbacks", SIZE_MAX); if (default_callback_thread == NULL) { LOG_ERROR(LOG_TAG, "%s unable to create default alarm callbacks thread.", __func__); @@ -392,11 +378,9 @@ error: semaphore_free(alarm_expired); alarm_expired = NULL; - if (wakeup_timer_initialized) - timer_delete(wakeup_timer); + if (wakeup_timer_initialized) timer_delete(wakeup_timer); - if (timer_initialized) - timer_delete(timer); + if (timer_initialized) timer_delete(timer); list_free(alarms); alarms = NULL; @@ -411,8 +395,8 @@ static period_ms_t now(void) { struct timespec ts; if (clock_gettime(CLOCK_ID, &ts) == -1) { - LOG_ERROR(LOG_TAG, "%s unable to get current time: %s", - __func__, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to get current time: %s", __func__, + strerror(errno)); return 0; } @@ -421,7 +405,7 @@ static period_ms_t now(void) { // Remove alarm from internal alarm list and the processing queue // The caller must hold the |monitor| lock. -static void remove_pending_alarm(alarm_t *alarm) { +static void remove_pending_alarm(alarm_t* alarm) { list_remove(alarms, alarm); while (fixed_queue_try_remove_from_queue(alarm->queue, alarm) != NULL) { // Remove all repeated alarm instances from the queue. @@ -430,12 +414,12 @@ static void remove_pending_alarm(alarm_t *alarm) { } // Must be called with monitor held -static void schedule_next_instance(alarm_t *alarm) { +static void schedule_next_instance(alarm_t* alarm) { // If the alarm is currently set and it's at the start of the list, // we'll need to re-schedule since we've adjusted the earliest deadline. - bool needs_reschedule = (!list_is_empty(alarms) && list_front(alarms) == alarm); - if (alarm->callback) - remove_pending_alarm(alarm); + bool needs_reschedule = + (!list_is_empty(alarms) && list_front(alarms) == alarm); + if (alarm->callback) remove_pending_alarm(alarm); // Calculate the next deadline for this alarm period_ms_t just_now = now(); @@ -446,19 +430,22 @@ static void schedule_next_instance(alarm_t *alarm) { // Add it into the timer list sorted by deadline (earliest deadline first). if (list_is_empty(alarms) || - ((alarm_t *)list_front(alarms))->deadline > alarm->deadline) { + ((alarm_t*)list_front(alarms))->deadline > alarm->deadline) { list_prepend(alarms, alarm); } else { - for (list_node_t *node = list_begin(alarms); node != list_end(alarms); node = list_next(node)) { - list_node_t *next = list_next(node); - if (next == list_end(alarms) || ((alarm_t *)list_node(next))->deadline > alarm->deadline) { + for (list_node_t* node = list_begin(alarms); node != list_end(alarms); + node = list_next(node)) { + list_node_t* next = list_next(node); + if (next == list_end(alarms) || + ((alarm_t*)list_node(next))->deadline > alarm->deadline) { list_insert_after(alarms, node, alarm); break; } } } - // If the new alarm has the earliest deadline, we need to re-evaluate our schedule. + // If the new alarm has the earliest deadline, we need to re-evaluate our + // schedule. if (needs_reschedule || (!list_is_empty(alarms) && list_front(alarms) == alarm)) { reschedule_root_alarm(); @@ -470,17 +457,16 @@ static void reschedule_root_alarm(void) { assert(alarms != NULL); const bool timer_was_set = timer_set; - alarm_t *next; + alarm_t* next; int64_t next_expiration; // If used in a zeroed state, disarms the timer. struct itimerspec timer_time; memset(&timer_time, 0, sizeof(timer_time)); - if (list_is_empty(alarms)) - goto done; + if (list_is_empty(alarms)) goto done; - next = static_cast(list_front(alarms)); + next = static_cast(list_front(alarms)); next_expiration = next->deadline - now(); if (next_expiration < TIMER_INTERVAL_FOR_WAKELOCK_IN_MS) { if (!timer_set) { @@ -516,16 +502,16 @@ static void reschedule_root_alarm(void) { struct itimerspec wakeup_time; memset(&wakeup_time, 0, sizeof(wakeup_time)); - wakeup_time.it_value.tv_sec = (next->deadline / 1000); wakeup_time.it_value.tv_nsec = (next->deadline % 1000) * 1000000LL; if (timer_settime(wakeup_timer, TIMER_ABSTIME, &wakeup_time, NULL) == -1) - LOG_ERROR(LOG_TAG, "%s unable to set wakeup timer: %s", - __func__, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to set wakeup timer: %s", __func__, + strerror(errno)); } done: - timer_set = timer_time.it_value.tv_sec != 0 || timer_time.it_value.tv_nsec != 0; + timer_set = + timer_time.it_value.tv_sec != 0 || timer_time.it_value.tv_nsec != 0; if (timer_was_set && !timer_set) { wakelock_release(); } @@ -548,13 +534,16 @@ done: timer_gettime(timer, &time_to_expire); if (time_to_expire.it_value.tv_sec == 0 && time_to_expire.it_value.tv_nsec == 0) { - LOG_DEBUG(LOG_TAG, "%s alarm expiration too close for posix timers, switching to guns", __func__); + LOG_DEBUG( + LOG_TAG, + "%s alarm expiration too close for posix timers, switching to guns", + __func__); semaphore_post(alarm_expired); } } } -void alarm_register_processing_queue(fixed_queue_t *queue, thread_t *thread) { +void alarm_register_processing_queue(fixed_queue_t* queue, thread_t* thread) { assert(queue != NULL); assert(thread != NULL); @@ -562,7 +551,7 @@ void alarm_register_processing_queue(fixed_queue_t *queue, thread_t *thread) { alarm_queue_ready, NULL); } -void alarm_unregister_processing_queue(fixed_queue_t *queue) { +void alarm_unregister_processing_queue(fixed_queue_t* queue) { assert(alarms != NULL); assert(queue != NULL); @@ -570,27 +559,25 @@ void alarm_unregister_processing_queue(fixed_queue_t *queue) { // Cancel all alarms that are using this queue pthread_mutex_lock(&monitor); - for (list_node_t *node = list_begin(alarms); node != list_end(alarms); ) { - alarm_t *alarm = (alarm_t *)list_node(node); + for (list_node_t* node = list_begin(alarms); node != list_end(alarms);) { + alarm_t* alarm = (alarm_t*)list_node(node); node = list_next(node); // TODO: Each module is responsible for tearing down its alarms; currently, // this is not the case. In the future, this check should be replaced by // an assert. - if (alarm->queue == queue) - alarm_cancel_internal(alarm); + if (alarm->queue == queue) alarm_cancel_internal(alarm); } pthread_mutex_unlock(&monitor); } -static void alarm_queue_ready(fixed_queue_t *queue, - UNUSED_ATTR void *context) { +static void alarm_queue_ready(fixed_queue_t* queue, UNUSED_ATTR void* context) { assert(queue != NULL); pthread_mutex_lock(&monitor); - alarm_t *alarm = (alarm_t *)fixed_queue_try_dequeue(queue); + alarm_t* alarm = (alarm_t*)fixed_queue_try_dequeue(queue); if (alarm == NULL) { pthread_mutex_unlock(&monitor); - return; // The alarm was probably canceled + return; // The alarm was probably canceled } // @@ -599,7 +586,7 @@ static void alarm_queue_ready(fixed_queue_t *queue, // alarms and active ones. // alarm_callback_t callback = alarm->callback; - void *data = alarm->data; + void* data = alarm->data; period_ms_t deadline = alarm->deadline; if (alarm->is_periodic) { // The periodic alarm has been rescheduled and alarm->deadline has been @@ -627,7 +614,7 @@ static void alarm_queue_ready(fixed_queue_t *queue, } // Callback function for wake alarms and our posix timer -static void timer_callback(UNUSED_ATTR void *ptr) { +static void timer_callback(UNUSED_ATTR void* ptr) { semaphore_post(alarm_expired); } @@ -635,21 +622,20 @@ static void timer_callback(UNUSED_ATTR void *ptr) { // (1) Receives a signal using |alarm_exired| that the alarm has expired // (2) Dispatches the alarm callback for processing by the corresponding // thread for that alarm. -static void callback_dispatch(UNUSED_ATTR void *context) { +static void callback_dispatch(UNUSED_ATTR void* context) { while (true) { semaphore_wait(alarm_expired); - if (!dispatcher_thread_active) - break; + if (!dispatcher_thread_active) break; pthread_mutex_lock(&monitor); - alarm_t *alarm; + alarm_t* alarm; // Take into account that the alarm may get cancelled before we get to it. // We're done here if there are no alarms or the alarm at the front is in // the future. Release the monitor lock and exit right away since there's // nothing left to do. if (list_is_empty(alarms) || - (alarm = static_cast(list_front(alarms)))->deadline > now()) { + (alarm = static_cast(list_front(alarms)))->deadline > now()) { reschedule_root_alarm(); pthread_mutex_unlock(&monitor); continue; @@ -673,7 +659,7 @@ static void callback_dispatch(UNUSED_ATTR void *context) { LOG_DEBUG(LOG_TAG, "%s Callback thread exited", __func__); } -static bool timer_create_internal(const clockid_t clock_id, timer_t *timer) { +static bool timer_create_internal(const clockid_t clock_id, timer_t* timer) { assert(timer != NULL); struct sigevent sigevent; @@ -681,11 +667,17 @@ static bool timer_create_internal(const clockid_t clock_id, timer_t *timer) { sigevent.sigev_notify = SIGEV_THREAD; sigevent.sigev_notify_function = (void (*)(union sigval))timer_callback; if (timer_create(clock_id, &sigevent, timer) == -1) { - LOG_ERROR(LOG_TAG, "%s unable to create timer with clock %d: %s", - __func__, clock_id, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to create timer with clock %d: %s", __func__, + clock_id, strerror(errno)); if (clock_id == CLOCK_BOOTTIME_ALARM) { - LOG_ERROR(LOG_TAG, "The kernel might not have support for timer_create(CLOCK_BOOTTIME_ALARM): https://lwn.net/Articles/429925/"); - LOG_ERROR(LOG_TAG, "See following patches: https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/log/?qt=grep&q=CLOCK_BOOTTIME_ALARM"); + LOG_ERROR(LOG_TAG, + "The kernel might not have support for " + "timer_create(CLOCK_BOOTTIME_ALARM): " + "https://lwn.net/Articles/429925/"); + LOG_ERROR(LOG_TAG, + "See following patches: " + "https://git.kernel.org/cgit/linux/kernel/git/torvalds/" + "linux.git/log/?qt=grep&q=CLOCK_BOOTTIME_ALARM"); } return false; } @@ -693,11 +685,9 @@ static bool timer_create_internal(const clockid_t clock_id, timer_t *timer) { return true; } -static void update_scheduling_stats(alarm_stats_t *stats, - period_ms_t now_ms, +static void update_scheduling_stats(alarm_stats_t* stats, period_ms_t now_ms, period_ms_t deadline_ms, - period_ms_t execution_delta_ms) -{ + period_ms_t execution_delta_ms) { stats->total_updates++; stats->last_update_ms = now_ms; @@ -714,21 +704,16 @@ static void update_scheduling_stats(alarm_stats_t *stats, } } -static void dump_stat(int fd, stat_t *stat, const char *description) -{ - period_ms_t average_time_ms = 0; - if (stat->count != 0) - average_time_ms = stat->total_ms / stat->count; - - dprintf(fd, "%-51s: %llu / %llu / %llu\n", - description, - (unsigned long long)stat->total_ms, - (unsigned long long)stat->max_ms, - (unsigned long long)average_time_ms); +static void dump_stat(int fd, stat_t* stat, const char* description) { + period_ms_t average_time_ms = 0; + if (stat->count != 0) average_time_ms = stat->total_ms / stat->count; + + dprintf(fd, "%-51s: %llu / %llu / %llu\n", description, + (unsigned long long)stat->total_ms, (unsigned long long)stat->max_ms, + (unsigned long long)average_time_ms); } -void alarm_debug_dump(int fd) -{ +void alarm_debug_dump(int fd) { dprintf(fd, "\nBluetooth Alarms Statistics:\n"); pthread_mutex_lock(&monitor); @@ -744,10 +729,10 @@ void alarm_debug_dump(int fd) dprintf(fd, " Total Alarms: %zu\n\n", list_length(alarms)); // Dump info for each alarm - for (list_node_t *node = list_begin(alarms); node != list_end(alarms); + for (list_node_t* node = list_begin(alarms); node != list_end(alarms); node = list_next(node)) { - alarm_t *alarm = (alarm_t *)list_node(node); - alarm_stats_t *stats = &alarm->stats; + alarm_t* alarm = (alarm_t*)list_node(node); + alarm_stats_t* stats = &alarm->stats; dprintf(fd, " Alarm : %s (%s)\n", stats->name, (alarm->is_periodic) ? "PERIODIC" : "SINGLE"); @@ -759,13 +744,12 @@ void alarm_debug_dump(int fd) dprintf(fd, "%-51s: %zu / %zu\n", " Deviation counts (overdue/premature)", - stats->overdue_scheduling.count, - stats->premature_scheduling.count); + stats->overdue_scheduling.count, stats->premature_scheduling.count); dprintf(fd, "%-51s: %llu / %llu / %lld\n", " Time in ms (since creation/interval/remaining)", (unsigned long long)(just_now - alarm->creation_time), - (unsigned long long) alarm->period, + (unsigned long long)alarm->period, (long long)(alarm->deadline - just_now)); dump_stat(fd, &stats->callback_execution, diff --git a/osi/src/allocation_tracker.cc b/osi/src/allocation_tracker.cc index 4a35f30f1..7312cb23a 100644 --- a/osi/src/allocation_tracker.cc +++ b/osi/src/allocation_tracker.cc @@ -32,7 +32,7 @@ typedef struct { uint8_t allocator_id; - void *ptr; + void* ptr; size_t size; bool freed; } allocation_t; @@ -45,12 +45,10 @@ static bool enabled = false; void allocation_tracker_init(void) { std::unique_lock lock(tracker_lock); - if (enabled) - return; + if (enabled) return; // randomize the canary contents - for (size_t i = 0; i < canary_size; i++) - canary[i] = (char)osi_rand(); + for (size_t i = 0; i < canary_size; i++) canary[i] = (char)osi_rand(); LOG_DEBUG(LOG_TAG, "canary initialized"); @@ -60,8 +58,7 @@ void allocation_tracker_init(void) { // Test function only. Do not call in the normal course of operations. void allocation_tracker_uninit(void) { std::unique_lock lock(tracker_lock); - if (!enabled) - return; + if (!enabled) return; allocations.clear(); enabled = false; @@ -69,46 +66,47 @@ void allocation_tracker_uninit(void) { void allocation_tracker_reset(void) { std::unique_lock lock(tracker_lock); - if (!enabled) - return; + if (!enabled) return; allocations.clear(); } size_t allocation_tracker_expect_no_allocations(void) { std::unique_lock lock(tracker_lock); - if (!enabled) - return 0; + if (!enabled) return 0; size_t unfreed_memory_size = 0; - for (const auto &entry : allocations) { - allocation_t *allocation = entry.second; + for (const auto& entry : allocations) { + allocation_t* allocation = entry.second; if (!allocation->freed) { - unfreed_memory_size += allocation->size; // Report back the unfreed byte count - LOG_ERROR(LOG_TAG, "%s found unfreed allocation. address: 0x%zx size: %zd bytes", __func__, (uintptr_t)allocation->ptr, allocation->size); + unfreed_memory_size += + allocation->size; // Report back the unfreed byte count + LOG_ERROR(LOG_TAG, + "%s found unfreed allocation. address: 0x%zx size: %zd bytes", + __func__, (uintptr_t)allocation->ptr, allocation->size); } } return unfreed_memory_size; } -void *allocation_tracker_notify_alloc(uint8_t allocator_id, void *ptr, size_t requested_size) { - char *return_ptr; +void* allocation_tracker_notify_alloc(uint8_t allocator_id, void* ptr, + size_t requested_size) { + char* return_ptr; { std::unique_lock lock(tracker_lock); - if (!enabled || !ptr) - return ptr; + if (!enabled || !ptr) return ptr; - return_ptr = ((char *)ptr) + canary_size; + return_ptr = ((char*)ptr) + canary_size; auto map_entry = allocations.find(return_ptr); - allocation_t *allocation; + allocation_t* allocation; if (map_entry != allocations.end()) { allocation = map_entry->second; - assert(allocation->freed); // Must have been freed before + assert(allocation->freed); // Must have been freed before } else { - allocation = (allocation_t *)calloc(1, sizeof(allocation_t)); + allocation = (allocation_t*)calloc(1, sizeof(allocation_t)); allocations[return_ptr] = allocation; } @@ -116,7 +114,6 @@ void *allocation_tracker_notify_alloc(uint8_t allocator_id, void *ptr, size_t re allocation->freed = false; allocation->size = requested_size; allocation->ptr = return_ptr; - } // Add the canary on both sides @@ -126,21 +123,22 @@ void *allocation_tracker_notify_alloc(uint8_t allocator_id, void *ptr, size_t re return return_ptr; } -void *allocation_tracker_notify_free(UNUSED_ATTR uint8_t allocator_id, void *ptr) { +void* allocation_tracker_notify_free(UNUSED_ATTR uint8_t allocator_id, + void* ptr) { std::unique_lock lock(tracker_lock); - if (!enabled || !ptr) - return ptr; + if (!enabled || !ptr) return ptr; auto map_entry = allocations.find(ptr); assert(map_entry != allocations.end()); - allocation_t *allocation = map_entry->second; - assert(allocation); // Must have been tracked before - assert(!allocation->freed); // Must not be a double free - assert(allocation->allocator_id == allocator_id); // Must be from the same allocator + allocation_t* allocation = map_entry->second; + assert(allocation); // Must have been tracked before + assert(!allocation->freed); // Must not be a double free + assert(allocation->allocator_id == + allocator_id); // Must be from the same allocator allocation->freed = true; - UNUSED_ATTR const char *beginning_canary = ((char *)ptr) - canary_size; - UNUSED_ATTR const char *end_canary = ((char *)ptr) + allocation->size; + UNUSED_ATTR const char* beginning_canary = ((char*)ptr) - canary_size; + UNUSED_ATTR const char* end_canary = ((char*)ptr) + allocation->size; for (size_t i = 0; i < canary_size; i++) { assert(beginning_canary[i] == canary[i]); @@ -152,7 +150,7 @@ void *allocation_tracker_notify_free(UNUSED_ATTR uint8_t allocator_id, void *ptr // as the allocation entry will not be present. allocations.erase(ptr); - return ((char *)ptr) - canary_size; + return ((char*)ptr) - canary_size; } size_t allocation_tracker_resize_for_canary(size_t size) { diff --git a/osi/src/allocator.cc b/osi/src/allocator.cc index 97598035e..aab196417 100644 --- a/osi/src/allocator.cc +++ b/osi/src/allocator.cc @@ -19,80 +19,66 @@ #include #include -#include "osi/include/allocator.h" #include "osi/include/allocation_tracker.h" +#include "osi/include/allocator.h" static const allocator_id_t alloc_allocator_id = 42; -char *osi_strdup(const char *str) { +char* osi_strdup(const char* str) { size_t size = strlen(str) + 1; // + 1 for the null terminator size_t real_size = allocation_tracker_resize_for_canary(size); - void *ptr = malloc(real_size); + void* ptr = malloc(real_size); assert(ptr); - char *new_string = static_cast(allocation_tracker_notify_alloc( - alloc_allocator_id, - ptr, - size)); - if (!new_string) - return NULL; + char* new_string = static_cast( + allocation_tracker_notify_alloc(alloc_allocator_id, ptr, size)); + if (!new_string) return NULL; memcpy(new_string, str, size); return new_string; } -char *osi_strndup(const char *str, size_t len) { +char* osi_strndup(const char* str, size_t len) { size_t size = strlen(str); - if (len < size) - size = len; + if (len < size) size = len; size_t real_size = allocation_tracker_resize_for_canary(size + 1); - void *ptr = malloc(real_size); + void* ptr = malloc(real_size); assert(ptr); - char *new_string = static_cast(allocation_tracker_notify_alloc( - alloc_allocator_id, - ptr, - size + 1)); - if (!new_string) - return NULL; + char* new_string = static_cast( + allocation_tracker_notify_alloc(alloc_allocator_id, ptr, size + 1)); + if (!new_string) return NULL; memcpy(new_string, str, size); new_string[size] = '\0'; return new_string; } -void *osi_malloc(size_t size) { +void* osi_malloc(size_t size) { size_t real_size = allocation_tracker_resize_for_canary(size); - void *ptr = malloc(real_size); + void* ptr = malloc(real_size); assert(ptr); return allocation_tracker_notify_alloc(alloc_allocator_id, ptr, size); } -void *osi_calloc(size_t size) { +void* osi_calloc(size_t size) { size_t real_size = allocation_tracker_resize_for_canary(size); - void *ptr = calloc(1, real_size); + void* ptr = calloc(1, real_size); assert(ptr); return allocation_tracker_notify_alloc(alloc_allocator_id, ptr, size); } -void osi_free(void *ptr) { +void osi_free(void* ptr) { free(allocation_tracker_notify_free(alloc_allocator_id, ptr)); } -void osi_free_and_reset(void **p_ptr) -{ +void osi_free_and_reset(void** p_ptr) { assert(p_ptr != NULL); osi_free(*p_ptr); *p_ptr = NULL; } -const allocator_t allocator_calloc = { - osi_calloc, - osi_free -}; +const allocator_t allocator_calloc = {osi_calloc, osi_free}; -const allocator_t allocator_malloc = { - osi_malloc, - osi_free -}; +const allocator_t allocator_malloc = {osi_malloc, osi_free}; diff --git a/osi/src/array.cc b/osi/src/array.cc index 36df8ae4e..1248e92cb 100644 --- a/osi/src/array.cc +++ b/osi/src/array.cc @@ -31,18 +31,19 @@ struct array_t { size_t element_size; size_t length; size_t capacity; - uint8_t *data; + uint8_t* data; uint8_t internal_storage[]; }; -static bool grow(array_t *array); +static bool grow(array_t* array); static const size_t INTERNAL_ELEMENTS = 16; -array_t *array_new(size_t element_size) { +array_t* array_new(size_t element_size) { assert(element_size > 0); - array_t *array = static_cast(osi_calloc(sizeof(array_t) + element_size * INTERNAL_ELEMENTS)); + array_t* array = static_cast( + osi_calloc(sizeof(array_t) + element_size * INTERNAL_ELEMENTS)); array->element_size = element_size; array->capacity = INTERNAL_ELEMENTS; @@ -50,41 +51,40 @@ array_t *array_new(size_t element_size) { return array; } -void array_free(array_t *array) { - if (!array) - return; +void array_free(array_t* array) { + if (!array) return; - if (array->data != array->internal_storage) - free(array->data); + if (array->data != array->internal_storage) free(array->data); osi_free(array); } -void *array_ptr(const array_t *array) { - return array_at(array, 0); -} +void* array_ptr(const array_t* array) { return array_at(array, 0); } -void *array_at(const array_t *array, size_t index) { +void* array_at(const array_t* array, size_t index) { assert(array != NULL); assert(index < array->length); return array->data + (index * array->element_size); } -size_t array_length(const array_t *array) { +size_t array_length(const array_t* array) { assert(array != NULL); return array->length; } -bool array_append_value(array_t *array, uint32_t value) { +bool array_append_value(array_t* array, uint32_t value) { return array_append_ptr(array, &value); } -bool array_append_ptr(array_t *array, void *data) { +bool array_append_ptr(array_t* array, void* data) { assert(array != NULL); assert(data != NULL); if (array->length == array->capacity && !grow(array)) { - LOG_ERROR(LOG_TAG, "%s unable to grow array past current capacity of %zu elements of size %zu.", __func__, array->capacity, array->element_size); + LOG_ERROR(LOG_TAG, + "%s unable to grow array past current capacity of %zu elements " + "of size %zu.", + __func__, array->capacity, array->element_size); return false; } @@ -93,18 +93,19 @@ bool array_append_ptr(array_t *array, void *data) { return true; } -static bool grow(array_t *array) { +static bool grow(array_t* array) { const size_t new_capacity = array->capacity + (array->capacity / 2); const bool is_moving = (array->data == array->internal_storage); - void *new_data = realloc(is_moving ? NULL : array->data, new_capacity * array->element_size); - if (!new_data) - return false; + void* new_data = realloc(is_moving ? NULL : array->data, + new_capacity * array->element_size); + if (!new_data) return false; if (is_moving) - memcpy(new_data, array->internal_storage, array->length * array->element_size); + memcpy(new_data, array->internal_storage, + array->length * array->element_size); - array->data = static_cast(new_data); + array->data = static_cast(new_data); array->capacity = new_capacity; return true; } diff --git a/osi/src/buffer.cc b/osi/src/buffer.cc index c46d58078..c66e37bf6 100644 --- a/osi/src/buffer.cc +++ b/osi/src/buffer.cc @@ -27,16 +27,17 @@ #include "osi/include/log.h" struct buffer_t { - buffer_t *root; + buffer_t* root; size_t refcount; size_t length; uint8_t data[]; }; -buffer_t *buffer_new(size_t size) { +buffer_t* buffer_new(size_t size) { assert(size > 0); - buffer_t *buffer = static_cast(osi_calloc(sizeof(buffer_t) + size)); + buffer_t* buffer = + static_cast(osi_calloc(sizeof(buffer_t) + size)); buffer->root = buffer; buffer->refcount = 1; @@ -45,17 +46,17 @@ buffer_t *buffer_new(size_t size) { return buffer; } -buffer_t *buffer_new_ref(const buffer_t *buf) { +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) { +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 = static_cast(osi_calloc(sizeof(buffer_t))); + buffer_t* ret = static_cast(osi_calloc(sizeof(buffer_t))); ret->root = buf->root; ret->refcount = SIZE_MAX; @@ -66,14 +67,12 @@ buffer_t *buffer_new_slice(const buffer_t *buf, size_t slice_size) { return ret; } -void buffer_free(buffer_t *buffer) { - if (!buffer) - return; +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); + 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. @@ -81,12 +80,12 @@ void buffer_free(buffer_t *buffer) { } } -void *buffer_ptr(const buffer_t *buf) { +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) { +size_t buffer_length(const buffer_t* buf) { assert(buf != NULL); return buf->length; } diff --git a/osi/src/compat.cc b/osi/src/compat.cc index 44fe5a135..c228c7575 100644 --- a/osi/src/compat.cc +++ b/osi/src/compat.cc @@ -35,11 +35,7 @@ #include "osi/include/osi.h" #if __GLIBC__ -pid_t -gettid(void) -{ - return syscall(SYS_gettid); -} +pid_t gettid(void) { return syscall(SYS_gettid); } #endif /* These functions from bionic @@ -65,30 +61,26 @@ gettid(void) * will be copied. Always NUL terminates (unless siz == 0). * Returns strlen(src); if retval >= siz, truncation occurred. */ -size_t -strlcpy(char *dst, const char *src, size_t siz) -{ - char *d = dst; - const char *s = src; +size_t strlcpy(char* dst, const char* src, size_t siz) { + char* d = dst; + const char* s = src; size_t n = siz; /* Copy as many bytes as will fit */ if (n != 0) { while (--n != 0) { - if ((*d++ = *s++) == '\0') - break; + if ((*d++ = *s++) == '\0') break; } } /* Not enough room in dst, add NUL and traverse rest of src */ if (n == 0) { - if (siz != 0) - *d = '\0'; /* NUL-terminate dst */ + if (siz != 0) *d = '\0'; /* NUL-terminate dst */ while (*s++) ; } - return(s - src - 1); /* count does not include NUL */ + return (s - src - 1); /* count does not include NUL */ } #endif @@ -100,22 +92,18 @@ strlcpy(char *dst, const char *src, size_t siz) * Returns strlen(src) + MIN(siz, strlen(initial dst)). * If retval >= siz, truncation occurred. */ -size_t -strlcat(char *dst, const char *src, size_t siz) -{ - char *d = dst; - const char *s = src; +size_t strlcat(char* dst, const char* src, size_t siz) { + char* d = dst; + const char* s = src; size_t n = siz; size_t dlen; /* Find the end of dst and adjust bytes left but don't go past end */ - while (n-- != 0 && *d != '\0') - d++; + while (n-- != 0 && *d != '\0') d++; dlen = d - dst; n = siz - dlen; - if (n == 0) - return (dlen + strlen(s)); + if (n == 0) return (dlen + strlen(s)); while (*s != '\0') { if (n != 1) { diff --git a/osi/src/config.cc b/osi/src/config.cc index df8beb02e..fb3a6f774 100644 --- a/osi/src/config.cc +++ b/osi/src/config.cc @@ -28,42 +28,43 @@ #include #include #include -#include #include +#include #include "osi/include/allocator.h" #include "osi/include/list.h" #include "osi/include/log.h" typedef struct { - char *key; - char *value; + char* key; + char* value; } entry_t; typedef struct { - char *name; - list_t *entries; + char* name; + list_t* entries; } section_t; struct config_t { - list_t *sections; + list_t* sections; }; // Empty definition; this type is aliased to list_node_t. struct config_section_iter_t {}; -static bool config_parse(FILE *fp, config_t *config); +static bool config_parse(FILE* fp, config_t* config); -static section_t *section_new(const char *name); -static void section_free(void *ptr); -static section_t *section_find(const config_t *config, const char *section); +static section_t* section_new(const char* name); +static void section_free(void* ptr); +static section_t* section_find(const config_t* config, const char* section); -static entry_t *entry_new(const char *key, const char *value); -static void entry_free(void *ptr); -static entry_t *entry_find(const config_t *config, const char *section, const char *key); +static entry_t* entry_new(const char* key, const char* value); +static void entry_free(void* ptr); +static entry_t* entry_find(const config_t* config, const char* section, + const char* key); -config_t *config_new_empty(void) { - config_t *config = static_cast(osi_calloc(sizeof(config_t))); +config_t* config_new_empty(void) { + config_t* config = static_cast(osi_calloc(sizeof(config_t))); config->sections = list_new(section_free); if (!config->sections) { @@ -78,16 +79,16 @@ error:; return NULL; } -config_t *config_new(const char *filename) { +config_t* config_new(const char* filename) { assert(filename != NULL); - config_t *config = config_new_empty(); - if (!config) - return NULL; + config_t* config = config_new_empty(); + if (!config) return NULL; - FILE *fp = fopen(filename, "rt"); + FILE* fp = fopen(filename, "rt"); if (!fp) { - LOG_ERROR(LOG_TAG, "%s unable to open file '%s': %s", __func__, filename, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to open file '%s': %s", __func__, filename, + strerror(errno)); config_free(config); return NULL; } @@ -101,22 +102,21 @@ config_t *config_new(const char *filename) { return config; } -config_t *config_new_clone(const config_t *src) { +config_t* config_new_clone(const config_t* src) { assert(src != NULL); - config_t *ret = config_new_empty(); + config_t* ret = config_new_empty(); assert(ret != NULL); - for (const list_node_t *node = list_begin(src->sections); - node != list_end(src->sections); - node = list_next(node)) { - section_t *sec = static_cast(list_node(node)); + for (const list_node_t* node = list_begin(src->sections); + node != list_end(src->sections); node = list_next(node)) { + section_t* sec = static_cast(list_node(node)); - for (const list_node_t *node_entry = list_begin(sec->entries); + for (const list_node_t* node_entry = list_begin(sec->entries); node_entry != list_end(sec->entries); node_entry = list_next(node_entry)) { - entry_t *entry = static_cast(list_node(node_entry)); + entry_t* entry = static_cast(list_node(node_entry)); config_set_string(ret, sec->name, entry->key, entry->value); } @@ -125,22 +125,22 @@ config_t *config_new_clone(const config_t *src) { return ret; } -void config_free(config_t *config) { - if (!config) - return; +void config_free(config_t* config) { + if (!config) return; list_free(config->sections); osi_free(config); } -bool config_has_section(const config_t *config, const char *section) { +bool config_has_section(const config_t* config, const char* section) { assert(config != NULL); assert(section != NULL); return (section_find(config, section) != NULL); } -bool config_has_key(const config_t *config, const char *section, const char *key) { +bool config_has_key(const config_t* config, const char* section, + const char* key) { assert(config != NULL); assert(section != NULL); assert(key != NULL); @@ -148,60 +148,60 @@ bool config_has_key(const config_t *config, const char *section, const char *key return (entry_find(config, section, key) != NULL); } -int config_get_int(const config_t *config, const char *section, const char *key, int def_value) { +int config_get_int(const config_t* config, const char* section, const char* key, + int def_value) { assert(config != NULL); assert(section != NULL); assert(key != NULL); - entry_t *entry = entry_find(config, section, key); - if (!entry) - return def_value; + entry_t* entry = entry_find(config, section, key); + if (!entry) return def_value; - char *endptr; + char* endptr; int ret = strtol(entry->value, &endptr, 0); return (*endptr == '\0') ? ret : def_value; } -bool config_get_bool(const config_t *config, const char *section, const char *key, bool def_value) { +bool config_get_bool(const config_t* config, const char* section, + const char* key, bool def_value) { assert(config != NULL); assert(section != NULL); assert(key != NULL); - entry_t *entry = entry_find(config, section, key); - if (!entry) - return def_value; + entry_t* entry = entry_find(config, section, key); + if (!entry) return def_value; - if (!strcmp(entry->value, "true")) - return true; - if (!strcmp(entry->value, "false")) - return false; + if (!strcmp(entry->value, "true")) return true; + if (!strcmp(entry->value, "false")) return false; return def_value; } -const char *config_get_string(const config_t *config, const char *section, const char *key, const char *def_value) { +const char* config_get_string(const config_t* config, const char* section, + const char* key, const char* def_value) { assert(config != NULL); assert(section != NULL); assert(key != NULL); - entry_t *entry = entry_find(config, section, key); - if (!entry) - return def_value; + entry_t* entry = entry_find(config, section, key); + if (!entry) return def_value; return entry->value; } -void config_set_int(config_t *config, const char *section, const char *key, int value) { +void config_set_int(config_t* config, const char* section, const char* key, + int value) { assert(config != NULL); assert(section != NULL); assert(key != NULL); - char value_str[32] = { 0 }; + char value_str[32] = {0}; snprintf(value_str, sizeof(value_str), "%d", value); config_set_string(config, section, key, value_str); } -void config_set_bool(config_t *config, const char *section, const char *key, bool value) { +void config_set_bool(config_t* config, const char* section, const char* key, + bool value) { assert(config != NULL); assert(section != NULL); assert(key != NULL); @@ -209,15 +209,17 @@ void config_set_bool(config_t *config, const char *section, const char *key, boo config_set_string(config, section, key, value ? "true" : "false"); } -void config_set_string(config_t *config, const char *section, const char *key, const char *value) { - section_t *sec = section_find(config, section); +void config_set_string(config_t* config, const char* section, const char* key, + const char* value) { + section_t* sec = section_find(config, section); if (!sec) { sec = section_new(section); list_append(config->sections, sec); } - for (const list_node_t *node = list_begin(sec->entries); node != list_end(sec->entries); node = list_next(node)) { - entry_t *entry = static_cast(list_node(node)); + for (const list_node_t* node = list_begin(sec->entries); + node != list_end(sec->entries); node = list_next(node)) { + entry_t* entry = static_cast(list_node(node)); if (!strcmp(entry->key, key)) { osi_free(entry->value); entry->value = osi_strdup(value); @@ -225,57 +227,56 @@ void config_set_string(config_t *config, const char *section, const char *key, c } } - entry_t *entry = entry_new(key, value); + entry_t* entry = entry_new(key, value); list_append(sec->entries, entry); } -bool config_remove_section(config_t *config, const char *section) { +bool config_remove_section(config_t* config, const char* section) { assert(config != NULL); assert(section != NULL); - section_t *sec = section_find(config, section); - if (!sec) - return false; + section_t* sec = section_find(config, section); + if (!sec) return false; return list_remove(config->sections, sec); } -bool config_remove_key(config_t *config, const char *section, const char *key) { +bool config_remove_key(config_t* config, const char* section, const char* key) { assert(config != NULL); assert(section != NULL); assert(key != NULL); - section_t *sec = section_find(config, section); - entry_t *entry = entry_find(config, section, key); - if (!sec || !entry) - return false; + section_t* sec = section_find(config, section); + entry_t* entry = entry_find(config, section, key); + if (!sec || !entry) return false; return list_remove(sec->entries, entry); } -const config_section_node_t *config_section_begin(const config_t *config) { +const config_section_node_t* config_section_begin(const config_t* config) { assert(config != NULL); - return (const config_section_node_t *)list_begin(config->sections); + return (const config_section_node_t*)list_begin(config->sections); } -const config_section_node_t *config_section_end(const config_t *config) { +const config_section_node_t* config_section_end(const config_t* config) { assert(config != NULL); - return (const config_section_node_t *)list_end(config->sections); + return (const config_section_node_t*)list_end(config->sections); } -const config_section_node_t *config_section_next(const config_section_node_t *node) { +const config_section_node_t* config_section_next( + const config_section_node_t* node) { assert(node != NULL); - return (const config_section_node_t *)list_next((const list_node_t *)node); + return (const config_section_node_t*)list_next((const list_node_t*)node); } -const char *config_section_name(const config_section_node_t *node) { +const char* config_section_name(const config_section_node_t* node) { assert(node != NULL); - const list_node_t *lnode = (const list_node_t *)node; - const section_t *section = (const section_t *)list_node(lnode); + const list_node_t* lnode = (const list_node_t*)node; + const section_t* section = (const section_t*)list_node(lnode); return section->name; } -bool config_save(const config_t *config, const char *filename) { +bool config_save(const config_t* config, const char* filename) { assert(config != NULL); assert(filename != NULL); assert(*filename != '\0'); @@ -289,46 +290,53 @@ bool config_save(const config_t *config, const char *filename) { // 4) Sync directory that has the conf file with fsync(). // This ensures directory entries are up-to-date. int dir_fd = -1; - FILE *fp = NULL; + FILE* fp = NULL; // Build temp config file based on config file (e.g. bt_config.conf.new). - static const char *temp_file_ext = ".new"; + static const char* temp_file_ext = ".new"; const int filename_len = strlen(filename); const int temp_filename_len = filename_len + strlen(temp_file_ext) + 1; - char *temp_filename = static_cast(osi_calloc(temp_filename_len)); + char* temp_filename = static_cast(osi_calloc(temp_filename_len)); snprintf(temp_filename, temp_filename_len, "%s%s", filename, temp_file_ext); // Extract directory from file path (e.g. /data/misc/bluedroid). - char *temp_dirname = osi_strdup(filename); - const char *directoryname = dirname(temp_dirname); + char* temp_dirname = osi_strdup(filename); + const char* directoryname = dirname(temp_dirname); if (!directoryname) { - LOG_ERROR(LOG_TAG, "%s error extracting directory from '%s': %s", __func__, filename, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s error extracting directory from '%s': %s", __func__, + filename, strerror(errno)); goto error; } dir_fd = open(directoryname, O_RDONLY); if (dir_fd < 0) { - LOG_ERROR(LOG_TAG, "%s unable to open dir '%s': %s", __func__, directoryname, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to open dir '%s': %s", __func__, + directoryname, strerror(errno)); goto error; } fp = fopen(temp_filename, "wt"); if (!fp) { - LOG_ERROR(LOG_TAG, "%s unable to write file '%s': %s", __func__, temp_filename, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to write file '%s': %s", __func__, + temp_filename, strerror(errno)); goto error; } - for (const list_node_t *node = list_begin(config->sections); node != list_end(config->sections); node = list_next(node)) { - const section_t *section = (const section_t *)list_node(node); + for (const list_node_t* node = list_begin(config->sections); + node != list_end(config->sections); node = list_next(node)) { + const section_t* section = (const section_t*)list_node(node); if (fprintf(fp, "[%s]\n", section->name) < 0) { - LOG_ERROR(LOG_TAG, "%s unable to write to file '%s': %s", __func__, temp_filename, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to write to file '%s': %s", __func__, + temp_filename, strerror(errno)); goto error; } - for (const list_node_t *enode = list_begin(section->entries); enode != list_end(section->entries); enode = list_next(enode)) { - const entry_t *entry = (const entry_t *)list_node(enode); + for (const list_node_t* enode = list_begin(section->entries); + enode != list_end(section->entries); enode = list_next(enode)) { + const entry_t* entry = (const entry_t*)list_node(enode); if (fprintf(fp, "%s = %s\n", entry->key, entry->value) < 0) { - LOG_ERROR(LOG_TAG, "%s unable to write to file '%s': %s", __func__, temp_filename, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to write to file '%s': %s", __func__, + temp_filename, strerror(errno)); goto error; } } @@ -336,42 +344,50 @@ bool config_save(const config_t *config, const char *filename) { // Only add a separating newline if there are more sections. if (list_next(node) != list_end(config->sections)) { if (fputc('\n', fp) == EOF) { - LOG_ERROR(LOG_TAG, "%s unable to write to file '%s': %s", __func__, temp_filename, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to write to file '%s': %s", __func__, + temp_filename, strerror(errno)); goto error; } } } - // Sync written temp file out to disk. fsync() is blocking until data makes it to disk. + // Sync written temp file out to disk. fsync() is blocking until data makes it + // to disk. if (fsync(fileno(fp)) < 0) { - LOG_WARN(LOG_TAG, "%s unable to fsync file '%s': %s", __func__, temp_filename, strerror(errno)); + LOG_WARN(LOG_TAG, "%s unable to fsync file '%s': %s", __func__, + temp_filename, strerror(errno)); } if (fclose(fp) == EOF) { - LOG_ERROR(LOG_TAG, "%s unable to close file '%s': %s", __func__, temp_filename, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to close file '%s': %s", __func__, + temp_filename, strerror(errno)); goto error; } fp = NULL; // Change the file's permissions to Read/Write by User and Group if (chmod(temp_filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP) == -1) { - LOG_ERROR(LOG_TAG, "%s unable to change file permissions '%s': %s", __func__, filename, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to change file permissions '%s': %s", + __func__, filename, strerror(errno)); goto error; } // Rename written temp file to the actual config file. if (rename(temp_filename, filename) == -1) { - LOG_ERROR(LOG_TAG, "%s unable to commit file '%s': %s", __func__, filename, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to commit file '%s': %s", __func__, filename, + strerror(errno)); goto error; } // This should ensure the directory is updated as well. if (fsync(dir_fd) < 0) { - LOG_WARN(LOG_TAG, "%s unable to fsync dir '%s': %s", __func__, directoryname, strerror(errno)); + LOG_WARN(LOG_TAG, "%s unable to fsync dir '%s': %s", __func__, + directoryname, strerror(errno)); } if (close(dir_fd) < 0) { - LOG_ERROR(LOG_TAG, "%s unable to close dir '%s': %s", __func__, directoryname, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to close dir '%s': %s", __func__, + directoryname, strerror(errno)); goto error; } @@ -380,33 +396,29 @@ bool config_save(const config_t *config, const char *filename) { return true; error: - // This indicates there is a write issue. Unlink as partial data is not acceptable. + // This indicates there is a write issue. Unlink as partial data is not + // acceptable. unlink(temp_filename); - if (fp) - fclose(fp); - if (dir_fd != -1) - close(dir_fd); + if (fp) fclose(fp); + if (dir_fd != -1) close(dir_fd); osi_free(temp_filename); osi_free(temp_dirname); return false; } -static char *trim(char *str) { - while (isspace(*str)) - ++str; +static char* trim(char* str) { + while (isspace(*str)) ++str; - if (!*str) - return str; + if (!*str) return str; - char *end_str = str + strlen(str) - 1; - while (end_str > str && isspace(*end_str)) - --end_str; + char* end_str = str + strlen(str) - 1; + while (end_str > str && isspace(*end_str)) --end_str; end_str[1] = '\0'; return str; } -static bool config_parse(FILE *fp, config_t *config) { +static bool config_parse(FILE* fp, config_t* config) { assert(fp != NULL); assert(config != NULL); @@ -416,25 +428,26 @@ static bool config_parse(FILE *fp, config_t *config) { strcpy(section, CONFIG_DEFAULT_SECTION); while (fgets(line, sizeof(line), fp)) { - char *line_ptr = trim(line); + char* line_ptr = trim(line); ++line_num; // Skip blank and comment lines. - if (*line_ptr == '\0' || *line_ptr == '#') - continue; + if (*line_ptr == '\0' || *line_ptr == '#') continue; if (*line_ptr == '[') { size_t len = strlen(line_ptr); if (line_ptr[len - 1] != ']') { - LOG_DEBUG(LOG_TAG, "%s unterminated section name on line %d.", __func__, line_num); + LOG_DEBUG(LOG_TAG, "%s unterminated section name on line %d.", __func__, + line_num); return false; } strncpy(section, line_ptr + 1, len - 2); section[len - 2] = '\0'; } else { - char *split = strchr(line_ptr, '='); + char* split = strchr(line_ptr, '='); if (!split) { - LOG_DEBUG(LOG_TAG, "%s no key/value separator found on line %d.", __func__, line_num); + LOG_DEBUG(LOG_TAG, "%s no key/value separator found on line %d.", + __func__, line_num); return false; } @@ -445,63 +458,59 @@ static bool config_parse(FILE *fp, config_t *config) { return true; } -static section_t *section_new(const char *name) { - section_t *section = static_cast(osi_calloc(sizeof(section_t))); +static section_t* section_new(const char* name) { + section_t* section = static_cast(osi_calloc(sizeof(section_t))); section->name = osi_strdup(name); section->entries = list_new(entry_free); return section; } -static void section_free(void *ptr) { - if (!ptr) - return; +static void section_free(void* ptr) { + if (!ptr) return; - section_t *section = static_cast(ptr); + section_t* section = static_cast(ptr); osi_free(section->name); list_free(section->entries); osi_free(section); } -static section_t *section_find(const config_t *config, const char *section) { - for (const list_node_t *node = list_begin(config->sections); +static section_t* section_find(const config_t* config, const char* section) { + for (const list_node_t* node = list_begin(config->sections); node != list_end(config->sections); node = list_next(node)) { - section_t *sec = static_cast(list_node(node)); - if (!strcmp(sec->name, section)) - return sec; + section_t* sec = static_cast(list_node(node)); + if (!strcmp(sec->name, section)) return sec; } return NULL; } -static entry_t *entry_new(const char *key, const char *value) { - entry_t *entry = static_cast(osi_calloc(sizeof(entry_t))); +static entry_t* entry_new(const char* key, const char* value) { + entry_t* entry = static_cast(osi_calloc(sizeof(entry_t))); entry->key = osi_strdup(key); entry->value = osi_strdup(value); return entry; } -static void entry_free(void *ptr) { - if (!ptr) - return; +static void entry_free(void* ptr) { + if (!ptr) return; - entry_t *entry = static_cast(ptr); + entry_t* entry = static_cast(ptr); osi_free(entry->key); osi_free(entry->value); osi_free(entry); } -static entry_t *entry_find(const config_t *config, const char *section, const char *key) { - section_t *sec = section_find(config, section); - if (!sec) - return NULL; +static entry_t* entry_find(const config_t* config, const char* section, + const char* key) { + section_t* sec = section_find(config, section); + if (!sec) return NULL; - for (const list_node_t *node = list_begin(sec->entries); + for (const list_node_t* node = list_begin(sec->entries); node != list_end(sec->entries); node = list_next(node)) { - entry_t *entry = static_cast(list_node(node)); - if (!strcmp(entry->key, key)) - return entry; + entry_t* entry = static_cast(list_node(node)); + if (!strcmp(entry->key, key)) return entry; } return NULL; diff --git a/osi/src/data_dispatcher.cc b/osi/src/data_dispatcher.cc index c8705f91d..e1a59cc80 100644 --- a/osi/src/data_dispatcher.cc +++ b/osi/src/data_dispatcher.cc @@ -24,23 +24,25 @@ #include #include "osi/include/allocator.h" -#include "osi/include/osi.h" #include "osi/include/log.h" +#include "osi/include/osi.h" #define DEFAULT_TABLE_BUCKETS 10 -typedef std::unordered_map DispatchTableMap; +typedef std::unordered_map + DispatchTableMap; struct data_dispatcher_t { - char *name; - DispatchTableMap *dispatch_table; - fixed_queue_t *default_queue; // We don't own this queue + char* name; + DispatchTableMap* dispatch_table; + fixed_queue_t* default_queue; // We don't own this queue }; -data_dispatcher_t *data_dispatcher_new(const char *name) { +data_dispatcher_t* data_dispatcher_new(const char* name) { assert(name != NULL); - data_dispatcher_t *ret = (data_dispatcher_t*)osi_calloc(sizeof(data_dispatcher_t)); + data_dispatcher_t* ret = + (data_dispatcher_t*)osi_calloc(sizeof(data_dispatcher_t)); ret->dispatch_table = new DispatchTableMap(); @@ -57,36 +59,38 @@ error:; return NULL; } -void data_dispatcher_free(data_dispatcher_t *dispatcher) { - if (!dispatcher) - return; +void data_dispatcher_free(data_dispatcher_t* dispatcher) { + if (!dispatcher) return; delete dispatcher->dispatch_table; osi_free(dispatcher->name); osi_free(dispatcher); } -void data_dispatcher_register(data_dispatcher_t *dispatcher, data_dispatcher_type_t type, fixed_queue_t *queue) { +void data_dispatcher_register(data_dispatcher_t* dispatcher, + data_dispatcher_type_t type, + fixed_queue_t* queue) { assert(dispatcher != NULL); if (queue) (*dispatcher->dispatch_table)[type] = queue; else dispatcher->dispatch_table->erase(type); - } -void data_dispatcher_register_default(data_dispatcher_t *dispatcher, fixed_queue_t *queue) { +void data_dispatcher_register_default(data_dispatcher_t* dispatcher, + fixed_queue_t* queue) { assert(dispatcher != NULL); dispatcher->default_queue = queue; } -bool data_dispatcher_dispatch(data_dispatcher_t *dispatcher, data_dispatcher_type_t type, void *data) { +bool data_dispatcher_dispatch(data_dispatcher_t* dispatcher, + data_dispatcher_type_t type, void* data) { assert(dispatcher != NULL); assert(data != NULL); - fixed_queue_t *queue; + fixed_queue_t* queue; auto iter = dispatcher->dispatch_table->find(type); if (iter == dispatcher->dispatch_table->end()) queue = dispatcher->default_queue; @@ -96,7 +100,9 @@ bool data_dispatcher_dispatch(data_dispatcher_t *dispatcher, data_dispatcher_typ if (queue) fixed_queue_enqueue(queue, data); else - LOG_WARN(LOG_TAG, "%s has no handler for type (%zd) in data dispatcher named: %s", __func__, type, dispatcher->name); + LOG_WARN(LOG_TAG, + "%s has no handler for type (%zd) in data dispatcher named: %s", + __func__, type, dispatcher->name); return queue != NULL; } diff --git a/osi/src/eager_reader.cc b/osi/src/eager_reader.cc index f2ef1beb2..0f4ff29ea 100644 --- a/osi/src/eager_reader.cc +++ b/osi/src/eager_reader.cc @@ -32,7 +32,7 @@ #include "osi/include/reactor.h" #if !defined(EFD_SEMAPHORE) -# define EFD_SEMAPHORE (1 << 0) +#define EFD_SEMAPHORE (1 << 0) #endif typedef struct { @@ -42,47 +42,46 @@ typedef struct { } data_buffer_t; struct eager_reader_t { - int bytes_available_fd; // semaphore mode eventfd which counts the number of available bytes + int bytes_available_fd; // semaphore mode eventfd which counts the number of + // available bytes int inbound_fd; - const allocator_t *allocator; + const allocator_t* allocator; size_t buffer_size; - fixed_queue_t *buffers; - data_buffer_t *current_buffer; + fixed_queue_t* buffers; + data_buffer_t* current_buffer; - thread_t *inbound_read_thread; - reactor_object_t *inbound_read_object; + thread_t* inbound_read_thread; + reactor_object_t* inbound_read_object; - reactor_object_t *outbound_registration; + reactor_object_t* outbound_registration; eager_reader_cb outbound_read_ready; - void *outbound_context; + void* outbound_context; }; -static bool has_byte(const eager_reader_t *reader); -static void inbound_data_waiting(void *context); -static void internal_outbound_read_ready(void *context); - -eager_reader_t *eager_reader_new( - int fd_to_read, - const allocator_t *allocator, - size_t buffer_size, - size_t max_buffer_count, - const char *thread_name) { +static bool has_byte(const eager_reader_t* reader); +static void inbound_data_waiting(void* context); +static void internal_outbound_read_ready(void* context); +eager_reader_t* eager_reader_new(int fd_to_read, const allocator_t* allocator, + size_t buffer_size, size_t max_buffer_count, + const char* thread_name) { assert(fd_to_read != INVALID_FD); assert(allocator != NULL); assert(buffer_size > 0); assert(max_buffer_count > 0); assert(thread_name != NULL && *thread_name != '\0'); - eager_reader_t *ret = static_cast(osi_calloc(sizeof(eager_reader_t))); + eager_reader_t* ret = + static_cast(osi_calloc(sizeof(eager_reader_t))); ret->allocator = allocator; ret->inbound_fd = fd_to_read; ret->bytes_available_fd = eventfd(0, 0); if (ret->bytes_available_fd == INVALID_FD) { - LOG_ERROR(LOG_TAG, "%s unable to create output reading semaphore.", __func__); + LOG_ERROR(LOG_TAG, "%s unable to create output reading semaphore.", + __func__); goto error; } @@ -100,13 +99,9 @@ eager_reader_t *eager_reader_new( goto error; } - ret->inbound_read_object = reactor_register( - thread_get_reactor(ret->inbound_read_thread), - fd_to_read, - ret, - inbound_data_waiting, - NULL - ); + ret->inbound_read_object = + reactor_register(thread_get_reactor(ret->inbound_read_thread), fd_to_read, + ret, inbound_data_waiting, NULL); return ret; @@ -115,9 +110,8 @@ error:; return NULL; } -void eager_reader_free(eager_reader_t *reader) { - if (!reader) - return; +void eager_reader_free(eager_reader_t* reader) { + if (!reader) return; eager_reader_unregister(reader); @@ -130,15 +124,15 @@ void eager_reader_free(eager_reader_t *reader) { // Free the current buffer, because it's not in the queue // and won't be freed below - if (reader->current_buffer) - reader->allocator->free(reader->current_buffer); + if (reader->current_buffer) reader->allocator->free(reader->current_buffer); fixed_queue_free(reader->buffers, reader->allocator->free); thread_free(reader->inbound_read_thread); osi_free(reader); } -void eager_reader_register(eager_reader_t *reader, reactor_t *reactor, eager_reader_cb read_cb, void *context) { +void eager_reader_register(eager_reader_t* reader, reactor_t* reactor, + eager_reader_cb read_cb, void* context) { assert(reader != NULL); assert(reactor != NULL); assert(read_cb != NULL); @@ -148,10 +142,12 @@ void eager_reader_register(eager_reader_t *reader, reactor_t *reactor, eager_rea reader->outbound_read_ready = read_cb; reader->outbound_context = context; - reader->outbound_registration = reactor_register(reactor, reader->bytes_available_fd, reader, internal_outbound_read_ready, NULL); + reader->outbound_registration = + reactor_register(reactor, reader->bytes_available_fd, reader, + internal_outbound_read_ready, NULL); } -void eager_reader_unregister(eager_reader_t *reader) { +void eager_reader_unregister(eager_reader_t* reader) { assert(reader != NULL); if (reader->outbound_registration) { @@ -161,34 +157,38 @@ void eager_reader_unregister(eager_reader_t *reader) { } // SEE HEADER FOR THREAD SAFETY NOTE -size_t eager_reader_read(eager_reader_t *reader, uint8_t *buffer, size_t max_size) { +size_t eager_reader_read(eager_reader_t* reader, uint8_t* buffer, + size_t max_size) { assert(reader != NULL); assert(buffer != NULL); // Poll to see if we have any bytes available before reading. - if (!has_byte(reader)) - return 0; + if (!has_byte(reader)) return 0; // Find out how many bytes we have available in our various buffers. eventfd_t bytes_available; if (eventfd_read(reader->bytes_available_fd, &bytes_available) == -1) { - LOG_ERROR(LOG_TAG, "%s unable to read semaphore for output data.", __func__); + LOG_ERROR(LOG_TAG, "%s unable to read semaphore for output data.", + __func__); return 0; } - if (max_size > bytes_available) - max_size = bytes_available; + if (max_size > bytes_available) max_size = bytes_available; size_t bytes_consumed = 0; while (bytes_consumed < max_size) { if (!reader->current_buffer) - reader->current_buffer = static_cast(fixed_queue_dequeue(reader->buffers)); + reader->current_buffer = + static_cast(fixed_queue_dequeue(reader->buffers)); - size_t bytes_to_copy = reader->current_buffer->length - reader->current_buffer->offset; + size_t bytes_to_copy = + reader->current_buffer->length - reader->current_buffer->offset; if (bytes_to_copy > (max_size - bytes_consumed)) bytes_to_copy = max_size - bytes_consumed; - memcpy(&buffer[bytes_consumed], &reader->current_buffer->data[reader->current_buffer->offset], bytes_to_copy); + memcpy(&buffer[bytes_consumed], + &reader->current_buffer->data[reader->current_buffer->offset], + bytes_to_copy); bytes_consumed += bytes_to_copy; reader->current_buffer->offset += bytes_to_copy; @@ -200,18 +200,20 @@ size_t eager_reader_read(eager_reader_t *reader, uint8_t *buffer, size_t max_siz bytes_available -= bytes_consumed; if (eventfd_write(reader->bytes_available_fd, bytes_available) == -1) { - LOG_ERROR(LOG_TAG, "%s unable to write back bytes available for output data.", __func__); + LOG_ERROR(LOG_TAG, + "%s unable to write back bytes available for output data.", + __func__); } return bytes_consumed; } -thread_t* eager_reader_get_read_thread(const eager_reader_t *reader) { +thread_t* eager_reader_get_read_thread(const eager_reader_t* reader) { assert(reader != NULL); return reader->inbound_read_thread; } -static bool has_byte(const eager_reader_t *reader) { +static bool has_byte(const eager_reader_t* reader) { assert(reader != NULL); fd_set read_fds; @@ -225,22 +227,23 @@ static bool has_byte(const eager_reader_t *reader) { timeout.tv_sec = 0; timeout.tv_usec = 0; - int ret = select(reader->bytes_available_fd + 1, &read_fds, NULL, NULL, - &timeout); - if (ret == -1 && errno == EINTR) - continue; + int ret = + select(reader->bytes_available_fd + 1, &read_fds, NULL, NULL, &timeout); + if (ret == -1 && errno == EINTR) continue; break; } return FD_ISSET(reader->bytes_available_fd, &read_fds); } -static void inbound_data_waiting(void *context) { - eager_reader_t *reader = (eager_reader_t *)context; +static void inbound_data_waiting(void* context) { + eager_reader_t* reader = (eager_reader_t*)context; - data_buffer_t *buffer = (data_buffer_t *)reader->allocator->alloc(reader->buffer_size + sizeof(data_buffer_t)); + data_buffer_t* buffer = (data_buffer_t*)reader->allocator->alloc( + reader->buffer_size + sizeof(data_buffer_t)); if (!buffer) { - LOG_ERROR(LOG_TAG, "%s couldn't aquire memory for inbound data buffer.", __func__); + LOG_ERROR(LOG_TAG, "%s couldn't aquire memory for inbound data buffer.", + __func__); return; } @@ -248,8 +251,8 @@ static void inbound_data_waiting(void *context) { buffer->offset = 0; ssize_t bytes_read; - OSI_NO_INTR(bytes_read = read(reader->inbound_fd, buffer->data, - reader->buffer_size)); + OSI_NO_INTR(bytes_read = + read(reader->inbound_fd, buffer->data, reader->buffer_size)); if (bytes_read > 0) { // Save the data for later buffer->length = bytes_read; @@ -260,17 +263,19 @@ static void inbound_data_waiting(void *context) { eventfd_write(reader->bytes_available_fd, bytes_read); } else { if (bytes_read == 0) - LOG_WARN(LOG_TAG, "%s fd said bytes existed, but none were found.", __func__); + LOG_WARN(LOG_TAG, "%s fd said bytes existed, but none were found.", + __func__); else - LOG_WARN(LOG_TAG, "%s unable to read from file descriptor: %s", __func__, strerror(errno)); + LOG_WARN(LOG_TAG, "%s unable to read from file descriptor: %s", __func__, + strerror(errno)); reader->allocator->free(buffer); } } -static void internal_outbound_read_ready(void *context) { +static void internal_outbound_read_ready(void* context) { assert(context != NULL); - eager_reader_t *reader = (eager_reader_t *)context; + eager_reader_t* reader = (eager_reader_t*)context; reader->outbound_read_ready(reader, reader->outbound_context); } diff --git a/osi/src/fixed_queue.cc b/osi/src/fixed_queue.cc index e46ad5093..a4cd08d38 100644 --- a/osi/src/fixed_queue.cc +++ b/osi/src/fixed_queue.cc @@ -24,40 +24,38 @@ #include "osi/include/fixed_queue.h" #include "osi/include/list.h" #include "osi/include/osi.h" -#include "osi/include/semaphore.h" #include "osi/include/reactor.h" +#include "osi/include/semaphore.h" typedef struct fixed_queue_t { - list_t *list; - semaphore_t *enqueue_sem; - semaphore_t *dequeue_sem; + list_t* list; + semaphore_t* enqueue_sem; + semaphore_t* dequeue_sem; pthread_mutex_t lock; size_t capacity; - reactor_object_t *dequeue_object; + reactor_object_t* dequeue_object; fixed_queue_cb dequeue_ready; - void *dequeue_context; + void* dequeue_context; } fixed_queue_t; -static void internal_dequeue_ready(void *context); +static void internal_dequeue_ready(void* context); -fixed_queue_t *fixed_queue_new(size_t capacity) { - fixed_queue_t *ret = static_cast(osi_calloc(sizeof(fixed_queue_t))); +fixed_queue_t* fixed_queue_new(size_t capacity) { + fixed_queue_t* ret = + static_cast(osi_calloc(sizeof(fixed_queue_t))); pthread_mutex_init(&ret->lock, NULL); ret->capacity = capacity; ret->list = list_new(NULL); - if (!ret->list) - goto error; + if (!ret->list) goto error; ret->enqueue_sem = semaphore_new(capacity); - if (!ret->enqueue_sem) - goto error; + if (!ret->enqueue_sem) goto error; ret->dequeue_sem = semaphore_new(0); - if (!ret->dequeue_sem) - goto error; + if (!ret->dequeue_sem) goto error; return ret; @@ -66,14 +64,14 @@ error: return NULL; } -void fixed_queue_free(fixed_queue_t *queue, fixed_queue_free_cb free_cb) { - if (!queue) - return; +void fixed_queue_free(fixed_queue_t* queue, fixed_queue_free_cb free_cb) { + if (!queue) return; fixed_queue_unregister_dequeue(queue); if (free_cb) - for (const list_node_t *node = list_begin(queue->list); node != list_end(queue->list); node = list_next(node)) + for (const list_node_t* node = list_begin(queue->list); + node != list_end(queue->list); node = list_next(node)) free_cb(list_node(node)); list_free(queue->list); @@ -83,21 +81,19 @@ void fixed_queue_free(fixed_queue_t *queue, fixed_queue_free_cb free_cb) { osi_free(queue); } -void fixed_queue_flush(fixed_queue_t *queue, fixed_queue_free_cb free_cb) { - if (!queue) - return; +void fixed_queue_flush(fixed_queue_t* queue, fixed_queue_free_cb free_cb) { + if (!queue) return; while (!fixed_queue_is_empty(queue)) { - void *data = fixed_queue_try_dequeue(queue); + void* data = fixed_queue_try_dequeue(queue); if (free_cb != NULL) { free_cb(data); } } } -bool fixed_queue_is_empty(fixed_queue_t *queue) { - if (queue == NULL) - return true; +bool fixed_queue_is_empty(fixed_queue_t* queue) { + if (queue == NULL) return true; pthread_mutex_lock(&queue->lock); bool is_empty = list_is_empty(queue->list); @@ -106,9 +102,8 @@ bool fixed_queue_is_empty(fixed_queue_t *queue) { return is_empty; } -size_t fixed_queue_length(fixed_queue_t *queue) { - if (queue == NULL) - return 0; +size_t fixed_queue_length(fixed_queue_t* queue) { + if (queue == NULL) return 0; pthread_mutex_lock(&queue->lock); size_t length = list_length(queue->list); @@ -117,13 +112,13 @@ size_t fixed_queue_length(fixed_queue_t *queue) { return length; } -size_t fixed_queue_capacity(fixed_queue_t *queue) { +size_t fixed_queue_capacity(fixed_queue_t* queue) { assert(queue != NULL); return queue->capacity; } -void fixed_queue_enqueue(fixed_queue_t *queue, void *data) { +void fixed_queue_enqueue(fixed_queue_t* queue, void* data) { assert(queue != NULL); assert(data != NULL); @@ -136,13 +131,13 @@ void fixed_queue_enqueue(fixed_queue_t *queue, void *data) { semaphore_post(queue->dequeue_sem); } -void *fixed_queue_dequeue(fixed_queue_t *queue) { +void* fixed_queue_dequeue(fixed_queue_t* queue) { assert(queue != NULL); semaphore_wait(queue->dequeue_sem); pthread_mutex_lock(&queue->lock); - void *ret = list_front(queue->list); + void* ret = list_front(queue->list); list_remove(queue->list, ret); pthread_mutex_unlock(&queue->lock); @@ -151,12 +146,11 @@ void *fixed_queue_dequeue(fixed_queue_t *queue) { return ret; } -bool fixed_queue_try_enqueue(fixed_queue_t *queue, void *data) { +bool fixed_queue_try_enqueue(fixed_queue_t* queue, void* data) { assert(queue != NULL); assert(data != NULL); - if (!semaphore_try_wait(queue->enqueue_sem)) - return false; + if (!semaphore_try_wait(queue->enqueue_sem)) return false; pthread_mutex_lock(&queue->lock); list_append(queue->list, data); @@ -166,15 +160,13 @@ bool fixed_queue_try_enqueue(fixed_queue_t *queue, void *data) { return true; } -void *fixed_queue_try_dequeue(fixed_queue_t *queue) { - if (queue == NULL) - return NULL; +void* fixed_queue_try_dequeue(fixed_queue_t* queue) { + if (queue == NULL) return NULL; - if (!semaphore_try_wait(queue->dequeue_sem)) - return NULL; + if (!semaphore_try_wait(queue->dequeue_sem)) return NULL; pthread_mutex_lock(&queue->lock); - void *ret = list_front(queue->list); + void* ret = list_front(queue->list); list_remove(queue->list, ret); pthread_mutex_unlock(&queue->lock); @@ -183,31 +175,28 @@ void *fixed_queue_try_dequeue(fixed_queue_t *queue) { return ret; } -void *fixed_queue_try_peek_first(fixed_queue_t *queue) { - if (queue == NULL) - return NULL; +void* fixed_queue_try_peek_first(fixed_queue_t* queue) { + if (queue == NULL) return NULL; pthread_mutex_lock(&queue->lock); - void *ret = list_is_empty(queue->list) ? NULL : list_front(queue->list); + void* ret = list_is_empty(queue->list) ? NULL : list_front(queue->list); pthread_mutex_unlock(&queue->lock); return ret; } -void *fixed_queue_try_peek_last(fixed_queue_t *queue) { - if (queue == NULL) - return NULL; +void* fixed_queue_try_peek_last(fixed_queue_t* queue) { + if (queue == NULL) return NULL; pthread_mutex_lock(&queue->lock); - void *ret = list_is_empty(queue->list) ? NULL : list_back(queue->list); + void* ret = list_is_empty(queue->list) ? NULL : list_back(queue->list); pthread_mutex_unlock(&queue->lock); return ret; } -void *fixed_queue_try_remove_from_queue(fixed_queue_t *queue, void *data) { - if (queue == NULL) - return NULL; +void* fixed_queue_try_remove_from_queue(fixed_queue_t* queue, void* data) { + if (queue == NULL) return NULL; bool removed = false; pthread_mutex_lock(&queue->lock); @@ -225,7 +214,7 @@ void *fixed_queue_try_remove_from_queue(fixed_queue_t *queue, void *data) { return NULL; } -list_t *fixed_queue_get_list(fixed_queue_t *queue) { +list_t* fixed_queue_get_list(fixed_queue_t* queue) { assert(queue != NULL); // NOTE: This function is not thread safe, and there is no point for @@ -233,18 +222,18 @@ list_t *fixed_queue_get_list(fixed_queue_t *queue) { return queue->list; } - -int fixed_queue_get_dequeue_fd(const fixed_queue_t *queue) { +int fixed_queue_get_dequeue_fd(const fixed_queue_t* queue) { assert(queue != NULL); return semaphore_get_fd(queue->dequeue_sem); } -int fixed_queue_get_enqueue_fd(const fixed_queue_t *queue) { +int fixed_queue_get_enqueue_fd(const fixed_queue_t* queue) { assert(queue != NULL); return semaphore_get_fd(queue->enqueue_sem); } -void fixed_queue_register_dequeue(fixed_queue_t *queue, reactor_t *reactor, fixed_queue_cb ready_cb, void *context) { +void fixed_queue_register_dequeue(fixed_queue_t* queue, reactor_t* reactor, + fixed_queue_cb ready_cb, void* context) { assert(queue != NULL); assert(reactor != NULL); assert(ready_cb != NULL); @@ -254,16 +243,12 @@ void fixed_queue_register_dequeue(fixed_queue_t *queue, reactor_t *reactor, fixe queue->dequeue_ready = ready_cb; queue->dequeue_context = context; - queue->dequeue_object = reactor_register( - reactor, - fixed_queue_get_dequeue_fd(queue), - queue, - internal_dequeue_ready, - NULL - ); + queue->dequeue_object = + reactor_register(reactor, fixed_queue_get_dequeue_fd(queue), queue, + internal_dequeue_ready, NULL); } -void fixed_queue_unregister_dequeue(fixed_queue_t *queue) { +void fixed_queue_unregister_dequeue(fixed_queue_t* queue) { assert(queue != NULL); if (queue->dequeue_object) { @@ -272,9 +257,9 @@ void fixed_queue_unregister_dequeue(fixed_queue_t *queue) { } } -static void internal_dequeue_ready(void *context) { +static void internal_dequeue_ready(void* context) { assert(context != NULL); - fixed_queue_t *queue = static_cast(context); + fixed_queue_t* queue = static_cast(context); queue->dequeue_ready(queue, queue->dequeue_context); } diff --git a/osi/src/future.cc b/osi/src/future.cc index 275d254f6..1b2f79b58 100644 --- a/osi/src/future.cc +++ b/osi/src/future.cc @@ -29,18 +29,19 @@ struct future_t { bool ready_can_be_called; - semaphore_t *semaphore; // NULL semaphore means immediate future - void *result; + semaphore_t* semaphore; // NULL semaphore means immediate future + void* result; }; -static void future_free(future_t *future); +static void future_free(future_t* future); -future_t *future_new(void) { - future_t *ret = static_cast(osi_calloc(sizeof(future_t))); +future_t* future_new(void) { + future_t* ret = static_cast(osi_calloc(sizeof(future_t))); ret->semaphore = semaphore_new(0); if (!ret->semaphore) { - LOG_ERROR(LOG_TAG, "%s unable to allocate memory for the semaphore.", __func__); + LOG_ERROR(LOG_TAG, "%s unable to allocate memory for the semaphore.", + __func__); goto error; } @@ -51,15 +52,15 @@ error:; return NULL; } -future_t *future_new_immediate(void *value) { - future_t *ret = static_cast(osi_calloc(sizeof(future_t))); +future_t* future_new_immediate(void* value) { + future_t* ret = static_cast(osi_calloc(sizeof(future_t))); ret->result = value; ret->ready_can_be_called = false; return ret; } -void future_ready(future_t *future, void *value) { +void future_ready(future_t* future, void* value) { assert(future != NULL); assert(future->ready_can_be_called); @@ -68,21 +69,19 @@ void future_ready(future_t *future, void *value) { semaphore_post(future->semaphore); } -void *future_await(future_t *future) { +void* future_await(future_t* future) { assert(future != NULL); // If the future is immediate, it will not have a semaphore - if (future->semaphore) - semaphore_wait(future->semaphore); + if (future->semaphore) semaphore_wait(future->semaphore); - void *result = future->result; + void* result = future->result; future_free(future); return result; } -static void future_free(future_t *future) { - if (!future) - return; +static void future_free(future_t* future) { + if (!future) return; semaphore_free(future->semaphore); osi_free(future); diff --git a/osi/src/hash_map_utils.cc b/osi/src/hash_map_utils.cc index f8a8dc9a6..3dfdc6e80 100644 --- a/osi/src/hash_map_utils.cc +++ b/osi/src/hash_map_utils.cc @@ -27,27 +27,27 @@ #include "osi/include/osi.h" std::unordered_map -hash_map_utils_new_from_string_params(const char *params) { +hash_map_utils_new_from_string_params(const char* params) { assert(params != NULL); std::unordered_map map; - char *str = osi_strdup(params); + char* str = osi_strdup(params); if (!str) return map; LOG_VERBOSE(LOG_TAG, "%s: source string: '%s'", __func__, str); // Parse |str| and add extracted key-and-value pair(s) in |map|. int items = 0; - char *tmpstr; - char *kvpair = strtok_r(str, ";", &tmpstr); + char* tmpstr; + char* kvpair = strtok_r(str, ";", &tmpstr); while (kvpair && *kvpair) { - char *eq = strchr(kvpair, '='); + char* eq = strchr(kvpair, '='); if (eq == kvpair) goto next_pair; - char *key; - char *value; + char* key; + char* value; if (eq) { key = osi_strndup(kvpair, eq - kvpair); @@ -76,8 +76,8 @@ hash_map_utils_new_from_string_params(const char *params) { } void hash_map_utils_dump_string_keys_string_values( - std::unordered_map &map) { - for (const auto &ptr : map) { + std::unordered_map& map) { + for (const auto& ptr : map) { LOG_INFO(LOG_TAG, "key: '%s' value: '%s'\n", ptr.first.c_str(), ptr.second.c_str()); } diff --git a/osi/src/list.cc b/osi/src/list.cc index 94685794f..e13c31e0b 100644 --- a/osi/src/list.cc +++ b/osi/src/list.cc @@ -5,128 +5,123 @@ #include "osi/include/osi.h" struct list_node_t { - struct list_node_t *next; - void *data; + struct list_node_t* next; + void* data; }; typedef struct list_t { - list_node_t *head; - list_node_t *tail; + list_node_t* head; + list_node_t* tail; size_t length; list_free_cb free_cb; - const allocator_t *allocator; + const allocator_t* allocator; } list_t; -static list_node_t *list_free_node_(list_t *list, list_node_t *node); +static list_node_t* list_free_node_(list_t* list, list_node_t* node); -// Hidden constructor, only to be used by the hash map for the allocation tracker. +// Hidden constructor, only to be used by the hash map for the allocation +// tracker. // Behaves the same as |list_new|, except you get to specify the allocator. -list_t *list_new_internal(list_free_cb callback, const allocator_t *zeroed_allocator) { - list_t *list = (list_t *)zeroed_allocator->alloc(sizeof(list_t)); - if (!list) - return NULL; +list_t* list_new_internal(list_free_cb callback, + const allocator_t* zeroed_allocator) { + list_t* list = (list_t*)zeroed_allocator->alloc(sizeof(list_t)); + if (!list) return NULL; list->free_cb = callback; list->allocator = zeroed_allocator; return list; } -list_t *list_new(list_free_cb callback) { +list_t* list_new(list_free_cb callback) { return list_new_internal(callback, &allocator_calloc); } -void list_free(list_t *list) { - if (!list) - return; +void list_free(list_t* list) { + if (!list) return; list_clear(list); list->allocator->free(list); } -bool list_is_empty(const list_t *list) { +bool list_is_empty(const list_t* list) { assert(list != NULL); return (list->length == 0); } -bool list_contains(const list_t *list, const void *data) { +bool list_contains(const list_t* list, const void* data) { assert(list != NULL); assert(data != NULL); - for (const list_node_t *node = list_begin(list); node != list_end(list); node = list_next(node)) { - if (list_node(node) == data) - return true; + for (const list_node_t* node = list_begin(list); node != list_end(list); + node = list_next(node)) { + if (list_node(node) == data) return true; } return false; } -size_t list_length(const list_t *list) { +size_t list_length(const list_t* list) { assert(list != NULL); return list->length; } -void *list_front(const list_t *list) { +void* list_front(const list_t* list) { assert(list != NULL); assert(!list_is_empty(list)); return list->head->data; } -void *list_back(const list_t *list) { +void* list_back(const list_t* list) { assert(list != NULL); assert(!list_is_empty(list)); return list->tail->data; } -list_node_t *list_back_node(const list_t *list) { +list_node_t* list_back_node(const list_t* list) { assert(list != NULL); assert(!list_is_empty(list)); return list->tail; } -bool list_insert_after(list_t *list, list_node_t *prev_node, void *data) { +bool list_insert_after(list_t* list, list_node_t* prev_node, void* data) { assert(list != NULL); assert(prev_node != NULL); assert(data != NULL); - list_node_t *node = (list_node_t *)list->allocator->alloc(sizeof(list_node_t)); - if (!node) - return false; + list_node_t* node = (list_node_t*)list->allocator->alloc(sizeof(list_node_t)); + if (!node) return false; node->next = prev_node->next; node->data = data; prev_node->next = node; - if (list->tail == prev_node) - list->tail = node; + if (list->tail == prev_node) list->tail = node; ++list->length; return true; } -bool list_prepend(list_t *list, void *data) { +bool list_prepend(list_t* list, void* data) { assert(list != NULL); assert(data != NULL); - list_node_t *node = (list_node_t *)list->allocator->alloc(sizeof(list_node_t)); - if (!node) - return false; + list_node_t* node = (list_node_t*)list->allocator->alloc(sizeof(list_node_t)); + if (!node) return false; node->next = list->head; node->data = data; list->head = node; - if (list->tail == NULL) - list->tail = list->head; + if (list->tail == NULL) list->tail = list->head; ++list->length; return true; } -bool list_append(list_t *list, void *data) { +bool list_append(list_t* list, void* data) { assert(list != NULL); assert(data != NULL); - list_node_t *node = (list_node_t *)list->allocator->alloc(sizeof(list_node_t)); - if (!node) - return false; + list_node_t* node = (list_node_t*)list->allocator->alloc(sizeof(list_node_t)); + if (!node) return false; node->next = NULL; node->data = data; if (list->tail == NULL) { @@ -140,82 +135,79 @@ bool list_append(list_t *list, void *data) { return true; } -bool list_remove(list_t *list, void *data) { +bool list_remove(list_t* list, void* data) { assert(list != NULL); assert(data != NULL); - if (list_is_empty(list)) - return false; + if (list_is_empty(list)) return false; if (list->head->data == data) { - list_node_t *next = list_free_node_(list, list->head); - if (list->tail == list->head) - list->tail = next; + list_node_t* next = list_free_node_(list, list->head); + if (list->tail == list->head) list->tail = next; list->head = next; return true; } - for (list_node_t *prev = list->head, *node = list->head->next; node; prev = node, node = node->next) + for (list_node_t *prev = list->head, *node = list->head->next; node; + prev = node, node = node->next) if (node->data == data) { prev->next = list_free_node_(list, node); - if (list->tail == node) - list->tail = prev; + if (list->tail == node) list->tail = prev; return true; } return false; } -void list_clear(list_t *list) { +void list_clear(list_t* list) { assert(list != NULL); - for (list_node_t *node = list->head; node; ) + for (list_node_t* node = list->head; node;) node = list_free_node_(list, node); list->head = NULL; list->tail = NULL; list->length = 0; } -list_node_t *list_foreach(const list_t *list, list_iter_cb callback, void *context) { +list_node_t* list_foreach(const list_t* list, list_iter_cb callback, + void* context) { assert(list != NULL); assert(callback != NULL); - for (list_node_t *node = list->head; node; ) { - list_node_t *next = node->next; - if (!callback(node->data, context)) - return node; + for (list_node_t* node = list->head; node;) { + list_node_t* next = node->next; + if (!callback(node->data, context)) return node; node = next; } return NULL; } -list_node_t *list_begin(const list_t *list) { +list_node_t* list_begin(const list_t* list) { assert(list != NULL); return list->head; } -list_node_t *list_end(UNUSED_ATTR const list_t *list) { +list_node_t* list_end(UNUSED_ATTR const list_t* list) { assert(list != NULL); return NULL; } -list_node_t *list_next(const list_node_t *node) { +list_node_t* list_next(const list_node_t* node) { assert(node != NULL); return node->next; } -void *list_node(const list_node_t *node) { +void* list_node(const list_node_t* node) { assert(node != NULL); return node->data; } -static list_node_t *list_free_node_(list_t *list, list_node_t *node) { +static list_node_t* list_free_node_(list_t* list, list_node_t* node) { assert(list != NULL); assert(node != NULL); - list_node_t *next = node->next; + list_node_t* next = node->next; - if (list->free_cb) - list->free_cb(node->data); + if (list->free_cb) list->free_cb(node->data); list->allocator->free(node); --list->length; diff --git a/osi/src/metrics.cc b/osi/src/metrics.cc index f90ea51c7..c161869d3 100644 --- a/osi/src/metrics.cc +++ b/osi/src/metrics.cc @@ -16,7 +16,6 @@ * ******************************************************************************/ - #define LOG_TAG "bt_osi_metrics" #include "osi/include/metrics.h" @@ -44,7 +43,7 @@ using clearcut::connectivity::ScanEvent_ScanEventType; using clearcut::connectivity::WakeEvent; using clearcut::connectivity::WakeEvent_WakeEventType; -BluetoothLog *pending; +BluetoothLog* pending; std::mutex log_lock; static void lazy_initialize(void) { @@ -58,20 +57,17 @@ void metrics_pair_event(uint32_t disconnect_reason, uint64_t timestamp_ms, std::lock_guard lock(log_lock); lazy_initialize(); - PairEvent *event = pending->add_pair_event(); + PairEvent* event = pending->add_pair_event(); - DeviceInfo *info = event->mutable_device_paired_with(); + DeviceInfo* info = event->mutable_device_paired_with(); info->set_device_class(device_class); DeviceInfo_DeviceType type = DeviceInfo::DEVICE_TYPE_UNKNOWN; - if (device_type == DEVICE_TYPE_BREDR) - type = DeviceInfo::DEVICE_TYPE_BREDR; - if (device_type == DEVICE_TYPE_LE) - type = DeviceInfo::DEVICE_TYPE_LE; - if (device_type == DEVICE_TYPE_DUMO) - type = DeviceInfo::DEVICE_TYPE_DUMO; + if (device_type == DEVICE_TYPE_BREDR) type = DeviceInfo::DEVICE_TYPE_BREDR; + if (device_type == DEVICE_TYPE_LE) type = DeviceInfo::DEVICE_TYPE_LE; + if (device_type == DEVICE_TYPE_DUMO) type = DeviceInfo::DEVICE_TYPE_DUMO; info->set_device_type(type); @@ -80,54 +76,46 @@ void metrics_pair_event(uint32_t disconnect_reason, uint64_t timestamp_ms, event->set_event_time_millis(timestamp_ms); } -void metrics_wake_event(wake_event_type_t type, const char *requestor, - const char *name, uint64_t timestamp_ms) { +void metrics_wake_event(wake_event_type_t type, const char* requestor, + const char* name, uint64_t timestamp_ms) { std::lock_guard lock(log_lock); lazy_initialize(); - WakeEvent *event = pending->add_wake_event(); + WakeEvent* event = pending->add_wake_event(); WakeEvent_WakeEventType waketype = WakeEvent::UNKNOWN; - if (type == WAKE_EVENT_ACQUIRED) - waketype = WakeEvent::ACQUIRED; - if (type == WAKE_EVENT_RELEASED) - waketype = WakeEvent::RELEASED; + if (type == WAKE_EVENT_ACQUIRED) waketype = WakeEvent::ACQUIRED; + if (type == WAKE_EVENT_RELEASED) waketype = WakeEvent::RELEASED; event->set_wake_event_type(waketype); - if (requestor) - event->set_requestor(requestor); + if (requestor) event->set_requestor(requestor); - if (name) - event->set_name(name); + if (name) event->set_name(name); event->set_event_time_millis(timestamp_ms); } -void metrics_scan_event(bool start, const char *initator, scan_tech_t type, +void metrics_scan_event(bool start, const char* initator, scan_tech_t type, uint32_t results, uint64_t timestamp_ms) { std::lock_guard lock(log_lock); lazy_initialize(); - ScanEvent *event = pending->add_scan_event(); + ScanEvent* event = pending->add_scan_event(); if (start) event->set_scan_event_type(ScanEvent::SCAN_EVENT_START); else event->set_scan_event_type(ScanEvent::SCAN_EVENT_STOP); - if (initator) - event->set_initiator(initator); + if (initator) event->set_initiator(initator); ScanEvent::ScanTechnologyType scantype = ScanEvent::SCAN_TYPE_UNKNOWN; - if (type == SCAN_TECH_TYPE_LE) - scantype = ScanEvent::SCAN_TECH_TYPE_LE; - if (type == SCAN_TECH_TYPE_BREDR) - scantype = ScanEvent::SCAN_TECH_TYPE_BREDR; - if (type == SCAN_TECH_TYPE_BOTH) - scantype = ScanEvent::SCAN_TECH_TYPE_BOTH; + if (type == SCAN_TECH_TYPE_LE) scantype = ScanEvent::SCAN_TECH_TYPE_LE; + if (type == SCAN_TECH_TYPE_BREDR) scantype = ScanEvent::SCAN_TECH_TYPE_BREDR; + if (type == SCAN_TECH_TYPE_BOTH) scantype = ScanEvent::SCAN_TECH_TYPE_BOTH; event->set_scan_technology_type(scantype); @@ -136,24 +124,20 @@ void metrics_scan_event(bool start, const char *initator, scan_tech_t type, event->set_event_time_millis(timestamp_ms); } -void metrics_a2dp_session(int64_t session_duration_sec, - const char *disconnect_reason, - uint32_t device_class, - int32_t media_timer_min_ms, - int32_t media_timer_max_ms, - int32_t media_timer_avg_ms, - int32_t buffer_overruns_max_count, - int32_t buffer_overruns_total, - float buffer_underruns_average, - int32_t buffer_underruns_count) { +void metrics_a2dp_session( + int64_t session_duration_sec, const char* disconnect_reason, + uint32_t device_class, int32_t media_timer_min_ms, + int32_t media_timer_max_ms, int32_t media_timer_avg_ms, + int32_t buffer_overruns_max_count, int32_t buffer_overruns_total, + float buffer_underruns_average, int32_t buffer_underruns_count) { std::lock_guard lock(log_lock); lazy_initialize(); - BluetoothSession *bt_session = pending->add_session(); + BluetoothSession* bt_session = pending->add_session(); // Set connection type: for A2DP it is always BR/EDR BluetoothSession::ConnectionTechnologyType conn_type = - BluetoothSession::CONNECTION_TECHNOLOGY_TYPE_BREDR; + BluetoothSession::CONNECTION_TECHNOLOGY_TYPE_BREDR; bt_session->set_connection_technology_type(conn_type); bt_session->set_session_duration_sec(session_duration_sec); @@ -161,11 +145,11 @@ void metrics_a2dp_session(int64_t session_duration_sec, bt_session->set_disconnect_reason(disconnect_reason); // Set device: class and type are pre-defined - DeviceInfo *info = bt_session->mutable_device_connected_to(); + DeviceInfo* info = bt_session->mutable_device_connected_to(); info->set_device_class(device_class); info->set_device_type(DeviceInfo::DEVICE_TYPE_BREDR); - A2DPSession *a2dp_session = bt_session->mutable_a2dp_session(); + A2DPSession* a2dp_session = bt_session->mutable_a2dp_session(); a2dp_session->set_media_timer_min_millis(media_timer_min_ms); a2dp_session->set_media_timer_max_millis(media_timer_max_ms); a2dp_session->set_media_timer_avg_millis(media_timer_avg_ms); diff --git a/osi/src/metrics_linux.cc b/osi/src/metrics_linux.cc index 663ce92e9..64bf175b7 100644 --- a/osi/src/metrics_linux.cc +++ b/osi/src/metrics_linux.cc @@ -16,43 +16,38 @@ * ******************************************************************************/ - #define LOG_TAG "bt_osi_metrics" #include "osi/include/metrics.h" void metrics_pair_event(uint32_t disconnect_reason, uint64_t timestamp_ms, uint32_t device_class, device_type_t device_type) { - //TODO(jpawlowski): implement + // TODO(jpawlowski): implement } -void metrics_wake_event(wake_event_type_t type, const char *requestor, - const char *name, uint64_t timestamp_ms) { - //TODO(jpawlowski): implement +void metrics_wake_event(wake_event_type_t type, const char* requestor, + const char* name, uint64_t timestamp_ms) { + // TODO(jpawlowski): implement } -void metrics_scan_event(bool start, const char *initator, scan_tech_t type, +void metrics_scan_event(bool start, const char* initator, scan_tech_t type, uint32_t results, uint64_t timestamp_ms) { - //TODO(jpawlowski): implement + // TODO(jpawlowski): implement } -void metrics_a2dp_session(int64_t session_duration_sec, - const char *disconnect_reason, - uint32_t device_class, - int32_t media_timer_min_ms, - int32_t media_timer_max_ms, - int32_t media_timer_avg_ms, - int32_t buffer_overruns_max_count, - int32_t buffer_overruns_total, - float buffer_underruns_average, - int32_t buffer_underruns_count) { - //TODO(jpawlowski): implement +void metrics_a2dp_session( + int64_t session_duration_sec, const char* disconnect_reason, + uint32_t device_class, int32_t media_timer_min_ms, + int32_t media_timer_max_ms, int32_t media_timer_avg_ms, + int32_t buffer_overruns_max_count, int32_t buffer_overruns_total, + float buffer_underruns_average, int32_t buffer_underruns_count) { + // TODO(jpawlowski): implement } void metrics_write(int fd, bool clear) { - //TODO(jpawlowski): implement + // TODO(jpawlowski): implement } void metrics_print(int fd, bool clear) { - //TODO(jpawlowski): implement + // TODO(jpawlowski): implement } diff --git a/osi/src/mutex.cc b/osi/src/mutex.cc index b70e4ebdf..4cbb45fbb 100644 --- a/osi/src/mutex.cc +++ b/osi/src/mutex.cc @@ -31,14 +31,8 @@ void mutex_init(void) { pthread_mutex_init(&global_lock, &attr); } -void mutex_cleanup(void) { - pthread_mutex_destroy(&global_lock); -} +void mutex_cleanup(void) { pthread_mutex_destroy(&global_lock); } -void mutex_global_lock(void) { - pthread_mutex_lock(&global_lock); -} +void mutex_global_lock(void) { pthread_mutex_lock(&global_lock); } -void mutex_global_unlock(void) { - pthread_mutex_unlock(&global_lock); -} +void mutex_global_unlock(void) { pthread_mutex_unlock(&global_lock); } diff --git a/osi/src/osi.cc b/osi/src/osi.cc index b3f9c7fa3..f06ca602b 100644 --- a/osi/src/osi.cc +++ b/osi/src/osi.cc @@ -23,8 +23,8 @@ #include #include #include -#include #include +#include #include #include "osi/include/log.h" @@ -47,8 +47,7 @@ int osi_rand(void) { assert(read_bytes == sizeof(rand)); - if (rand < 0) - rand = -rand; + if (rand < 0) rand = -rand; return rand; } diff --git a/osi/src/properties.cc b/osi/src/properties.cc index 10e15996b..a484fd19b 100644 --- a/osi/src/properties.cc +++ b/osi/src/properties.cc @@ -20,29 +20,27 @@ #include "osi/include/properties.h" -int osi_property_get(const char *key, char *value, const char *default_value) { +int osi_property_get(const char* key, char* value, const char* default_value) { #if defined(OS_GENERIC) - /* For linux right now just return default value, if present */ - int len = -1; - if (!default_value) - return len; + /* For linux right now just return default value, if present */ + int len = -1; + if (!default_value) return len; - len = strlen(default_value); - if (len >= PROPERTY_VALUE_MAX) - len = PROPERTY_VALUE_MAX - 1; + len = strlen(default_value); + if (len >= PROPERTY_VALUE_MAX) len = PROPERTY_VALUE_MAX - 1; - memcpy(value, default_value, len); - value[len] = '\0'; - return len; + memcpy(value, default_value, len); + value[len] = '\0'; + return len; #else - return property_get(key, value, default_value); + return property_get(key, value, default_value); #endif // defined(OS_GENERIC) } -int osi_property_set(const char *key, const char *value) { +int osi_property_set(const char* key, const char* value) { #if defined(OS_GENERIC) - return -1; + return -1; #else - return property_set(key, value); + return property_set(key, value); #endif // defined(OS_GENERIC) } diff --git a/osi/src/protos/bluetooth.proto b/osi/src/protos/bluetooth.proto index 9a233ad26..95266d8c0 100644 --- a/osi/src/protos/bluetooth.proto +++ b/osi/src/protos/bluetooth.proto @@ -7,12 +7,11 @@ syntax = "proto2"; package clearcut.connectivity; option java_package = "com.google.wireless.android.play.playlog.connectivity"; -//option (datapol.file_vetting_status) = "latest"; +// option (datapol.file_vetting_status) = "latest"; // import "storage/datapol/annotations/proto/semantic_annotations.proto"; message BluetoothLog { - // Session information that gets logged for every BT connection. repeated BluetoothSession session = 1; @@ -28,18 +27,16 @@ message BluetoothLog { // The information about the device. message DeviceInfo { - // Device type. enum DeviceType { + // Type is unknown. + DEVICE_TYPE_UNKNOWN = 0; - // Type is unknown. - DEVICE_TYPE_UNKNOWN = 0; + DEVICE_TYPE_BREDR = 1; - DEVICE_TYPE_BREDR = 1; + DEVICE_TYPE_LE = 2; - DEVICE_TYPE_LE = 2; - - DEVICE_TYPE_DUMO = 3; + DEVICE_TYPE_DUMO = 3; } // Device class @@ -52,15 +49,13 @@ message DeviceInfo { // Information that gets logged for every Bluetooth connection. message BluetoothSession { - // Type of technology used in the connection. enum ConnectionTechnologyType { + CONNECTION_TECHNOLOGY_TYPE_UNKNOWN = 0; - CONNECTION_TECHNOLOGY_TYPE_UNKNOWN = 0; + CONNECTION_TECHNOLOGY_TYPE_LE = 1; - CONNECTION_TECHNOLOGY_TYPE_LE = 1; - - CONNECTION_TECHNOLOGY_TYPE_BREDR = 2; + CONNECTION_TECHNOLOGY_TYPE_BREDR = 2; } // Duration of the session. @@ -83,7 +78,6 @@ message BluetoothSession { } message RFCommSession { - // bytes transmitted. optional int32 rx_bytes = 1; @@ -93,7 +87,6 @@ message RFCommSession { // Session information that gets logged for every A2DP session. message A2DPSession { - // Media timer in milliseconds. optional int32 media_timer_min_millis = 1; @@ -117,31 +110,29 @@ message A2DPSession { } message PairEvent { - // The reason for disconnecting // https://cs.corp.google.com/#android/system/bt/stack/include/hcidefs.h&q=failed_establish. optional int32 disconnect_reason = 1; // Pair event time - optional int64 event_time_millis = 2; // [(datapol.semantic_type) = ST_TIMESTAMP]; + optional int64 event_time_millis = + 2; // [(datapol.semantic_type) = ST_TIMESTAMP]; // The information about the device which it is paired to. optional DeviceInfo device_paired_with = 3; } message WakeEvent { - // Information about the wake event type. enum WakeEventType { + // Type is unknown. + UNKNOWN = 0; - // Type is unknown. - UNKNOWN = 0; - - // WakeLock was acquired. - ACQUIRED = 1; + // WakeLock was acquired. + ACQUIRED = 1; - // WakeLock was released. - RELEASED = 2; + // WakeLock was released. + RELEASED = 2; } // Information about the wake event type. @@ -155,32 +146,30 @@ message WakeEvent { optional string name = 3; // Time of the event. - optional int64 event_time_millis = 4; // [(datapol.semantic_type) = ST_TIMESTAMP]; + optional int64 event_time_millis = + 4; // [(datapol.semantic_type) = ST_TIMESTAMP]; } message ScanEvent { - // Scan type. enum ScanTechnologyType { + // Scan Type is unknown. + SCAN_TYPE_UNKNOWN = 0; - // Scan Type is unknown. - SCAN_TYPE_UNKNOWN = 0; - - SCAN_TECH_TYPE_LE = 1; + SCAN_TECH_TYPE_LE = 1; - SCAN_TECH_TYPE_BREDR = 2; + SCAN_TECH_TYPE_BREDR = 2; - SCAN_TECH_TYPE_BOTH = 3; + SCAN_TECH_TYPE_BOTH = 3; } // Scan event type. enum ScanEventType { + // Scan started. + SCAN_EVENT_START = 0; - // Scan started. - SCAN_EVENT_START = 0; - - // Scan stopped. - SCAN_EVENT_STOP = 1; + // Scan stopped. + SCAN_EVENT_STOP = 1; } // Scan event type. @@ -197,5 +186,6 @@ message ScanEvent { optional int32 number_results = 4; // Time of the event. - optional int64 event_time_millis = 5; // [(datapol.semantic_type) = ST_TIMESTAMP]; + optional int64 event_time_millis = + 5; // [(datapol.semantic_type) = ST_TIMESTAMP]; } diff --git a/osi/src/reactor.cc b/osi/src/reactor.cc index 7388d52d7..b77809a46 100644 --- a/osi/src/reactor.cc +++ b/osi/src/reactor.cc @@ -34,56 +34,62 @@ #include "osi/include/log.h" #if !defined(EFD_SEMAPHORE) -# define EFD_SEMAPHORE (1 << 0) +#define EFD_SEMAPHORE (1 << 0) #endif struct reactor_t { int epoll_fd; int event_fd; pthread_mutex_t list_lock; // protects invalidation_list. - list_t *invalidation_list; // reactor objects that have been unregistered. + list_t* invalidation_list; // reactor objects that have been unregistered. pthread_t run_thread; // the pthread on which reactor_run is executing. bool is_running; // indicates whether |run_thread| is valid. bool object_removed; }; struct reactor_object_t { - int fd; // the file descriptor to monitor for events. - void *context; // a context that's passed back to the *_ready functions. - reactor_t *reactor; // the reactor instance this object is registered with. - pthread_mutex_t lock; // protects the lifetime of this object and all variables. - - void (*read_ready)(void *context); // function to call when the file descriptor becomes readable. - void (*write_ready)(void *context); // function to call when the file descriptor becomes writeable. + int fd; // the file descriptor to monitor for events. + void* context; // a context that's passed back to the *_ready functions. + reactor_t* reactor; // the reactor instance this object is registered with. + pthread_mutex_t + lock; // protects the lifetime of this object and all variables. + + void (*read_ready)(void* context); // function to call when the file + // descriptor becomes readable. + void (*write_ready)(void* context); // function to call when the file + // descriptor becomes writeable. }; -static reactor_status_t run_reactor(reactor_t *reactor, int iterations); +static reactor_status_t run_reactor(reactor_t* reactor, int iterations); static const size_t MAX_EVENTS = 64; static const eventfd_t EVENT_REACTOR_STOP = 1; -reactor_t *reactor_new(void) { - reactor_t *ret = (reactor_t *)osi_calloc(sizeof(reactor_t)); +reactor_t* reactor_new(void) { + reactor_t* ret = (reactor_t*)osi_calloc(sizeof(reactor_t)); ret->epoll_fd = INVALID_FD; ret->event_fd = INVALID_FD; ret->epoll_fd = epoll_create(MAX_EVENTS); if (ret->epoll_fd == INVALID_FD) { - LOG_ERROR(LOG_TAG, "%s unable to create epoll instance: %s", __func__, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to create epoll instance: %s", __func__, + strerror(errno)); goto error; } ret->event_fd = eventfd(0, 0); if (ret->event_fd == INVALID_FD) { - LOG_ERROR(LOG_TAG, "%s unable to create eventfd: %s", __func__, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to create eventfd: %s", __func__, + strerror(errno)); goto error; } pthread_mutex_init(&ret->list_lock, NULL); ret->invalidation_list = list_new(NULL); if (!ret->invalidation_list) { - LOG_ERROR(LOG_TAG, "%s unable to allocate object invalidation list.", __func__); + LOG_ERROR(LOG_TAG, "%s unable to allocate object invalidation list.", + __func__); goto error; } @@ -92,7 +98,8 @@ reactor_t *reactor_new(void) { event.events = EPOLLIN; event.data.ptr = NULL; if (epoll_ctl(ret->epoll_fd, EPOLL_CTL_ADD, ret->event_fd, &event) == -1) { - LOG_ERROR(LOG_TAG, "%s unable to register eventfd with epoll set: %s", __func__, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to register eventfd with epoll set: %s", + __func__, strerror(errno)); goto error; } @@ -103,9 +110,8 @@ error:; return NULL; } -void reactor_free(reactor_t *reactor) { - if (!reactor) - return; +void reactor_free(reactor_t* reactor) { + if (!reactor) return; list_free(reactor->invalidation_list); close(reactor->event_fd); @@ -113,31 +119,30 @@ void reactor_free(reactor_t *reactor) { osi_free(reactor); } -reactor_status_t reactor_start(reactor_t *reactor) { +reactor_status_t reactor_start(reactor_t* reactor) { assert(reactor != NULL); return run_reactor(reactor, 0); } -reactor_status_t reactor_run_once(reactor_t *reactor) { +reactor_status_t reactor_run_once(reactor_t* reactor) { assert(reactor != NULL); return run_reactor(reactor, 1); } -void reactor_stop(reactor_t *reactor) { +void reactor_stop(reactor_t* reactor) { assert(reactor != NULL); eventfd_write(reactor->event_fd, EVENT_REACTOR_STOP); } -reactor_object_t *reactor_register(reactor_t *reactor, - int fd, void *context, - void (*read_ready)(void *context), - void (*write_ready)(void *context)) { +reactor_object_t* reactor_register(reactor_t* reactor, int fd, void* context, + void (*read_ready)(void* context), + void (*write_ready)(void* context)) { assert(reactor != NULL); assert(fd != INVALID_FD); - reactor_object_t *object = - (reactor_object_t *)osi_calloc(sizeof(reactor_object_t)); + reactor_object_t* object = + (reactor_object_t*)osi_calloc(sizeof(reactor_object_t)); object->reactor = reactor; object->fd = fd; @@ -148,14 +153,13 @@ reactor_object_t *reactor_register(reactor_t *reactor, struct epoll_event event; memset(&event, 0, sizeof(event)); - if (read_ready) - event.events |= (EPOLLIN | EPOLLRDHUP); - if (write_ready) - event.events |= EPOLLOUT; + if (read_ready) event.events |= (EPOLLIN | EPOLLRDHUP); + if (write_ready) event.events |= EPOLLOUT; event.data.ptr = object; if (epoll_ctl(reactor->epoll_fd, EPOLL_CTL_ADD, fd, &event) == -1) { - LOG_ERROR(LOG_TAG, "%s unable to register fd %d to epoll set: %s", __func__, fd, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to register fd %d to epoll set: %s", __func__, + fd, strerror(errno)); pthread_mutex_destroy(&object->lock); osi_free(object); return NULL; @@ -164,21 +168,21 @@ reactor_object_t *reactor_register(reactor_t *reactor, return object; } -bool reactor_change_registration(reactor_object_t *object, - void (*read_ready)(void *context), - void (*write_ready)(void *context)) { +bool reactor_change_registration(reactor_object_t* object, + void (*read_ready)(void* context), + void (*write_ready)(void* context)) { assert(object != NULL); struct epoll_event event; memset(&event, 0, sizeof(event)); - if (read_ready) - event.events |= (EPOLLIN | EPOLLRDHUP); - if (write_ready) - event.events |= EPOLLOUT; + if (read_ready) event.events |= (EPOLLIN | EPOLLRDHUP); + if (write_ready) event.events |= EPOLLOUT; event.data.ptr = object; - if (epoll_ctl(object->reactor->epoll_fd, EPOLL_CTL_MOD, object->fd, &event) == -1) { - LOG_ERROR(LOG_TAG, "%s unable to modify interest set for fd %d: %s", __func__, object->fd, strerror(errno)); + if (epoll_ctl(object->reactor->epoll_fd, EPOLL_CTL_MOD, object->fd, &event) == + -1) { + LOG_ERROR(LOG_TAG, "%s unable to modify interest set for fd %d: %s", + __func__, object->fd, strerror(errno)); return false; } @@ -190,15 +194,17 @@ bool reactor_change_registration(reactor_object_t *object, return true; } -void reactor_unregister(reactor_object_t *obj) { +void reactor_unregister(reactor_object_t* obj) { assert(obj != NULL); - reactor_t *reactor = obj->reactor; + reactor_t* reactor = obj->reactor; if (epoll_ctl(reactor->epoll_fd, EPOLL_CTL_DEL, obj->fd, NULL) == -1) - LOG_ERROR(LOG_TAG, "%s unable to unregister fd %d from epoll set: %s", __func__, obj->fd, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to unregister fd %d from epoll set: %s", + __func__, obj->fd, strerror(errno)); - if (reactor->is_running && pthread_equal(pthread_self(), reactor->run_thread)) { + if (reactor->is_running && + pthread_equal(pthread_self(), reactor->run_thread)) { reactor->object_removed = true; return; } @@ -224,7 +230,7 @@ void reactor_unregister(reactor_object_t *obj) { // Runs the reactor loop for a maximum of |iterations|. // 0 |iterations| means loop forever. // |reactor| may not be NULL. -static reactor_status_t run_reactor(reactor_t *reactor, int iterations) { +static reactor_status_t run_reactor(reactor_t* reactor, int iterations) { assert(reactor != NULL); reactor->run_thread = pthread_self(); @@ -239,7 +245,8 @@ static reactor_status_t run_reactor(reactor_t *reactor, int iterations) { int ret; OSI_NO_INTR(ret = epoll_wait(reactor->epoll_fd, events, MAX_EVENTS, -1)); if (ret == -1) { - LOG_ERROR(LOG_TAG, "%s error in epoll_wait: %s", __func__, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s error in epoll_wait: %s", __func__, + strerror(errno)); reactor->is_running = false; return REACTOR_STATUS_ERROR; } @@ -255,7 +262,7 @@ static reactor_status_t run_reactor(reactor_t *reactor, int iterations) { return REACTOR_STATUS_STOP; } - reactor_object_t *object = (reactor_object_t *)events[j].data.ptr; + reactor_object_t* object = (reactor_object_t*)events[j].data.ptr; pthread_mutex_lock(&reactor->list_lock); if (list_contains(reactor->invalidation_list, object)) { @@ -268,9 +275,11 @@ static reactor_status_t run_reactor(reactor_t *reactor, int iterations) { pthread_mutex_unlock(&reactor->list_lock); reactor->object_removed = false; - if (events[j].events & (EPOLLIN | EPOLLHUP | EPOLLRDHUP | EPOLLERR) && object->read_ready) + if (events[j].events & (EPOLLIN | EPOLLHUP | EPOLLRDHUP | EPOLLERR) && + object->read_ready) object->read_ready(object->context); - if (!reactor->object_removed && events[j].events & EPOLLOUT && object->write_ready) + if (!reactor->object_removed && events[j].events & EPOLLOUT && + object->write_ready) object->write_ready(object->context); pthread_mutex_unlock(&object->lock); diff --git a/osi/src/ringbuffer.cc b/osi/src/ringbuffer.cc index 67c8f544d..3ab602300 100644 --- a/osi/src/ringbuffer.cc +++ b/osi/src/ringbuffer.cc @@ -25,94 +25,91 @@ struct ringbuffer_t { size_t total; size_t available; - uint8_t *base; - uint8_t *head; - uint8_t *tail; + uint8_t* base; + uint8_t* head; + uint8_t* tail; }; ringbuffer_t* ringbuffer_init(const size_t size) { - ringbuffer_t* p = static_cast(osi_calloc(sizeof(ringbuffer_t))); + ringbuffer_t* p = + static_cast(osi_calloc(sizeof(ringbuffer_t))); - p->base = static_cast(osi_calloc(size)); + p->base = static_cast(osi_calloc(size)); p->head = p->tail = p->base; p->total = p->available = size; return p; } -void ringbuffer_free(ringbuffer_t *rb) { - if (rb != NULL) - osi_free(rb->base); +void ringbuffer_free(ringbuffer_t* rb) { + if (rb != NULL) osi_free(rb->base); osi_free(rb); } -size_t ringbuffer_available(const ringbuffer_t *rb) { +size_t ringbuffer_available(const ringbuffer_t* rb) { assert(rb); return rb->available; } -size_t ringbuffer_size(const ringbuffer_t *rb) { +size_t ringbuffer_size(const ringbuffer_t* rb) { assert(rb); return rb->total - rb->available; } -size_t ringbuffer_insert(ringbuffer_t *rb, const uint8_t *p, size_t length) { +size_t ringbuffer_insert(ringbuffer_t* rb, const uint8_t* p, size_t length) { assert(rb); assert(p); - if (length > ringbuffer_available(rb)) - length = ringbuffer_available(rb); + if (length > ringbuffer_available(rb)) length = ringbuffer_available(rb); for (size_t i = 0; i != length; ++i) { *rb->tail++ = *p++; - if (rb->tail >= (rb->base + rb->total)) - rb->tail = rb->base; + if (rb->tail >= (rb->base + rb->total)) rb->tail = rb->base; } rb->available -= length; return length; } -size_t ringbuffer_delete(ringbuffer_t *rb, size_t length) { +size_t ringbuffer_delete(ringbuffer_t* rb, size_t length) { assert(rb); - if (length > ringbuffer_size(rb)) - length = ringbuffer_size(rb); + if (length > ringbuffer_size(rb)) length = ringbuffer_size(rb); rb->head += length; - if (rb->head >= (rb->base + rb->total)) - rb->head -= rb->total; + if (rb->head >= (rb->base + rb->total)) rb->head -= rb->total; rb->available += length; return length; } -size_t ringbuffer_peek(const ringbuffer_t *rb, off_t offset, uint8_t *p, size_t length) { +size_t ringbuffer_peek(const ringbuffer_t* rb, off_t offset, uint8_t* p, + size_t length) { assert(rb); assert(p); assert(offset >= 0); assert((size_t)offset <= ringbuffer_size(rb)); - uint8_t *b = ((rb->head - rb->base + offset) % rb->total) + rb->base; - const size_t bytes_to_copy = (offset + length > ringbuffer_size(rb)) ? ringbuffer_size(rb) - offset : length; + uint8_t* b = ((rb->head - rb->base + offset) % rb->total) + rb->base; + const size_t bytes_to_copy = (offset + length > ringbuffer_size(rb)) + ? ringbuffer_size(rb) - offset + : length; for (size_t copied = 0; copied < bytes_to_copy; ++copied) { *p++ = *b++; - if (b >= (rb->base + rb->total)) - b = rb->base; + if (b >= (rb->base + rb->total)) b = rb->base; } return bytes_to_copy; } -size_t ringbuffer_pop(ringbuffer_t *rb, uint8_t *p, size_t length) { +size_t ringbuffer_pop(ringbuffer_t* rb, uint8_t* p, size_t length) { assert(rb); assert(p); const size_t copied = ringbuffer_peek(rb, 0, p, length); rb->head += copied; - if (rb->head >= (rb->base + rb->total)) - rb->head -= rb->total; + if (rb->head >= (rb->base + rb->total)) rb->head -= rb->total; rb->available += copied; return copied; diff --git a/osi/src/semaphore.cc b/osi/src/semaphore.cc index d24d38b5d..876095850 100644 --- a/osi/src/semaphore.cc +++ b/osi/src/semaphore.cc @@ -33,75 +33,78 @@ #include "osi/include/osi.h" #if !defined(EFD_SEMAPHORE) -# define EFD_SEMAPHORE (1 << 0) +#define EFD_SEMAPHORE (1 << 0) #endif struct semaphore_t { int fd; }; -semaphore_t *semaphore_new(unsigned int value) { - semaphore_t *ret = static_cast(osi_malloc(sizeof(semaphore_t))); +semaphore_t* semaphore_new(unsigned int value) { + semaphore_t* ret = static_cast(osi_malloc(sizeof(semaphore_t))); ret->fd = eventfd(value, EFD_SEMAPHORE); if (ret->fd == INVALID_FD) { - LOG_ERROR(LOG_TAG, "%s unable to allocate semaphore: %s", __func__, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to allocate semaphore: %s", __func__, + strerror(errno)); osi_free(ret); ret = NULL; } return ret; } -void semaphore_free(semaphore_t *semaphore) { - if (!semaphore) - return; +void semaphore_free(semaphore_t* semaphore) { + if (!semaphore) return; - if (semaphore->fd != INVALID_FD) - close(semaphore->fd); + if (semaphore->fd != INVALID_FD) close(semaphore->fd); osi_free(semaphore); } -void semaphore_wait(semaphore_t *semaphore) { +void semaphore_wait(semaphore_t* semaphore) { assert(semaphore != NULL); assert(semaphore->fd != INVALID_FD); eventfd_t value; if (eventfd_read(semaphore->fd, &value) == -1) - LOG_ERROR(LOG_TAG, "%s unable to wait on semaphore: %s", __func__, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to wait on semaphore: %s", __func__, + strerror(errno)); } -bool semaphore_try_wait(semaphore_t *semaphore) { +bool semaphore_try_wait(semaphore_t* semaphore) { assert(semaphore != NULL); assert(semaphore->fd != INVALID_FD); int flags = fcntl(semaphore->fd, F_GETFL); if (flags == -1) { - LOG_ERROR(LOG_TAG, "%s unable to get flags for semaphore fd: %s", __func__, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to get flags for semaphore fd: %s", __func__, + strerror(errno)); return false; } if (fcntl(semaphore->fd, F_SETFL, flags | O_NONBLOCK) == -1) { - LOG_ERROR(LOG_TAG, "%s unable to set O_NONBLOCK for semaphore fd: %s", __func__, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to set O_NONBLOCK for semaphore fd: %s", + __func__, strerror(errno)); return false; } bool rc = true; eventfd_t value; - if (eventfd_read(semaphore->fd, &value) == -1) - rc = false; + if (eventfd_read(semaphore->fd, &value) == -1) rc = false; if (fcntl(semaphore->fd, F_SETFL, flags) == -1) - LOG_ERROR(LOG_TAG, "%s unable to restore flags for semaphore fd: %s", __func__, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to restore flags for semaphore fd: %s", + __func__, strerror(errno)); return rc; } -void semaphore_post(semaphore_t *semaphore) { +void semaphore_post(semaphore_t* semaphore) { assert(semaphore != NULL); assert(semaphore->fd != INVALID_FD); if (eventfd_write(semaphore->fd, 1ULL) == -1) - LOG_ERROR(LOG_TAG, "%s unable to post to semaphore: %s", __func__, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to post to semaphore: %s", __func__, + strerror(errno)); } -int semaphore_get_fd(const semaphore_t *semaphore) { +int semaphore_get_fd(const semaphore_t* semaphore) { assert(semaphore != NULL); assert(semaphore->fd != INVALID_FD); return semaphore->fd; diff --git a/osi/src/socket.cc b/osi/src/socket.cc index 166c2cea4..737024678 100644 --- a/osi/src/socket.cc +++ b/osi/src/socket.cc @@ -39,94 +39,98 @@ static const in_addr_t LOCALHOST_ = 0x7f000001; struct socket_t { int fd; - reactor_object_t *reactor_object; + reactor_object_t* reactor_object; socket_cb read_ready; socket_cb write_ready; - void *context; // Not owned, do not free. + void* context; // Not owned, do not free. }; -static void internal_read_ready(void *context); -static void internal_write_ready(void *context); +static void internal_read_ready(void* context); +static void internal_write_ready(void* context); -socket_t *socket_new(void) { - socket_t *ret = (socket_t *)osi_calloc(sizeof(socket_t)); +socket_t* socket_new(void) { + socket_t* ret = (socket_t*)osi_calloc(sizeof(socket_t)); int enable = 1; ret->fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (ret->fd == INVALID_FD) { - LOG_ERROR(LOG_TAG, "%s unable to create socket: %s", __func__, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to create socket: %s", __func__, + strerror(errno)); goto error; } - if (setsockopt(ret->fd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable)) == -1) { - LOG_ERROR(LOG_TAG, "%s unable to set SO_REUSEADDR: %s", __func__, strerror(errno)); + if (setsockopt(ret->fd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable)) == + -1) { + LOG_ERROR(LOG_TAG, "%s unable to set SO_REUSEADDR: %s", __func__, + strerror(errno)); goto error; } return ret; error:; - if (ret) - close(ret->fd); + if (ret) close(ret->fd); osi_free(ret); return NULL; } -socket_t *socket_new_from_fd(int fd) { +socket_t* socket_new_from_fd(int fd) { assert(fd != INVALID_FD); - socket_t *ret = (socket_t *)osi_calloc(sizeof(socket_t)); + socket_t* ret = (socket_t*)osi_calloc(sizeof(socket_t)); ret->fd = fd; return ret; } -void socket_free(socket_t *socket) { - if (!socket) - return; +void socket_free(socket_t* socket) { + if (!socket) return; socket_unregister(socket); close(socket->fd); osi_free(socket); } -bool socket_listen(const socket_t *socket, port_t port) { +bool socket_listen(const socket_t* socket, port_t port) { assert(socket != NULL); struct sockaddr_in addr; addr.sin_family = AF_INET; addr.sin_addr.s_addr = htonl(LOCALHOST_); addr.sin_port = htons(port); - if (bind(socket->fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) { - LOG_ERROR(LOG_TAG, "%s unable to bind socket to port %u: %s", __func__, port, strerror(errno)); + if (bind(socket->fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) { + LOG_ERROR(LOG_TAG, "%s unable to bind socket to port %u: %s", __func__, + port, strerror(errno)); return false; } if (listen(socket->fd, 10) == -1) { - LOG_ERROR(LOG_TAG, "%s unable to listen on port %u: %s", __func__, port, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to listen on port %u: %s", __func__, port, + strerror(errno)); return false; } return true; } -socket_t *socket_accept(const socket_t *socket) { +socket_t* socket_accept(const socket_t* socket) { assert(socket != NULL); int fd; OSI_NO_INTR(fd = accept(socket->fd, NULL, NULL)); if (fd == INVALID_FD) { - LOG_ERROR(LOG_TAG, "%s unable to accept socket: %s", __func__, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to accept socket: %s", __func__, + strerror(errno)); return NULL; } - socket_t *ret = (socket_t *)osi_calloc(sizeof(socket_t)); + socket_t* ret = (socket_t*)osi_calloc(sizeof(socket_t)); ret->fd = fd; return ret; } -ssize_t socket_read(const socket_t *socket, void *buf, size_t count) { +ssize_t socket_read(const socket_t* socket, void* buf, size_t count) { assert(socket != NULL); assert(buf != NULL); @@ -136,7 +140,7 @@ ssize_t socket_read(const socket_t *socket, void *buf, size_t count) { return ret; } -ssize_t socket_write(const socket_t *socket, const void *buf, size_t count) { +ssize_t socket_write(const socket_t* socket, const void* buf, size_t count) { assert(socket != NULL); assert(buf != NULL); @@ -146,18 +150,18 @@ ssize_t socket_write(const socket_t *socket, const void *buf, size_t count) { return ret; } -ssize_t socket_write_and_transfer_fd(const socket_t *socket, const void *buf, size_t count, int fd) { +ssize_t socket_write_and_transfer_fd(const socket_t* socket, const void* buf, + size_t count, int fd) { assert(socket != NULL); assert(buf != NULL); - if (fd == INVALID_FD) - return socket_write(socket, buf, count); + if (fd == INVALID_FD) return socket_write(socket, buf, count); struct msghdr msg; struct iovec iov; char control_buf[CMSG_SPACE(sizeof(int))]; - iov.iov_base = (void *)buf; + iov.iov_base = (void*)buf; iov.iov_len = count; msg.msg_iov = &iov; @@ -167,11 +171,11 @@ ssize_t socket_write_and_transfer_fd(const socket_t *socket, const void *buf, si msg.msg_name = NULL; msg.msg_namelen = 0; - struct cmsghdr *header = CMSG_FIRSTHDR(&msg); + struct cmsghdr* header = CMSG_FIRSTHDR(&msg); header->cmsg_level = SOL_SOCKET; header->cmsg_type = SCM_RIGHTS; header->cmsg_len = CMSG_LEN(sizeof(int)); - *(int *)CMSG_DATA(header) = fd; + *(int*)CMSG_DATA(header) = fd; ssize_t ret; OSI_NO_INTR(ret = sendmsg(socket->fd, &msg, MSG_DONTWAIT)); @@ -180,16 +184,16 @@ ssize_t socket_write_and_transfer_fd(const socket_t *socket, const void *buf, si return ret; } -ssize_t socket_bytes_available(const socket_t *socket) { +ssize_t socket_bytes_available(const socket_t* socket) { assert(socket != NULL); int size = 0; - if (ioctl(socket->fd, FIONREAD, &size) == -1) - return -1; + if (ioctl(socket->fd, FIONREAD, &size) == -1) return -1; return size; } -void socket_register(socket_t *socket, reactor_t *reactor, void *context, socket_cb read_cb, socket_cb write_cb) { +void socket_register(socket_t* socket, reactor_t* reactor, void* context, + socket_cb read_cb, socket_cb write_cb) { assert(socket != NULL); // Make sure the socket isn't currently registered. @@ -199,30 +203,30 @@ void socket_register(socket_t *socket, reactor_t *reactor, void *context, socket socket->write_ready = write_cb; socket->context = context; - void (*read_fn)(void *) = (read_cb != NULL) ? internal_read_ready : NULL; - void (*write_fn)(void *) = (write_cb != NULL) ? internal_write_ready : NULL; + void (*read_fn)(void*) = (read_cb != NULL) ? internal_read_ready : NULL; + void (*write_fn)(void*) = (write_cb != NULL) ? internal_write_ready : NULL; - socket->reactor_object = reactor_register(reactor, socket->fd, socket, read_fn, write_fn); + socket->reactor_object = + reactor_register(reactor, socket->fd, socket, read_fn, write_fn); } -void socket_unregister(socket_t *socket) { +void socket_unregister(socket_t* socket) { assert(socket != NULL); - if (socket->reactor_object) - reactor_unregister(socket->reactor_object); + if (socket->reactor_object) reactor_unregister(socket->reactor_object); socket->reactor_object = NULL; } -static void internal_read_ready(void *context) { +static void internal_read_ready(void* context) { assert(context != NULL); - socket_t *socket = static_cast(context); + socket_t* socket = static_cast(context); socket->read_ready(socket, socket->context); } -static void internal_write_ready(void *context) { +static void internal_write_ready(void* context) { assert(context != NULL); - socket_t *socket = static_cast(context); + socket_t* socket = static_cast(context); socket->write_ready(socket, socket->context); } diff --git a/osi/src/socket_utils/README b/osi/src/socket_utils/README index 07a28bd05..9ed210a8f 100644 --- a/osi/src/socket_utils/README +++ b/osi/src/socket_utils/README @@ -14,23 +14,28 @@ * limitations under the License. */ -The sources in this folder re-implement some of the sources in libcutils/sockets -to provide a short-term solution eliminating libcutils dependency from -system/bt. Once a long-term platform-independent abstraction is presented, these -sources and the corresponding headers should be removed. +The sources in this folder re - + implement some of the sources in libcutils / sockets to provide a short - + term solution eliminating libcutils dependency from system / + bt.Once a long - + term platform - independent abstraction is presented, + these sources and the corresponding headers should be removed. -Note that only a part of the source files are pulled from libcutils/sockets, and -"osi_" prefix is added to all functions. The developers who want to pull sockets -sources other than the existing ones must put the sources in this folder and -refactor the functions as well. + Note that only a part of the source files are pulled from libcutils / + sockets, + and"osi_" prefix is added to all functions + .The developers who want to pull sockets sources other than the + existing ones must put the sources in this folder and refactor + the functions as well. -The current sources include: + The current sources include : -[Headers] - - osi/include/socket_utils/sockets.h - - osi/include/socket_utils/socket_local.h -[Source files] - - osi/src/socket_utils/socket_local_client.cc - - osi/src/socket_utils/socket_local_server.cc + [Headers] - + osi / include / socket_utils / sockets.h - + osi / include / socket_utils / socket_local.h[Source files] - + osi / src / socket_utils / socket_local_client.cc - + osi / src / socket_utils / + socket_local_server + .cc -Please update the above list if adding more sources. + Please update the above list if adding more sources. diff --git a/osi/src/socket_utils/socket_local_client.cc b/osi/src/socket_utils/socket_local_client.cc index 73a828c1e..7338407b6 100644 --- a/osi/src/socket_utils/socket_local_client.cc +++ b/osi/src/socket_utils/socket_local_client.cc @@ -25,14 +25,14 @@ #include #include "osi/include/osi.h" -#include "osi/include/socket_utils/sockets.h" #include "osi/include/socket_utils/socket_local.h" +#include "osi/include/socket_utils/sockets.h" #define LISTEN_BACKLOG 4 /* Documented in header file. */ -int osi_socket_make_sockaddr_un(const char *name, int namespaceId, - struct sockaddr_un *p_addr, socklen_t *alen) { +int osi_socket_make_sockaddr_un(const char* name, int namespaceId, + struct sockaddr_un* p_addr, socklen_t* alen) { memset(p_addr, 0, sizeof(*p_addr)); size_t namelen; @@ -109,7 +109,7 @@ error: * * Used by AndroidSocketImpl */ -int osi_socket_local_client_connect(int fd, const char *name, int namespaceId, +int osi_socket_local_client_connect(int fd, const char* name, int namespaceId, int type UNUSED_ATTR) { struct sockaddr_un addr; socklen_t alen; @@ -121,7 +121,7 @@ int osi_socket_local_client_connect(int fd, const char *name, int namespaceId, goto error; } - OSI_NO_INTR(err = connect(fd, (struct sockaddr *)&addr, alen)); + OSI_NO_INTR(err = connect(fd, (struct sockaddr*)&addr, alen)); if (err < 0) { goto error; } @@ -136,7 +136,7 @@ error: * connect to peer named "name" * returns fd or -1 on error */ -int osi_socket_local_client(const char *name, int namespaceId, int type) { +int osi_socket_local_client(const char* name, int namespaceId, int type) { int s; s = socket(AF_LOCAL, type, 0); diff --git a/osi/src/socket_utils/socket_local_server.cc b/osi/src/socket_utils/socket_local_server.cc index 79f179021..9bfdf54a1 100644 --- a/osi/src/socket_utils/socket_local_server.cc +++ b/osi/src/socket_utils/socket_local_server.cc @@ -19,14 +19,14 @@ #include #include #include -#include -#include #include +#include #include +#include #include -#include "osi/include/socket_utils/sockets.h" #include "osi/include/socket_utils/socket_local.h" +#include "osi/include/socket_utils/sockets.h" #define LISTEN_BACKLOG 4 @@ -39,7 +39,7 @@ * * Does not call listen() */ -int osi_socket_local_server_bind(int s, const char *name, int namespaceId) { +int osi_socket_local_server_bind(int s, const char* name, int namespaceId) { struct sockaddr_un addr; socklen_t alen; int n; @@ -65,7 +65,7 @@ int osi_socket_local_server_bind(int s, const char *name, int namespaceId) { n = 1; setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &n, sizeof(n)); - if (bind(s, (struct sockaddr *)&addr, alen) < 0) { + if (bind(s, (struct sockaddr*)&addr, alen) < 0) { return -1; } @@ -77,7 +77,7 @@ int osi_socket_local_server_bind(int s, const char *name, int namespaceId) { * * Returns fd on success, -1 on fail */ -int osi_socket_local_server(const char *name, int namespaceId, int type) { +int osi_socket_local_server(const char* name, int namespaceId, int type) { int err; int s; diff --git a/osi/src/thread.cc b/osi/src/thread.cc index 6c9fab774..92017a3ff 100644 --- a/osi/src/thread.cc +++ b/osi/src/thread.cc @@ -42,45 +42,42 @@ struct thread_t { pthread_t pthread; pid_t tid; char name[THREAD_NAME_MAX + 1]; - reactor_t *reactor; - fixed_queue_t *work_queue; + reactor_t* reactor; + fixed_queue_t* work_queue; }; struct start_arg { - thread_t *thread; - semaphore_t *start_sem; + thread_t* thread; + semaphore_t* start_sem; int error; }; typedef struct { thread_fn func; - void *context; + void* context; } work_item_t; -static void *run_thread(void *start_arg); -static void work_queue_read_cb(void *context); +static void* run_thread(void* start_arg); +static void work_queue_read_cb(void* context); static const size_t DEFAULT_WORK_QUEUE_CAPACITY = 128; -thread_t *thread_new_sized(const char *name, size_t work_queue_capacity) { +thread_t* thread_new_sized(const char* name, size_t work_queue_capacity) { assert(name != NULL); assert(work_queue_capacity != 0); - thread_t *ret = static_cast(osi_calloc(sizeof(thread_t))); + thread_t* ret = static_cast(osi_calloc(sizeof(thread_t))); ret->reactor = reactor_new(); - if (!ret->reactor) - goto error; + if (!ret->reactor) goto error; ret->work_queue = fixed_queue_new(work_queue_capacity); - if (!ret->work_queue) - goto error; + if (!ret->work_queue) goto error; // Start is on the stack, but we use a semaphore, so it's safe struct start_arg start; start.start_sem = semaphore_new(0); - if (!start.start_sem) - goto error; + if (!start.start_sem) goto error; strncpy(ret->name, name, THREAD_NAME_MAX); start.thread = ret; @@ -89,8 +86,7 @@ thread_t *thread_new_sized(const char *name, size_t work_queue_capacity) { semaphore_wait(start.start_sem); semaphore_free(start.start_sem); - if (start.error) - goto error; + if (start.error) goto error; return ret; @@ -103,13 +99,12 @@ error:; return NULL; } -thread_t *thread_new(const char *name) { +thread_t* thread_new(const char* name) { return thread_new_sized(name, DEFAULT_WORK_QUEUE_CAPACITY); } -void thread_free(thread_t *thread) { - if (!thread) - return; +void thread_free(thread_t* thread) { + if (!thread) return; thread_stop(thread); thread_join(thread); @@ -119,7 +114,7 @@ void thread_free(thread_t *thread) { osi_free(thread); } -void thread_join(thread_t *thread) { +void thread_join(thread_t* thread) { assert(thread != NULL); // TODO(zachoverflow): use a compare and swap when ready @@ -129,7 +124,7 @@ void thread_join(thread_t *thread) { } } -bool thread_post(thread_t *thread, thread_fn func, void *context) { +bool thread_post(thread_t* thread, thread_fn func, void* context) { assert(thread != NULL); assert(func != NULL); @@ -139,71 +134,74 @@ bool thread_post(thread_t *thread, thread_fn func, void *context) { // Queue item is freed either when the queue itself is destroyed // or when the item is removed from the queue for dispatch. - work_item_t *item = (work_item_t *)osi_malloc(sizeof(work_item_t)); + work_item_t* item = (work_item_t*)osi_malloc(sizeof(work_item_t)); item->func = func; item->context = context; fixed_queue_enqueue(thread->work_queue, item); return true; } -void thread_stop(thread_t *thread) { +void thread_stop(thread_t* thread) { assert(thread != NULL); reactor_stop(thread->reactor); } -bool thread_set_priority(thread_t *thread, int priority) { - if (!thread) - return false; +bool thread_set_priority(thread_t* thread, int priority) { + if (!thread) return false; const int rc = setpriority(PRIO_PROCESS, thread->tid, priority); if (rc < 0) { - LOG_ERROR(LOG_TAG, "%s unable to set thread priority %d for tid %d, error %d", - __func__, priority, thread->tid, rc); + LOG_ERROR(LOG_TAG, + "%s unable to set thread priority %d for tid %d, error %d", + __func__, priority, thread->tid, rc); return false; } return true; } -bool thread_is_self(const thread_t *thread) { +bool thread_is_self(const thread_t* thread) { assert(thread != NULL); return !!pthread_equal(pthread_self(), thread->pthread); } -reactor_t *thread_get_reactor(const thread_t *thread) { +reactor_t* thread_get_reactor(const thread_t* thread) { assert(thread != NULL); return thread->reactor; } -const char *thread_name(const thread_t *thread) { +const char* thread_name(const thread_t* thread) { assert(thread != NULL); return thread->name; } -static void *run_thread(void *start_arg) { +static void* run_thread(void* start_arg) { assert(start_arg != NULL); - struct start_arg *start = static_cast(start_arg); - thread_t *thread = start->thread; + struct start_arg* start = static_cast(start_arg); + thread_t* thread = start->thread; assert(thread != NULL); if (prctl(PR_SET_NAME, (unsigned long)thread->name) == -1) { - LOG_ERROR(LOG_TAG, "%s unable to set thread name: %s", __func__, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to set thread name: %s", __func__, + strerror(errno)); start->error = errno; semaphore_post(start->start_sem); return NULL; } thread->tid = gettid(); - LOG_WARN(LOG_TAG, "%s: thread id %d, thread name %s started", __func__, thread->tid, thread->name); + LOG_WARN(LOG_TAG, "%s: thread id %d, thread name %s started", __func__, + thread->tid, thread->name); semaphore_post(start->start_sem); int fd = fixed_queue_get_dequeue_fd(thread->work_queue); - void *context = thread->work_queue; + void* context = thread->work_queue; - reactor_object_t *work_queue_object = reactor_register(thread->reactor, fd, context, work_queue_read_cb, NULL); + reactor_object_t* work_queue_object = + reactor_register(thread->reactor, fd, context, work_queue_read_cb, NULL); reactor_start(thread->reactor); reactor_unregister(work_queue_object); @@ -211,26 +209,29 @@ static void *run_thread(void *start_arg) { // This allows a caller to safely tear down by enqueuing a teardown // work item and then joining the thread. size_t count = 0; - work_item_t *item = static_cast(fixed_queue_try_dequeue(thread->work_queue)); + work_item_t* item = + static_cast(fixed_queue_try_dequeue(thread->work_queue)); while (item && count <= fixed_queue_capacity(thread->work_queue)) { item->func(item->context); osi_free(item); - item = static_cast(fixed_queue_try_dequeue(thread->work_queue)); + item = + static_cast(fixed_queue_try_dequeue(thread->work_queue)); ++count; } if (count > fixed_queue_capacity(thread->work_queue)) LOG_DEBUG(LOG_TAG, "%s growing event queue on shutdown.", __func__); - LOG_WARN(LOG_TAG, "%s: thread id %d, thread name %s exited", __func__, thread->tid, thread->name); + LOG_WARN(LOG_TAG, "%s: thread id %d, thread name %s exited", __func__, + thread->tid, thread->name); return NULL; } -static void work_queue_read_cb(void *context) { +static void work_queue_read_cb(void* context) { assert(context != NULL); - fixed_queue_t *queue = (fixed_queue_t *)context; - work_item_t *item = static_cast(fixed_queue_dequeue(queue)); + fixed_queue_t* queue = (fixed_queue_t*)context; + work_item_t* item = static_cast(fixed_queue_dequeue(queue)); item->func(item->context); osi_free(item); } diff --git a/osi/src/time.cc b/osi/src/time.cc index c432a28c0..a36d411e5 100644 --- a/osi/src/time.cc +++ b/osi/src/time.cc @@ -23,7 +23,7 @@ #include "osi/include/time.h" uint32_t time_get_os_boottime_ms(void) { - return (uint32_t) (time_get_os_boottime_us() / 1000); + return (uint32_t)(time_get_os_boottime_us() / 1000); } uint64_t time_get_os_boottime_us(void) { @@ -31,5 +31,5 @@ uint64_t time_get_os_boottime_us(void) { clock_gettime(CLOCK_BOOTTIME, &ts_now); return ((uint64_t)ts_now.tv_sec * 1000000L) + - ((uint64_t)ts_now.tv_nsec / 1000); + ((uint64_t)ts_now.tv_nsec / 1000); } diff --git a/osi/src/wakelock.cc b/osi/src/wakelock.cc index 534f82aa3..777aa8c8b 100644 --- a/osi/src/wakelock.cc +++ b/osi/src/wakelock.cc @@ -26,8 +26,8 @@ #include #include #include -#include #include +#include #include #include @@ -41,11 +41,11 @@ #include "osi/include/thread.h" #include "osi/include/wakelock.h" -static bt_os_callouts_t *wakelock_os_callouts = NULL; +static bt_os_callouts_t* wakelock_os_callouts = NULL; static bool is_native = true; static const clockid_t CLOCK_ID = CLOCK_BOOTTIME; -static const char *WAKE_LOCK_ID = "bluetooth_timer"; +static const char* WAKE_LOCK_ID = "bluetooth_timer"; static const std::string DEFAULT_WAKE_LOCK_PATH = "/sys/power/wake_lock"; static const std::string DEFAULT_WAKE_UNLOCK_PATH = "/sys/power/wake_unlock"; static std::string wake_lock_path; @@ -89,12 +89,11 @@ static void reset_wakelock_stats(void); static void update_wakelock_acquired_stats(bt_status_t acquired_status); static void update_wakelock_released_stats(bt_status_t released_status); -void wakelock_set_os_callouts(bt_os_callouts_t *callouts) -{ +void wakelock_set_os_callouts(bt_os_callouts_t* callouts) { wakelock_os_callouts = callouts; is_native = (wakelock_os_callouts == NULL); - LOG_INFO(LOG_TAG, "%s set to %s", - __func__, (is_native)? "native" : "non-native"); + LOG_INFO(LOG_TAG, "%s set to %s", __func__, + (is_native) ? "native" : "non-native"); } bool wakelock_acquire(void) { @@ -116,7 +115,8 @@ bool wakelock_acquire(void) { } static bt_status_t wakelock_acquire_callout(void) { - return static_cast(wakelock_os_callouts->acquire_wake_lock(WAKE_LOCK_ID)); + return static_cast( + wakelock_os_callouts->acquire_wake_lock(WAKE_LOCK_ID)); } static bt_status_t wakelock_acquire_native(void) { @@ -133,13 +133,13 @@ static bt_status_t wakelock_acquire_native(void) { long lock_name_len = strlen(WAKE_LOCK_ID); locked_id_len = write(wake_lock_fd, WAKE_LOCK_ID, lock_name_len); if (locked_id_len == -1) { - LOG_ERROR(LOG_TAG, "%s wake lock not acquired: %s", - __func__, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s wake lock not acquired: %s", __func__, + strerror(errno)); return BT_STATUS_FAIL; } else if (locked_id_len < lock_name_len) { // TODO (jamuraa): this is weird. maybe we should release and retry. - LOG_WARN(LOG_TAG, "%s wake lock truncated to %zd chars", - __func__, locked_id_len); + LOG_WARN(LOG_TAG, "%s wake lock truncated to %zd chars", __func__, + locked_id_len); } return BT_STATUS_SUCCESS; } @@ -160,7 +160,8 @@ bool wakelock_release(void) { } static bt_status_t wakelock_release_callout(void) { - return static_cast(wakelock_os_callouts->release_wake_lock(WAKE_LOCK_ID)); + return static_cast( + wakelock_os_callouts->release_wake_lock(WAKE_LOCK_ID)); } static bt_status_t wakelock_release_native(void) { @@ -171,8 +172,8 @@ static bt_status_t wakelock_release_native(void) { ssize_t wrote_name_len = write(wake_unlock_fd, WAKE_LOCK_ID, locked_id_len); if (wrote_name_len == -1) { - LOG_ERROR(LOG_TAG, "%s can't release wake lock: %s", - __func__, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s can't release wake lock: %s", __func__, + strerror(errno)); } else if (wrote_name_len < locked_id_len) { LOG_ERROR(LOG_TAG, "%s lock release only wrote %zd, assuming released", __func__, wrote_name_len); @@ -184,29 +185,26 @@ static void wakelock_initialize(void) { pthread_mutex_init(&monitor, NULL); reset_wakelock_stats(); - if (is_native) - wakelock_initialize_native(); + if (is_native) wakelock_initialize_native(); } static void wakelock_initialize_native(void) { LOG_DEBUG(LOG_TAG, "%s opening wake locks", __func__); - if (wake_lock_path.empty()) - wake_lock_path = DEFAULT_WAKE_LOCK_PATH; + if (wake_lock_path.empty()) wake_lock_path = DEFAULT_WAKE_LOCK_PATH; wake_lock_fd = open(wake_lock_path.c_str(), O_RDWR | O_CLOEXEC); if (wake_lock_fd == INVALID_FD) { - LOG_ERROR(LOG_TAG, "%s can't open wake lock %s: %s", - __func__, wake_lock_path.c_str(), strerror(errno)); + LOG_ERROR(LOG_TAG, "%s can't open wake lock %s: %s", __func__, + wake_lock_path.c_str(), strerror(errno)); } - if (wake_unlock_path.empty()) - wake_unlock_path = DEFAULT_WAKE_UNLOCK_PATH; + if (wake_unlock_path.empty()) wake_unlock_path = DEFAULT_WAKE_UNLOCK_PATH; wake_unlock_fd = open(wake_unlock_path.c_str(), O_RDWR | O_CLOEXEC); if (wake_unlock_fd == INVALID_FD) { - LOG_ERROR(LOG_TAG, "%s can't open wake unlock %s: %s", - __func__, wake_unlock_path.c_str(), strerror(errno)); + LOG_ERROR(LOG_TAG, "%s can't open wake unlock %s: %s", __func__, + wake_unlock_path.c_str(), strerror(errno)); } } @@ -217,19 +215,17 @@ void wakelock_cleanup(void) { pthread_mutex_destroy(&monitor); } -void wakelock_set_paths(const char *lock_path, const char *unlock_path) { - if (lock_path) - wake_lock_path = lock_path; +void wakelock_set_paths(const char* lock_path, const char* unlock_path) { + if (lock_path) wake_lock_path = lock_path; - if (unlock_path) - wake_unlock_path = unlock_path; + if (unlock_path) wake_unlock_path = unlock_path; } static period_ms_t now(void) { struct timespec ts; if (clock_gettime(CLOCK_ID, &ts) == -1) { - LOG_ERROR(LOG_TAG, "%s unable to get current time: %s", - __func__, strerror(errno)); + LOG_ERROR(LOG_TAG, "%s unable to get current time: %s", __func__, + strerror(errno)); return 0; } @@ -349,27 +345,26 @@ void wakelock_debug_dump(int fd) { if (wakelock_stats.is_acquired) { delta_ms = now_ms - wakelock_stats.last_acquired_timestamp_ms; - if (delta_ms > max_interval) - max_interval = delta_ms; - if (delta_ms < min_interval) - min_interval = delta_ms; + if (delta_ms > max_interval) max_interval = delta_ms; + if (delta_ms < min_interval) min_interval = delta_ms; last_interval = delta_ms; } period_ms_t total_interval = - wakelock_stats.total_acquired_interval_ms + delta_ms; + wakelock_stats.total_acquired_interval_ms + delta_ms; if (wakelock_stats.acquired_count > 0) ave_interval = total_interval / wakelock_stats.acquired_count; dprintf(fd, "\nBluetooth Wakelock Statistics:\n"); dprintf(fd, " Is acquired : %s\n", - wakelock_stats.is_acquired? "true" : "false"); + wakelock_stats.is_acquired ? "true" : "false"); dprintf(fd, " Acquired/released count : %zu / %zu\n", wakelock_stats.acquired_count, wakelock_stats.released_count); dprintf(fd, " Acquired/released error count : %zu / %zu\n", wakelock_stats.acquired_errors, wakelock_stats.released_errors); dprintf(fd, " Last acquire/release error code: %d / %d\n", - wakelock_stats.last_acquired_error, wakelock_stats.last_released_error); + wakelock_stats.last_acquired_error, + wakelock_stats.last_released_error); dprintf(fd, " Last acquired time (ms) : %llu\n", (unsigned long long)last_interval); dprintf(fd, " Acquired time min/max/avg (ms) : %llu / %llu / %llu\n", @@ -377,9 +372,9 @@ void wakelock_debug_dump(int fd) { (unsigned long long)ave_interval); dprintf(fd, " Total acquired time (ms) : %llu\n", (unsigned long long)total_interval); - dprintf(fd, " Total run time (ms) : %llu\n", - (unsigned long long)(now_ms - wakelock_stats.last_reset_timestamp_ms)); + dprintf( + fd, " Total run time (ms) : %llu\n", + (unsigned long long)(now_ms - wakelock_stats.last_reset_timestamp_ms)); - if (lock_error == 0) - pthread_mutex_unlock(&monitor); + if (lock_error == 0) pthread_mutex_unlock(&monitor); } diff --git a/osi/test/AlarmTestHarness.cc b/osi/test/AlarmTestHarness.cc index 286a3e1fe..ee6aaa353 100644 --- a/osi/test/AlarmTestHarness.cc +++ b/osi/test/AlarmTestHarness.cc @@ -25,24 +25,18 @@ static bool is_wake_lock_acquired = false; -static int acquire_wake_lock_cb(const char *lock_name) -{ +static int acquire_wake_lock_cb(const char* lock_name) { is_wake_lock_acquired = true; return BT_STATUS_SUCCESS; } -static int release_wake_lock_cb(const char *lock_name) -{ +static int release_wake_lock_cb(const char* lock_name) { is_wake_lock_acquired = false; return BT_STATUS_SUCCESS; } static bt_os_callouts_t bt_wakelock_callouts = { - sizeof(bt_os_callouts_t), - NULL, - acquire_wake_lock_cb, - release_wake_lock_cb -}; + sizeof(bt_os_callouts_t), NULL, acquire_wake_lock_cb, release_wake_lock_cb}; void AlarmTestHarness::SetUp() { AllocationTestHarness::SetUp(); @@ -60,6 +54,4 @@ void AlarmTestHarness::TearDown() { AllocationTestHarness::TearDown(); } -bool AlarmTestHarness::WakeLockHeld() { - return is_wake_lock_acquired; -} +bool AlarmTestHarness::WakeLockHeld() { return is_wake_lock_acquired; } diff --git a/osi/test/AlarmTestHarness.h b/osi/test/AlarmTestHarness.h index d37ded04c..39dd21879 100644 --- a/osi/test/AlarmTestHarness.h +++ b/osi/test/AlarmTestHarness.h @@ -23,11 +23,11 @@ extern int64_t TIMER_INTERVAL_FOR_WAKELOCK_IN_MS; class AlarmTestHarness : public AllocationTestHarness { - protected: - virtual void SetUp(); - virtual void TearDown(); + protected: + virtual void SetUp(); + virtual void TearDown(); - public: - // Returns true if a wake lock is held. - bool WakeLockHeld(); + public: + // Returns true if a wake lock is held. + bool WakeLockHeld(); }; diff --git a/osi/test/AllocationTestHarness.cc b/osi/test/AllocationTestHarness.cc index 538623724..8df097f6d 100644 --- a/osi/test/AllocationTestHarness.cc +++ b/osi/test/AllocationTestHarness.cc @@ -28,5 +28,6 @@ void AllocationTestHarness::SetUp() { } void AllocationTestHarness::TearDown() { - EXPECT_EQ(0U, allocation_tracker_expect_no_allocations()) << "not all memory freed"; + EXPECT_EQ(0U, allocation_tracker_expect_no_allocations()) + << "not all memory freed"; } diff --git a/osi/test/AllocationTestHarness.h b/osi/test/AllocationTestHarness.h index 65fc0b00a..cbf29d8c5 100644 --- a/osi/test/AllocationTestHarness.h +++ b/osi/test/AllocationTestHarness.h @@ -21,7 +21,7 @@ #include class AllocationTestHarness : public ::testing::Test { - protected: - virtual void SetUp(); - virtual void TearDown(); + protected: + virtual void SetUp(); + virtual void TearDown(); }; diff --git a/osi/test/alarm_test.cc b/osi/test/alarm_test.cc index 331a043cd..dd4bbc15a 100644 --- a/osi/test/alarm_test.cc +++ b/osi/test/alarm_test.cc @@ -26,63 +26,58 @@ #include "osi/include/semaphore.h" #include "osi/include/thread.h" -static semaphore_t *semaphore; +static semaphore_t* semaphore; static int cb_counter; static int cb_misordered_counter; static const uint64_t EPSILON_MS = 50; -static void msleep(uint64_t ms) { - usleep(ms * 1000); -} +static void msleep(uint64_t ms) { usleep(ms * 1000); } class AlarmTest : public AlarmTestHarness { - protected: - virtual void SetUp() { - AlarmTestHarness::SetUp(); - cb_counter = 0; - cb_misordered_counter = 0; - - semaphore = semaphore_new(0); - } - - virtual void TearDown() { - semaphore_free(semaphore); - AlarmTestHarness::TearDown(); - } + protected: + virtual void SetUp() { + AlarmTestHarness::SetUp(); + cb_counter = 0; + cb_misordered_counter = 0; + + semaphore = semaphore_new(0); + } + + virtual void TearDown() { + semaphore_free(semaphore); + AlarmTestHarness::TearDown(); + } }; -static void cb(UNUSED_ATTR void *data) { +static void cb(UNUSED_ATTR void* data) { ++cb_counter; semaphore_post(semaphore); } -static void ordered_cb(void *data) { +static void ordered_cb(void* data) { int i = PTR_TO_INT(data); - if (i != cb_counter) - cb_misordered_counter++; + if (i != cb_counter) cb_misordered_counter++; ++cb_counter; semaphore_post(semaphore); } TEST_F(AlarmTest, test_new_free_simple) { - alarm_t *alarm = alarm_new("alarm_test.test_new_free_simple"); + alarm_t* alarm = alarm_new("alarm_test.test_new_free_simple"); ASSERT_TRUE(alarm != NULL); alarm_free(alarm); } -TEST_F(AlarmTest, test_free_null) { - alarm_free(NULL); -} +TEST_F(AlarmTest, test_free_null) { alarm_free(NULL); } TEST_F(AlarmTest, test_simple_cancel) { - alarm_t *alarm = alarm_new("alarm_test.test_simple_cancel"); + alarm_t* alarm = alarm_new("alarm_test.test_simple_cancel"); alarm_cancel(alarm); alarm_free(alarm); } TEST_F(AlarmTest, test_cancel) { - alarm_t *alarm = alarm_new("alarm_test.test_cancel"); + alarm_t* alarm = alarm_new("alarm_test.test_cancel"); alarm_set(alarm, 10, cb, NULL); alarm_cancel(alarm); @@ -94,7 +89,7 @@ TEST_F(AlarmTest, test_cancel) { } TEST_F(AlarmTest, test_cancel_idempotent) { - alarm_t *alarm = alarm_new("alarm_test.test_cancel_idempotent"); + alarm_t* alarm = alarm_new("alarm_test.test_cancel_idempotent"); alarm_set(alarm, 10, cb, NULL); alarm_cancel(alarm); alarm_cancel(alarm); @@ -103,7 +98,7 @@ TEST_F(AlarmTest, test_cancel_idempotent) { } TEST_F(AlarmTest, test_set_short) { - alarm_t *alarm = alarm_new("alarm_test.test_set_short"); + alarm_t* alarm = alarm_new("alarm_test.test_set_short"); alarm_set(alarm, 10, cb, NULL); @@ -119,7 +114,7 @@ TEST_F(AlarmTest, test_set_short) { } TEST_F(AlarmTest, test_set_short_periodic) { - alarm_t *alarm = alarm_new_periodic("alarm_test.test_set_short_periodic"); + alarm_t* alarm = alarm_new_periodic("alarm_test.test_set_short_periodic"); alarm_set(alarm, 10, cb, NULL); @@ -139,7 +134,7 @@ TEST_F(AlarmTest, test_set_short_periodic) { } TEST_F(AlarmTest, test_set_zero_periodic) { - alarm_t *alarm = alarm_new_periodic("alarm_test.test_set_zero_periodic"); + alarm_t* alarm = alarm_new_periodic("alarm_test.test_set_zero_periodic"); alarm_set(alarm, 0, cb, NULL); @@ -158,7 +153,7 @@ TEST_F(AlarmTest, test_set_zero_periodic) { } TEST_F(AlarmTest, test_set_long) { - alarm_t *alarm = alarm_new("alarm_test.test_set_long"); + alarm_t* alarm = alarm_new("alarm_test.test_set_long"); alarm_set(alarm, TIMER_INTERVAL_FOR_WAKELOCK_IN_MS + EPSILON_MS, cb, NULL); EXPECT_EQ(cb_counter, 0); @@ -173,10 +168,8 @@ TEST_F(AlarmTest, test_set_long) { } TEST_F(AlarmTest, test_set_short_short) { - alarm_t *alarm[2] = { - alarm_new("alarm_test.test_set_short_short_0"), - alarm_new("alarm_test.test_set_short_short_1") - }; + alarm_t* alarm[2] = {alarm_new("alarm_test.test_set_short_short_0"), + alarm_new("alarm_test.test_set_short_short_1")}; alarm_set(alarm[0], 10, cb, NULL); alarm_set(alarm[1], 20, cb, NULL); @@ -199,13 +192,12 @@ TEST_F(AlarmTest, test_set_short_short) { } TEST_F(AlarmTest, test_set_short_long) { - alarm_t *alarm[2] = { - alarm_new("alarm_test.test_set_short_long_0"), - alarm_new("alarm_test.test_set_short_long_1") - }; + alarm_t* alarm[2] = {alarm_new("alarm_test.test_set_short_long_0"), + alarm_new("alarm_test.test_set_short_long_1")}; alarm_set(alarm[0], 10, cb, NULL); - alarm_set(alarm[1], 10 + TIMER_INTERVAL_FOR_WAKELOCK_IN_MS + EPSILON_MS, cb, NULL); + alarm_set(alarm[1], 10 + TIMER_INTERVAL_FOR_WAKELOCK_IN_MS + EPSILON_MS, cb, + NULL); EXPECT_EQ(cb_counter, 0); EXPECT_TRUE(WakeLockHeld()); @@ -225,13 +217,12 @@ TEST_F(AlarmTest, test_set_short_long) { } TEST_F(AlarmTest, test_set_long_long) { - alarm_t *alarm[2] = { - alarm_new("alarm_test.test_set_long_long_0"), - alarm_new("alarm_test.test_set_long_long_1") - }; + alarm_t* alarm[2] = {alarm_new("alarm_test.test_set_long_long_0"), + alarm_new("alarm_test.test_set_long_long_1")}; alarm_set(alarm[0], TIMER_INTERVAL_FOR_WAKELOCK_IN_MS + EPSILON_MS, cb, NULL); - alarm_set(alarm[1], 2 * (TIMER_INTERVAL_FOR_WAKELOCK_IN_MS + EPSILON_MS), cb, NULL); + alarm_set(alarm[1], 2 * (TIMER_INTERVAL_FOR_WAKELOCK_IN_MS + EPSILON_MS), cb, + NULL); EXPECT_EQ(cb_counter, 0); EXPECT_FALSE(WakeLockHeld()); @@ -251,9 +242,9 @@ TEST_F(AlarmTest, test_set_long_long) { } TEST_F(AlarmTest, test_is_scheduled) { - alarm_t *alarm = alarm_new("alarm_test.test_is_scheduled"); + alarm_t* alarm = alarm_new("alarm_test.test_is_scheduled"); - EXPECT_FALSE(alarm_is_scheduled((alarm_t *)NULL)); + EXPECT_FALSE(alarm_is_scheduled((alarm_t*)NULL)); EXPECT_FALSE(alarm_is_scheduled(alarm)); alarm_set(alarm, TIMER_INTERVAL_FOR_WAKELOCK_IN_MS + EPSILON_MS, cb, NULL); EXPECT_TRUE(alarm_is_scheduled(alarm)); @@ -272,11 +263,11 @@ TEST_F(AlarmTest, test_is_scheduled) { // Test whether the callbacks are invoked in the expected order TEST_F(AlarmTest, test_callback_ordering) { - alarm_t *alarms[100]; + alarm_t* alarms[100]; for (int i = 0; i < 100; i++) { - const std::string alarm_name = "alarm_test.test_callback_ordering[" + - std::to_string(i) + "]"; + const std::string alarm_name = + "alarm_test.test_callback_ordering[" + std::to_string(i) + "]"; alarms[i] = alarm_new(alarm_name.c_str()); } @@ -291,8 +282,7 @@ TEST_F(AlarmTest, test_callback_ordering) { EXPECT_EQ(cb_counter, 100); EXPECT_EQ(cb_misordered_counter, 0); - for (int i = 0; i < 100; i++) - alarm_free(alarms[i]); + for (int i = 0; i < 100; i++) alarm_free(alarms[i]); EXPECT_FALSE(WakeLockHeld()); } @@ -300,16 +290,16 @@ TEST_F(AlarmTest, test_callback_ordering) { // Test whether the callbacks are involed in the expected order on a // separate queue. TEST_F(AlarmTest, test_callback_ordering_on_queue) { - alarm_t *alarms[100]; - fixed_queue_t *queue = fixed_queue_new(SIZE_MAX); - thread_t *thread = thread_new("timers.test_callback_ordering_on_queue.thread"); + alarm_t* alarms[100]; + fixed_queue_t* queue = fixed_queue_new(SIZE_MAX); + thread_t* thread = + thread_new("timers.test_callback_ordering_on_queue.thread"); alarm_register_processing_queue(queue, thread); for (int i = 0; i < 100; i++) { const std::string alarm_name = - "alarm_test.test_callback_ordering_on_queue[" + - std::to_string(i) + "]"; + "alarm_test.test_callback_ordering_on_queue[" + std::to_string(i) + "]"; alarms[i] = alarm_new(alarm_name.c_str()); } @@ -324,8 +314,7 @@ TEST_F(AlarmTest, test_callback_ordering_on_queue) { EXPECT_EQ(cb_counter, 100); EXPECT_EQ(cb_misordered_counter, 0); - for (int i = 0; i < 100; i++) - alarm_free(alarms[i]); + for (int i = 0; i < 100; i++) alarm_free(alarms[i]); EXPECT_FALSE(WakeLockHeld()); @@ -337,17 +326,17 @@ TEST_F(AlarmTest, test_callback_ordering_on_queue) { // Test whether unregistering a processing queue cancels all timers using // that queue. TEST_F(AlarmTest, test_unregister_processing_queue) { - alarm_t *alarms[100]; - fixed_queue_t *queue = fixed_queue_new(SIZE_MAX); - thread_t *thread = - thread_new("timers.test_unregister_processing_queue.thread"); + alarm_t* alarms[100]; + fixed_queue_t* queue = fixed_queue_new(SIZE_MAX); + thread_t* thread = + thread_new("timers.test_unregister_processing_queue.thread"); alarm_register_processing_queue(queue, thread); for (int i = 0; i < 100; i++) { const std::string alarm_name = - "alarm_test.test_unregister_processing_queue[" + - std::to_string(i) + "]"; + "alarm_test.test_unregister_processing_queue[" + std::to_string(i) + + "]"; alarms[i] = alarm_new(alarm_name.c_str()); } @@ -356,7 +345,8 @@ TEST_F(AlarmTest, test_unregister_processing_queue) { alarm_set_on_queue(alarms[i], 100, ordered_cb, INT_TO_PTR(i), queue); } for (int i = 50; i < 100; i++) { - alarm_set_on_queue(alarms[i], 1000 * 1000, ordered_cb, INT_TO_PTR(i), queue); + alarm_set_on_queue(alarms[i], 1000 * 1000, ordered_cb, INT_TO_PTR(i), + queue); } // Wait until half of the timers have expired @@ -395,17 +385,17 @@ TEST_F(AlarmTest, test_unregister_processing_queue) { // Test whether unregistering a processing queue cancels all periodic timers // using that queue. TEST_F(AlarmTest, test_periodic_unregister_processing_queue) { - alarm_t *alarms[5]; - fixed_queue_t *queue = fixed_queue_new(SIZE_MAX); - thread_t *thread = - thread_new("timers.test_periodic_unregister_processing_queue.thread"); + alarm_t* alarms[5]; + fixed_queue_t* queue = fixed_queue_new(SIZE_MAX); + thread_t* thread = + thread_new("timers.test_periodic_unregister_processing_queue.thread"); alarm_register_processing_queue(queue, thread); for (int i = 0; i < 5; i++) { const std::string alarm_name = - "alarm_test.test_periodic_unregister_processing_queue[" + - std::to_string(i) + "]"; + "alarm_test.test_periodic_unregister_processing_queue[" + + std::to_string(i) + "]"; alarms[i] = alarm_new_periodic(alarm_name.c_str()); } @@ -453,9 +443,9 @@ TEST_F(AlarmTest, test_periodic_unregister_processing_queue) { // Try to catch any race conditions between the timer callback and |alarm_free|. TEST_F(AlarmTest, test_callback_free_race) { for (int i = 0; i < 1000; ++i) { - const std::string alarm_name = "alarm_test.test_callback_free_race[" + - std::to_string(i) + "]"; - alarm_t *alarm = alarm_new(alarm_name.c_str()); + const std::string alarm_name = + "alarm_test.test_callback_free_race[" + std::to_string(i) + "]"; + alarm_t* alarm = alarm_new(alarm_name.c_str()); alarm_set(alarm, 0, cb, NULL); alarm_free(alarm); } diff --git a/osi/test/allocation_tracker_test.cc b/osi/test/allocation_tracker_test.cc index ce465e93b..cf979cb19 100644 --- a/osi/test/allocation_tracker_test.cc +++ b/osi/test/allocation_tracker_test.cc @@ -25,14 +25,16 @@ void allocation_tracker_uninit(void); static const allocator_id_t allocator_id = 5; TEST(AllocationTrackerTest, test_uninit_no_bad_effects) { - void *dummy_allocation = malloc(4); + void* dummy_allocation = malloc(4); // Ensure uninitialized state (previous tests may have called init) allocation_tracker_uninit(); EXPECT_EQ(4U, allocation_tracker_resize_for_canary(4)); allocation_tracker_notify_alloc(allocator_id, dummy_allocation, 4); - EXPECT_EQ(0U, allocation_tracker_expect_no_allocations()); // should not have registered an allocation + EXPECT_EQ(0U, allocation_tracker_expect_no_allocations()); // should not have + // registered an + // allocation allocation_tracker_notify_free(allocator_id, dummy_allocation); EXPECT_EQ(0U, allocation_tracker_expect_no_allocations()); @@ -46,11 +48,15 @@ TEST(AllocationTrackerTest, test_canaries_on) { size_t with_canary_size = allocation_tracker_resize_for_canary(4); EXPECT_TRUE(with_canary_size > 4); - void *dummy_allocation = malloc(with_canary_size); - void *useable_ptr = allocation_tracker_notify_alloc(allocator_id, dummy_allocation, 4); + void* dummy_allocation = malloc(with_canary_size); + void* useable_ptr = + allocation_tracker_notify_alloc(allocator_id, dummy_allocation, 4); EXPECT_TRUE(useable_ptr > dummy_allocation); - EXPECT_EQ(4U, allocation_tracker_expect_no_allocations()); // should have registered the allocation - void *freeable_ptr = allocation_tracker_notify_free(allocator_id, useable_ptr); + EXPECT_EQ(4U, allocation_tracker_expect_no_allocations()); // should have + // registered the + // allocation + void* freeable_ptr = + allocation_tracker_notify_free(allocator_id, useable_ptr); EXPECT_EQ(dummy_allocation, freeable_ptr); EXPECT_EQ(0U, allocation_tracker_expect_no_allocations()); diff --git a/osi/test/allocator_test.cc b/osi/test/allocator_test.cc index ca408fac4..9dc6302fc 100644 --- a/osi/test/allocator_test.cc +++ b/osi/test/allocator_test.cc @@ -28,7 +28,7 @@ class AllocatorTest : public AllocationTestHarness {}; TEST_F(AllocatorTest, test_osi_strndup) { char str[] = "IloveBluetooth"; size_t len = strlen(str); - char *copy_str = NULL; + char* copy_str = NULL; // len == 0 copy_str = osi_strndup(str, 0); diff --git a/osi/test/array_test.cc b/osi/test/array_test.cc index 5c1e1b46c..2addadc05 100644 --- a/osi/test/array_test.cc +++ b/osi/test/array_test.cc @@ -7,64 +7,56 @@ class ArrayTest : public AllocationTestHarness {}; TEST_F(ArrayTest, test_new_free_simple) { - array_t *array = array_new(4); + array_t* array = array_new(4); ASSERT_TRUE(array != NULL); array_free(array); } -TEST_F(ArrayTest, test_free_null) { - array_free(NULL); -} +TEST_F(ArrayTest, test_free_null) { array_free(NULL); } TEST_F(ArrayTest, test_invalid_ptr) { - array_t *array = array_new(4); + array_t* array = array_new(4); EXPECT_DEATH(array_ptr(array), ""); array_free(array); } TEST_F(ArrayTest, test_invalid_at) { - array_t *array = array_new(4); + array_t* array = array_new(4); EXPECT_DEATH(array_at(array, 1), ""); array_free(array); } TEST_F(ArrayTest, test_append_value) { - array_t *array = array_new(sizeof(int)); + array_t* array = array_new(sizeof(int)); for (int i = 0; i < 100; ++i) { array_append_value(array, i * i); } for (int i = 0; i < 100; ++i) { - EXPECT_EQ(*(int *)array_at(array, i), i * i); + EXPECT_EQ(*(int*)array_at(array, i), i * i); } array_free(array); } TEST_F(ArrayTest, test_append_ptr) { int items[100]; - array_t *array = array_new(sizeof(int)); + array_t* array = array_new(sizeof(int)); for (int i = 0; i < 100; ++i) { items[i] = i * i; array_append_ptr(array, &items[i]); } for (int i = 0; i < 100; ++i) { - EXPECT_EQ(*(int *)array_at(array, i), i * i); + EXPECT_EQ(*(int*)array_at(array, i), i * i); } array_free(array); } TEST_F(ArrayTest, test_large_element) { char strings[][128] = { - "string 1", - "string 2", - "string 3", - "string 4", - "string 5", - "string 6", - "string 7", - "string 8", + "string 1", "string 2", "string 3", "string 4", + "string 5", "string 6", "string 7", "string 8", }; - array_t *array = array_new(128); + array_t* array = array_new(128); for (int i = 0; i < 100; ++i) { array_append_ptr(array, strings[i % 8]); } diff --git a/osi/test/config_test.cc b/osi/test/config_test.cc index 3348880de..67122225d 100644 --- a/osi/test/config_test.cc +++ b/osi/test/config_test.cc @@ -6,7 +6,7 @@ static const char CONFIG_FILE[] = "/data/local/tmp/config_test.conf"; static const char CONFIG_FILE_CONTENT[] = -" \n\ + " \n\ first_key=value \n\ \n\ # Device ID (DID) configuration \n\ @@ -47,65 +47,66 @@ version = 0x1436 "; class ConfigTest : public AllocationTestHarness { - protected: - virtual void SetUp() { - AllocationTestHarness::SetUp(); - FILE *fp = fopen(CONFIG_FILE, "wt"); - fwrite(CONFIG_FILE_CONTENT, 1, sizeof(CONFIG_FILE_CONTENT), fp); - fclose(fp); - } + protected: + virtual void SetUp() { + AllocationTestHarness::SetUp(); + FILE* fp = fopen(CONFIG_FILE, "wt"); + fwrite(CONFIG_FILE_CONTENT, 1, sizeof(CONFIG_FILE_CONTENT), fp); + fclose(fp); + } }; TEST_F(ConfigTest, config_new_empty) { - config_t *config = config_new_empty(); + config_t* config = config_new_empty(); EXPECT_TRUE(config != NULL); config_free(config); } TEST_F(ConfigTest, config_new_no_file) { - config_t *config = config_new("/meow"); + config_t* config = config_new("/meow"); EXPECT_TRUE(config == NULL); config_free(config); } TEST_F(ConfigTest, config_new) { - config_t *config = config_new(CONFIG_FILE); + config_t* config = config_new(CONFIG_FILE); EXPECT_TRUE(config != NULL); config_free(config); } -TEST_F(ConfigTest, config_free_null) { - config_free(NULL); -} +TEST_F(ConfigTest, config_free_null) { config_free(NULL); } TEST_F(ConfigTest, config_new_clone) { - config_t *config = config_new(CONFIG_FILE); - config_t *clone = config_new_clone(config); + config_t* config = config_new(CONFIG_FILE); + config_t* clone = config_new_clone(config); config_set_string(clone, CONFIG_DEFAULT_SECTION, "first_key", "not_value"); - EXPECT_STRNE(config_get_string(config, CONFIG_DEFAULT_SECTION, "first_key", "one"), - config_get_string(clone, CONFIG_DEFAULT_SECTION, "first_key", "one")); + EXPECT_STRNE( + config_get_string(config, CONFIG_DEFAULT_SECTION, "first_key", "one"), + config_get_string(clone, CONFIG_DEFAULT_SECTION, "first_key", "one")); config_free(config); config_free(clone); } TEST_F(ConfigTest, config_has_section) { - config_t *config = config_new(CONFIG_FILE); + config_t* config = config_new(CONFIG_FILE); EXPECT_TRUE(config_has_section(config, "DID")); config_free(config); } TEST_F(ConfigTest, config_has_key_in_default_section) { - config_t *config = config_new(CONFIG_FILE); + config_t* config = config_new(CONFIG_FILE); EXPECT_TRUE(config_has_key(config, CONFIG_DEFAULT_SECTION, "first_key")); - EXPECT_STREQ(config_get_string(config, CONFIG_DEFAULT_SECTION, "first_key", "meow"), "value"); + EXPECT_STREQ( + config_get_string(config, CONFIG_DEFAULT_SECTION, "first_key", "meow"), + "value"); config_free(config); } TEST_F(ConfigTest, config_has_keys) { - config_t *config = config_new(CONFIG_FILE); + config_t* config = config_new(CONFIG_FILE); EXPECT_TRUE(config_has_key(config, "DID", "recordNumber")); EXPECT_TRUE(config_has_key(config, "DID", "primaryRecord")); EXPECT_TRUE(config_has_key(config, "DID", "productId")); @@ -114,7 +115,7 @@ TEST_F(ConfigTest, config_has_keys) { } TEST_F(ConfigTest, config_no_bad_keys) { - config_t *config = config_new(CONFIG_FILE); + config_t* config = config_new(CONFIG_FILE); EXPECT_FALSE(config_has_key(config, "DID_BAD", "primaryRecord")); EXPECT_FALSE(config_has_key(config, "DID", "primaryRecord_BAD")); EXPECT_FALSE(config_has_key(config, CONFIG_DEFAULT_SECTION, "primaryRecord")); @@ -122,19 +123,19 @@ TEST_F(ConfigTest, config_no_bad_keys) { } TEST_F(ConfigTest, config_get_int_version) { - config_t *config = config_new(CONFIG_FILE); + config_t* config = config_new(CONFIG_FILE); EXPECT_EQ(config_get_int(config, "DID", "version", 0), 0x1436); config_free(config); } TEST_F(ConfigTest, config_get_int_default) { - config_t *config = config_new(CONFIG_FILE); + config_t* config = config_new(CONFIG_FILE); EXPECT_EQ(config_get_int(config, "DID", "primaryRecord", 123), 123); config_free(config); } TEST_F(ConfigTest, config_remove_section) { - config_t *config = config_new(CONFIG_FILE); + config_t* config = config_new(CONFIG_FILE); EXPECT_TRUE(config_remove_section(config, "DID")); EXPECT_FALSE(config_has_section(config, "DID")); EXPECT_FALSE(config_has_key(config, "DID", "productId")); @@ -142,13 +143,13 @@ TEST_F(ConfigTest, config_remove_section) { } TEST_F(ConfigTest, config_remove_section_missing) { - config_t *config = config_new(CONFIG_FILE); + config_t* config = config_new(CONFIG_FILE); EXPECT_FALSE(config_remove_section(config, "not a section")); config_free(config); } TEST_F(ConfigTest, config_remove_key) { - config_t *config = config_new(CONFIG_FILE); + config_t* config = config_new(CONFIG_FILE); EXPECT_EQ(config_get_int(config, "DID", "productId", 999), 0x1200); EXPECT_TRUE(config_remove_key(config, "DID", "productId")); EXPECT_FALSE(config_has_key(config, "DID", "productId")); @@ -156,7 +157,7 @@ TEST_F(ConfigTest, config_remove_key) { } TEST_F(ConfigTest, config_remove_key_missing) { - config_t *config = config_new(CONFIG_FILE); + config_t* config = config_new(CONFIG_FILE); EXPECT_EQ(config_get_int(config, "DID", "productId", 999), 0x1200); EXPECT_TRUE(config_remove_key(config, "DID", "productId")); EXPECT_EQ(config_get_int(config, "DID", "productId", 999), 999); @@ -164,30 +165,30 @@ TEST_F(ConfigTest, config_remove_key_missing) { } TEST_F(ConfigTest, config_section_begin) { - config_t *config = config_new(CONFIG_FILE); - const config_section_node_t *section = config_section_begin(config); + config_t* config = config_new(CONFIG_FILE); + const config_section_node_t* section = config_section_begin(config); EXPECT_TRUE(section != NULL); - const char *section_name = config_section_name(section); + const char* section_name = config_section_name(section); EXPECT_TRUE(section != NULL); EXPECT_TRUE(!strcmp(section_name, CONFIG_DEFAULT_SECTION)); config_free(config); } TEST_F(ConfigTest, config_section_next) { - config_t *config = config_new(CONFIG_FILE); - const config_section_node_t *section = config_section_begin(config); + config_t* config = config_new(CONFIG_FILE); + const config_section_node_t* section = config_section_begin(config); EXPECT_TRUE(section != NULL); section = config_section_next(section); EXPECT_TRUE(section != NULL); - const char *section_name = config_section_name(section); + const char* section_name = config_section_name(section); EXPECT_TRUE(section != NULL); EXPECT_TRUE(!strcmp(section_name, "DID")); config_free(config); } TEST_F(ConfigTest, config_section_end) { - config_t *config = config_new(CONFIG_FILE); - const config_section_node_t * section = config_section_begin(config); + config_t* config = config_new(CONFIG_FILE); + const config_section_node_t* section = config_section_begin(config); section = config_section_next(section); section = config_section_next(section); EXPECT_EQ(section, config_section_end(config)); @@ -195,7 +196,7 @@ TEST_F(ConfigTest, config_section_end) { } TEST_F(ConfigTest, config_save_basic) { - config_t *config = config_new(CONFIG_FILE); + config_t* config = config_new(CONFIG_FILE); EXPECT_TRUE(config_save(config, CONFIG_FILE)); config_free(config); } diff --git a/osi/test/data_dispatcher_test.cc b/osi/test/data_dispatcher_test.cc index 9f00bb4c2..cc7d78de2 100644 --- a/osi/test/data_dispatcher_test.cc +++ b/osi/test/data_dispatcher_test.cc @@ -22,22 +22,23 @@ static char dummy_data_0[42] = "please test your code"; static char dummy_data_1[42] = "testing is good for your sanity"; TEST_F(DataDispatcherTest, test_new_free_simple) { - data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher"); + data_dispatcher_t* dispatcher = data_dispatcher_new("test_dispatcher"); ASSERT_TRUE(dispatcher != NULL); data_dispatcher_free(dispatcher); } TEST_F(DataDispatcherTest, test_dispatch_single_to_nowhere) { - data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher"); - EXPECT_FALSE(data_dispatcher_dispatch(dispatcher, DUMMY_TYPE_0, dummy_data_0)); + data_dispatcher_t* dispatcher = data_dispatcher_new("test_dispatcher"); + EXPECT_FALSE( + data_dispatcher_dispatch(dispatcher, DUMMY_TYPE_0, dummy_data_0)); data_dispatcher_free(dispatcher); } TEST_F(DataDispatcherTest, test_dispatch_single_to_single) { - data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher"); + data_dispatcher_t* dispatcher = data_dispatcher_new("test_dispatcher"); // Register a queue - fixed_queue_t *dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE); + fixed_queue_t* dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE); data_dispatcher_register(dispatcher, DUMMY_TYPE_0, dummy_queue); EXPECT_TRUE(fixed_queue_is_empty(dummy_queue)); @@ -46,7 +47,7 @@ TEST_F(DataDispatcherTest, test_dispatch_single_to_single) { // Did we get it? EXPECT_FALSE(fixed_queue_is_empty(dummy_queue)); - EXPECT_STREQ(dummy_data_0, (char *)fixed_queue_try_dequeue(dummy_queue)); + EXPECT_STREQ(dummy_data_0, (char*)fixed_queue_try_dequeue(dummy_queue)); EXPECT_TRUE(fixed_queue_is_empty(dummy_queue)); fixed_queue_free(dummy_queue, NULL); @@ -54,11 +55,11 @@ TEST_F(DataDispatcherTest, test_dispatch_single_to_single) { } TEST_F(DataDispatcherTest, test_dispatch_single_to_multiple) { - data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher"); + data_dispatcher_t* dispatcher = data_dispatcher_new("test_dispatcher"); // Register two queues - fixed_queue_t *dummy_queue0 = fixed_queue_new(DUMMY_QUEUE_SIZE); - fixed_queue_t *dummy_queue1 = fixed_queue_new(DUMMY_QUEUE_SIZE); + fixed_queue_t* dummy_queue0 = fixed_queue_new(DUMMY_QUEUE_SIZE); + fixed_queue_t* dummy_queue1 = fixed_queue_new(DUMMY_QUEUE_SIZE); data_dispatcher_register(dispatcher, DUMMY_TYPE_0, dummy_queue0); data_dispatcher_register(dispatcher, DUMMY_TYPE_1, dummy_queue1); EXPECT_TRUE(fixed_queue_is_empty(dummy_queue0)); @@ -70,7 +71,7 @@ TEST_F(DataDispatcherTest, test_dispatch_single_to_multiple) { // Did we get it? EXPECT_FALSE(fixed_queue_is_empty(dummy_queue0)); EXPECT_TRUE(fixed_queue_is_empty(dummy_queue1)); - EXPECT_STREQ(dummy_data_0, (char *)fixed_queue_try_dequeue(dummy_queue0)); + EXPECT_STREQ(dummy_data_0, (char*)fixed_queue_try_dequeue(dummy_queue0)); EXPECT_TRUE(fixed_queue_is_empty(dummy_queue0)); fixed_queue_free(dummy_queue0, NULL); @@ -79,11 +80,11 @@ TEST_F(DataDispatcherTest, test_dispatch_single_to_multiple) { } TEST_F(DataDispatcherTest, test_dispatch_single_to_default) { - data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher"); + data_dispatcher_t* dispatcher = data_dispatcher_new("test_dispatcher"); // Register two queues, a default and a typed one - fixed_queue_t *dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE); - fixed_queue_t *default_queue = fixed_queue_new(DUMMY_QUEUE_SIZE); + fixed_queue_t* dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE); + fixed_queue_t* default_queue = fixed_queue_new(DUMMY_QUEUE_SIZE); data_dispatcher_register(dispatcher, DUMMY_TYPE_0, dummy_queue); data_dispatcher_register_default(dispatcher, default_queue); EXPECT_TRUE(fixed_queue_is_empty(dummy_queue)); @@ -95,7 +96,7 @@ TEST_F(DataDispatcherTest, test_dispatch_single_to_default) { // Did we get it? EXPECT_TRUE(fixed_queue_is_empty(dummy_queue)); EXPECT_FALSE(fixed_queue_is_empty(default_queue)); - EXPECT_STREQ(dummy_data_1, (char *)fixed_queue_try_dequeue(default_queue)); + EXPECT_STREQ(dummy_data_1, (char*)fixed_queue_try_dequeue(default_queue)); EXPECT_TRUE(fixed_queue_is_empty(default_queue)); fixed_queue_free(dummy_queue, NULL); @@ -104,10 +105,10 @@ TEST_F(DataDispatcherTest, test_dispatch_single_to_default) { } TEST_F(DataDispatcherTest, test_dispatch_multiple_to_single) { - data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher"); + data_dispatcher_t* dispatcher = data_dispatcher_new("test_dispatcher"); // Register a queue - fixed_queue_t *dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE); + fixed_queue_t* dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE); data_dispatcher_register(dispatcher, DUMMY_TYPE_0, dummy_queue); EXPECT_TRUE(fixed_queue_is_empty(dummy_queue)); @@ -117,9 +118,9 @@ TEST_F(DataDispatcherTest, test_dispatch_multiple_to_single) { // Did we get it? EXPECT_FALSE(fixed_queue_is_empty(dummy_queue)); - EXPECT_STREQ(dummy_data_0, (char *)fixed_queue_try_dequeue(dummy_queue)); + EXPECT_STREQ(dummy_data_0, (char*)fixed_queue_try_dequeue(dummy_queue)); EXPECT_FALSE(fixed_queue_is_empty(dummy_queue)); - EXPECT_STREQ(dummy_data_1, (char *)fixed_queue_try_dequeue(dummy_queue)); + EXPECT_STREQ(dummy_data_1, (char*)fixed_queue_try_dequeue(dummy_queue)); EXPECT_TRUE(fixed_queue_is_empty(dummy_queue)); fixed_queue_free(dummy_queue, NULL); @@ -127,11 +128,11 @@ TEST_F(DataDispatcherTest, test_dispatch_multiple_to_single) { } TEST_F(DataDispatcherTest, test_dispatch_multiple_to_multiple) { - data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher"); + data_dispatcher_t* dispatcher = data_dispatcher_new("test_dispatcher"); // Register two queues - fixed_queue_t *dummy_queue0 = fixed_queue_new(DUMMY_QUEUE_SIZE); - fixed_queue_t *dummy_queue1 = fixed_queue_new(DUMMY_QUEUE_SIZE); + fixed_queue_t* dummy_queue0 = fixed_queue_new(DUMMY_QUEUE_SIZE); + fixed_queue_t* dummy_queue1 = fixed_queue_new(DUMMY_QUEUE_SIZE); data_dispatcher_register(dispatcher, DUMMY_TYPE_0, dummy_queue0); data_dispatcher_register(dispatcher, DUMMY_TYPE_1, dummy_queue1); EXPECT_TRUE(fixed_queue_is_empty(dummy_queue0)); @@ -144,8 +145,8 @@ TEST_F(DataDispatcherTest, test_dispatch_multiple_to_multiple) { // Did we get it? EXPECT_FALSE(fixed_queue_is_empty(dummy_queue0)); EXPECT_FALSE(fixed_queue_is_empty(dummy_queue1)); - EXPECT_STREQ(dummy_data_0, (char *)fixed_queue_try_dequeue(dummy_queue0)); - EXPECT_STREQ(dummy_data_1, (char *)fixed_queue_try_dequeue(dummy_queue1)); + EXPECT_STREQ(dummy_data_0, (char*)fixed_queue_try_dequeue(dummy_queue0)); + EXPECT_STREQ(dummy_data_1, (char*)fixed_queue_try_dequeue(dummy_queue1)); EXPECT_TRUE(fixed_queue_is_empty(dummy_queue0)); EXPECT_TRUE(fixed_queue_is_empty(dummy_queue1)); @@ -155,11 +156,11 @@ TEST_F(DataDispatcherTest, test_dispatch_multiple_to_multiple) { } TEST_F(DataDispatcherTest, test_dispatch_single_to_single_reregistered) { - data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher"); + data_dispatcher_t* dispatcher = data_dispatcher_new("test_dispatcher"); // Register a queue, then reregister - fixed_queue_t *dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE); - fixed_queue_t *dummy_queue_reregistered = fixed_queue_new(DUMMY_QUEUE_SIZE); + fixed_queue_t* dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE); + fixed_queue_t* dummy_queue_reregistered = fixed_queue_new(DUMMY_QUEUE_SIZE); data_dispatcher_register(dispatcher, DUMMY_TYPE_0, dummy_queue); data_dispatcher_register(dispatcher, DUMMY_TYPE_0, dummy_queue_reregistered); EXPECT_TRUE(fixed_queue_is_empty(dummy_queue)); @@ -171,7 +172,8 @@ TEST_F(DataDispatcherTest, test_dispatch_single_to_single_reregistered) { // Did we get it? EXPECT_TRUE(fixed_queue_is_empty(dummy_queue)); EXPECT_FALSE(fixed_queue_is_empty(dummy_queue_reregistered)); - EXPECT_STREQ(dummy_data_0, (char *)fixed_queue_try_dequeue(dummy_queue_reregistered)); + EXPECT_STREQ(dummy_data_0, + (char*)fixed_queue_try_dequeue(dummy_queue_reregistered)); EXPECT_TRUE(fixed_queue_is_empty(dummy_queue_reregistered)); fixed_queue_free(dummy_queue, NULL); @@ -180,15 +182,16 @@ TEST_F(DataDispatcherTest, test_dispatch_single_to_single_reregistered) { } TEST_F(DataDispatcherTest, test_dispatch_single_to_reregistered_null) { - data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher"); + data_dispatcher_t* dispatcher = data_dispatcher_new("test_dispatcher"); // Register a queue - fixed_queue_t *dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE); + fixed_queue_t* dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE); data_dispatcher_register(dispatcher, DUMMY_TYPE_0, dummy_queue); data_dispatcher_register(dispatcher, DUMMY_TYPE_0, NULL); EXPECT_TRUE(fixed_queue_is_empty(dummy_queue)); - EXPECT_FALSE(data_dispatcher_dispatch(dispatcher, DUMMY_TYPE_0, dummy_data_0)); + EXPECT_FALSE( + data_dispatcher_dispatch(dispatcher, DUMMY_TYPE_0, dummy_data_0)); EXPECT_TRUE(fixed_queue_is_empty(dummy_queue)); fixed_queue_free(dummy_queue, NULL); @@ -196,15 +199,16 @@ TEST_F(DataDispatcherTest, test_dispatch_single_to_reregistered_null) { } TEST_F(DataDispatcherTest, test_dispatch_single_to_default_reregistered_null) { - data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher"); + data_dispatcher_t* dispatcher = data_dispatcher_new("test_dispatcher"); // Register a queue - fixed_queue_t *dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE); + fixed_queue_t* dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE); data_dispatcher_register_default(dispatcher, dummy_queue); data_dispatcher_register_default(dispatcher, NULL); EXPECT_TRUE(fixed_queue_is_empty(dummy_queue)); - EXPECT_FALSE(data_dispatcher_dispatch(dispatcher, DUMMY_TYPE_0, dummy_data_0)); + EXPECT_FALSE( + data_dispatcher_dispatch(dispatcher, DUMMY_TYPE_0, dummy_data_0)); EXPECT_TRUE(fixed_queue_is_empty(dummy_queue)); fixed_queue_free(dummy_queue, NULL); @@ -212,19 +216,20 @@ TEST_F(DataDispatcherTest, test_dispatch_single_to_default_reregistered_null) { } TEST_F(DataDispatcherTest, test_dispatch_edge_zero) { - data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher"); + data_dispatcher_t* dispatcher = data_dispatcher_new("test_dispatcher"); // Register a queue - fixed_queue_t *dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE); + fixed_queue_t* dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE); data_dispatcher_register(dispatcher, TYPE_EDGE_CASE_ZERO, dummy_queue); EXPECT_TRUE(fixed_queue_is_empty(dummy_queue)); // Send data to the queue - EXPECT_TRUE(data_dispatcher_dispatch(dispatcher, TYPE_EDGE_CASE_ZERO, dummy_data_0)); + EXPECT_TRUE( + data_dispatcher_dispatch(dispatcher, TYPE_EDGE_CASE_ZERO, dummy_data_0)); // Did we get it? EXPECT_FALSE(fixed_queue_is_empty(dummy_queue)); - EXPECT_STREQ(dummy_data_0, (char *)fixed_queue_try_dequeue(dummy_queue)); + EXPECT_STREQ(dummy_data_0, (char*)fixed_queue_try_dequeue(dummy_queue)); EXPECT_TRUE(fixed_queue_is_empty(dummy_queue)); fixed_queue_free(dummy_queue, NULL); @@ -232,19 +237,20 @@ TEST_F(DataDispatcherTest, test_dispatch_edge_zero) { } TEST_F(DataDispatcherTest, test_dispatch_edge_max) { - data_dispatcher_t *dispatcher = data_dispatcher_new("test_dispatcher"); + data_dispatcher_t* dispatcher = data_dispatcher_new("test_dispatcher"); // Register a queue - fixed_queue_t *dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE); + fixed_queue_t* dummy_queue = fixed_queue_new(DUMMY_QUEUE_SIZE); data_dispatcher_register(dispatcher, TYPE_EDGE_CASE_MAX, dummy_queue); EXPECT_TRUE(fixed_queue_is_empty(dummy_queue)); // Send data to the queue - EXPECT_TRUE(data_dispatcher_dispatch(dispatcher, TYPE_EDGE_CASE_MAX, dummy_data_0)); + EXPECT_TRUE( + data_dispatcher_dispatch(dispatcher, TYPE_EDGE_CASE_MAX, dummy_data_0)); // Did we get it? EXPECT_FALSE(fixed_queue_is_empty(dummy_queue)); - EXPECT_STREQ(dummy_data_0, (char *)fixed_queue_try_dequeue(dummy_queue)); + EXPECT_STREQ(dummy_data_0, (char*)fixed_queue_try_dequeue(dummy_queue)); EXPECT_TRUE(fixed_queue_is_empty(dummy_queue)); fixed_queue_free(dummy_queue, NULL); diff --git a/osi/test/eager_reader_test.cc b/osi/test/eager_reader_test.cc index e69905ef6..58f1bb477 100644 --- a/osi/test/eager_reader_test.cc +++ b/osi/test/eager_reader_test.cc @@ -31,59 +31,61 @@ #define BUFFER_SIZE 32 -static const char *small_data = "white chocolate lindor truffles"; -static const char *large_data = - "Let him make him examine and thoroughly sift everything he reads, and " - "lodge nothing in his fancy upon simple authority and upon trust. " - "Aristotle's principles will then be no more principles to him, than those " - "of Epicurus and the Stoics: let this diversity of opinions be propounded " - "to, and laid before him; he will himself choose, if he be able; if not, " - "he will remain in doubt. " - "" - " \"Che non men the saver, dubbiar m' aggrata.\" " - " [\"I love to doubt, as well as to know.\"--Dante, Inferno, xi. 93] " - "" - "for, if he embrace the opinions of Xenophon and Plato, by his own reason, " - "they will no more be theirs, but become his own. Who follows another, " - "follows nothing, finds nothing, nay, is inquisitive after nothing. " - "" - " \"Non sumus sub rege; sibi quisque se vindicet.\" " - " [\"We are under no king; let each vindicate himself.\" --Seneca, Ep.,33] " - "" - "let him, at least, know that he knows. it will be necessary that he " - "imbibe their knowledge, not that he be corrupted with their precepts; " - "and no matter if he forget where he had his learning, provided he know " - "how to apply it to his own use. truth and reason are common to every " - "one, and are no more his who spake them first, than his who speaks them " - "after: 'tis no more according to plato, than according to me, since both " - "he and i equally see and understand them. bees cull their several sweets " - "from this flower and that blossom, here and there where they find them, " - "but themselves afterwards make the honey, which is all and purely their " - "own, and no more thyme and marjoram: so the several fragments he borrows " - "from others, he will transform and shuffle together to compile a work " - "that shall be absolutely his own; that is to say, his judgment: " - "his instruction, labour and study, tend to nothing else but to form that. "; - -static semaphore_t *done; +static const char* small_data = "white chocolate lindor truffles"; +static const char* large_data = + "Let him make him examine and thoroughly sift everything he reads, and " + "lodge nothing in his fancy upon simple authority and upon trust. " + "Aristotle's principles will then be no more principles to him, than those " + "of Epicurus and the Stoics: let this diversity of opinions be propounded " + "to, and laid before him; he will himself choose, if he be able; if not, " + "he will remain in doubt. " + "" + " \"Che non men the saver, dubbiar m' aggrata.\" " + " [\"I love to doubt, as well as to know.\"--Dante, Inferno, xi. 93] " + "" + "for, if he embrace the opinions of Xenophon and Plato, by his own reason, " + "they will no more be theirs, but become his own. Who follows another, " + "follows nothing, finds nothing, nay, is inquisitive after nothing. " + "" + " \"Non sumus sub rege; sibi quisque se vindicet.\" " + " [\"We are under no king; let each vindicate himself.\" --Seneca, " + "Ep.,33] " + "" + "let him, at least, know that he knows. it will be necessary that he " + "imbibe their knowledge, not that he be corrupted with their precepts; " + "and no matter if he forget where he had his learning, provided he know " + "how to apply it to his own use. truth and reason are common to every " + "one, and are no more his who spake them first, than his who speaks them " + "after: 'tis no more according to plato, than according to me, since both " + "he and i equally see and understand them. bees cull their several sweets " + "from this flower and that blossom, here and there where they find them, " + "but themselves afterwards make the honey, which is all and purely their " + "own, and no more thyme and marjoram: so the several fragments he borrows " + "from others, he will transform and shuffle together to compile a work " + "that shall be absolutely his own; that is to say, his judgment: " + "his instruction, labour and study, tend to nothing else but to form " + "that. "; + +static semaphore_t* done; class EagerReaderTest : public AllocationTestHarness { - protected: - virtual void SetUp() { - AllocationTestHarness::SetUp(); - pipe(pipefd); - done = semaphore_new(0); - } + protected: + virtual void SetUp() { + AllocationTestHarness::SetUp(); + pipe(pipefd); + done = semaphore_new(0); + } - virtual void TearDown() { - semaphore_free(done); - AllocationTestHarness::TearDown(); - } + virtual void TearDown() { + semaphore_free(done); + AllocationTestHarness::TearDown(); + } - int pipefd[2]; + int pipefd[2]; }; -static void expect_data(eager_reader_t *reader, void *context) { - char *data = (char *)context; +static void expect_data(eager_reader_t* reader, void* context) { + char* data = (char*)context; int length = strlen(data); for (int i = 0; i < length; i++) { @@ -95,8 +97,8 @@ static void expect_data(eager_reader_t *reader, void *context) { semaphore_post(done); } -static void expect_data_multibyte(eager_reader_t *reader, void *context) { - char *data = (char *)context; +static void expect_data_multibyte(eager_reader_t* reader, void* context) { + char* data = (char*)context; size_t length = strlen(data); for (size_t i = 0; i < length;) { @@ -113,16 +115,19 @@ static void expect_data_multibyte(eager_reader_t *reader, void *context) { } TEST_F(EagerReaderTest, test_new_free_simple) { - eager_reader_t *reader = eager_reader_new(pipefd[0], &allocator_malloc, BUFFER_SIZE, SIZE_MAX, "test_thread"); + eager_reader_t* reader = eager_reader_new( + pipefd[0], &allocator_malloc, BUFFER_SIZE, SIZE_MAX, "test_thread"); ASSERT_TRUE(reader != NULL); eager_reader_free(reader); } TEST_F(EagerReaderTest, test_small_data) { - eager_reader_t *reader = eager_reader_new(pipefd[0], &allocator_malloc, BUFFER_SIZE, SIZE_MAX, "test_thread"); + eager_reader_t* reader = eager_reader_new( + pipefd[0], &allocator_malloc, BUFFER_SIZE, SIZE_MAX, "test_thread"); - thread_t *read_thread = thread_new("read_thread"); - eager_reader_register(reader, thread_get_reactor(read_thread), expect_data, (void *)small_data); + thread_t* read_thread = thread_new("read_thread"); + eager_reader_register(reader, thread_get_reactor(read_thread), expect_data, + (void*)small_data); write(pipefd[1], small_data, strlen(small_data)); @@ -132,10 +137,12 @@ TEST_F(EagerReaderTest, test_small_data) { } TEST_F(EagerReaderTest, test_large_data_multibyte) { - eager_reader_t *reader = eager_reader_new(pipefd[0], &allocator_malloc, BUFFER_SIZE, SIZE_MAX, "test_thread"); + eager_reader_t* reader = eager_reader_new( + pipefd[0], &allocator_malloc, BUFFER_SIZE, SIZE_MAX, "test_thread"); - thread_t *read_thread = thread_new("read_thread"); - eager_reader_register(reader, thread_get_reactor(read_thread), expect_data_multibyte, (void *)large_data); + thread_t* read_thread = thread_new("read_thread"); + eager_reader_register(reader, thread_get_reactor(read_thread), + expect_data_multibyte, (void*)large_data); write(pipefd[1], large_data, strlen(large_data)); diff --git a/osi/test/fixed_queue_test.cc b/osi/test/fixed_queue_test.cc index 030241b40..56917efdf 100644 --- a/osi/test/fixed_queue_test.cc +++ b/osi/test/fixed_queue_test.cc @@ -11,18 +11,17 @@ #include "osi/include/thread.h" static const size_t TEST_QUEUE_SIZE = 10; -static const char *DUMMY_DATA_STRING = "Dummy data string"; -static const char *DUMMY_DATA_STRING1 = "Dummy data string1"; -static const char *DUMMY_DATA_STRING2 = "Dummy data string2"; -static const char *DUMMY_DATA_STRING3 = "Dummy data string3"; -static future_t *received_message_future = NULL; +static const char* DUMMY_DATA_STRING = "Dummy data string"; +static const char* DUMMY_DATA_STRING1 = "Dummy data string1"; +static const char* DUMMY_DATA_STRING2 = "Dummy data string2"; +static const char* DUMMY_DATA_STRING3 = "Dummy data string3"; +static future_t* received_message_future = NULL; static int test_queue_entry_free_counter = 0; // Test whether a file descriptor |fd| is readable. // Return true if the file descriptor is readable, otherwise false. -static bool is_fd_readable(int fd) -{ +static bool is_fd_readable(int fd) { fd_set rfds; struct timeval tv; @@ -38,17 +37,13 @@ static bool is_fd_readable(int fd) } // Function for performing dequeue operations from the queue when is ready -static void -fixed_queue_ready(fixed_queue_t *queue, UNUSED_ATTR void *context) -{ - void *msg = fixed_queue_try_dequeue(queue); +static void fixed_queue_ready(fixed_queue_t* queue, UNUSED_ATTR void* context) { + void* msg = fixed_queue_try_dequeue(queue); EXPECT_TRUE(msg != NULL); future_ready(received_message_future, msg); } -static void -test_queue_entry_free_cb(void *data) -{ +static void test_queue_entry_free_cb(void* data) { // Don't free the data, because we are testing only whether the callback // is called. test_queue_entry_free_counter++; @@ -57,7 +52,7 @@ test_queue_entry_free_cb(void *data) class FixedQueueTest : public AllocationTestHarness {}; TEST_F(FixedQueueTest, test_fixed_queue_new_free) { - fixed_queue_t *queue; + fixed_queue_t* queue; // Test a corner case: queue of size 0 queue = fixed_queue_new(0); @@ -85,7 +80,7 @@ TEST_F(FixedQueueTest, test_fixed_queue_new_free) { } TEST_F(FixedQueueTest, test_fixed_queue_flush) { - fixed_queue_t *queue; + fixed_queue_t* queue; // Test a corner case: queue of size 0 and no callback to free entries queue = fixed_queue_new(0); @@ -104,9 +99,9 @@ TEST_F(FixedQueueTest, test_fixed_queue_flush) { // Test a queue of some size and no callback to free entries queue = fixed_queue_new(TEST_QUEUE_SIZE); EXPECT_TRUE(queue != NULL); - fixed_queue_try_enqueue(queue, (void *)DUMMY_DATA_STRING1); - fixed_queue_try_enqueue(queue, (void *)DUMMY_DATA_STRING2); - fixed_queue_try_enqueue(queue, (void *)DUMMY_DATA_STRING3); + fixed_queue_try_enqueue(queue, (void*)DUMMY_DATA_STRING1); + fixed_queue_try_enqueue(queue, (void*)DUMMY_DATA_STRING2); + fixed_queue_try_enqueue(queue, (void*)DUMMY_DATA_STRING3); EXPECT_FALSE(fixed_queue_is_empty(queue)); fixed_queue_flush(queue, NULL); EXPECT_TRUE(fixed_queue_is_empty(queue)); @@ -116,9 +111,9 @@ TEST_F(FixedQueueTest, test_fixed_queue_flush) { test_queue_entry_free_counter = 0; queue = fixed_queue_new(TEST_QUEUE_SIZE); EXPECT_TRUE(queue != NULL); - fixed_queue_try_enqueue(queue, (void *)DUMMY_DATA_STRING1); - fixed_queue_try_enqueue(queue, (void *)DUMMY_DATA_STRING2); - fixed_queue_try_enqueue(queue, (void *)DUMMY_DATA_STRING3); + fixed_queue_try_enqueue(queue, (void*)DUMMY_DATA_STRING1); + fixed_queue_try_enqueue(queue, (void*)DUMMY_DATA_STRING2); + fixed_queue_try_enqueue(queue, (void*)DUMMY_DATA_STRING3); EXPECT_FALSE(fixed_queue_is_empty(queue)); fixed_queue_flush(queue, test_queue_entry_free_cb); EXPECT_TRUE(test_queue_entry_free_counter == 3); @@ -127,7 +122,7 @@ TEST_F(FixedQueueTest, test_fixed_queue_flush) { } TEST_F(FixedQueueTest, test_fixed_queue_is_empty) { - fixed_queue_t *queue; + fixed_queue_t* queue; // Test a NULL queue EXPECT_TRUE(fixed_queue_is_empty(NULL)); @@ -138,7 +133,7 @@ TEST_F(FixedQueueTest, test_fixed_queue_is_empty) { EXPECT_TRUE(fixed_queue_is_empty(queue)); // Test a non-empty queue - fixed_queue_try_enqueue(queue, (void *)DUMMY_DATA_STRING); + fixed_queue_try_enqueue(queue, (void*)DUMMY_DATA_STRING); EXPECT_FALSE(fixed_queue_is_empty(queue)); // Test an empty dequeued queue @@ -149,7 +144,7 @@ TEST_F(FixedQueueTest, test_fixed_queue_is_empty) { } TEST_F(FixedQueueTest, test_fixed_queue_length) { - fixed_queue_t *queue; + fixed_queue_t* queue; // Test a NULL queue EXPECT_EQ((size_t)0, fixed_queue_length(NULL)); @@ -160,7 +155,7 @@ TEST_F(FixedQueueTest, test_fixed_queue_length) { EXPECT_EQ((size_t)0, fixed_queue_length(queue)); // Test a non-empty queue - fixed_queue_try_enqueue(queue, (void *)DUMMY_DATA_STRING); + fixed_queue_try_enqueue(queue, (void*)DUMMY_DATA_STRING); EXPECT_EQ((size_t)1, fixed_queue_length(queue)); // Test an empty dequeued queue @@ -171,7 +166,7 @@ TEST_F(FixedQueueTest, test_fixed_queue_length) { } TEST_F(FixedQueueTest, test_fixed_queue_capacity) { - fixed_queue_t *queue; + fixed_queue_t* queue; // Test a corner case: queue of size 0 queue = fixed_queue_new(0); @@ -199,27 +194,27 @@ TEST_F(FixedQueueTest, test_fixed_queue_capacity) { } TEST_F(FixedQueueTest, test_fixed_queue_enqueue_dequeue) { - fixed_queue_t *queue = fixed_queue_new(TEST_QUEUE_SIZE); + fixed_queue_t* queue = fixed_queue_new(TEST_QUEUE_SIZE); ASSERT_TRUE(queue != NULL); // Test blocking enqueue and blocking dequeue - fixed_queue_enqueue(queue, (void *)DUMMY_DATA_STRING); + fixed_queue_enqueue(queue, (void*)DUMMY_DATA_STRING); EXPECT_EQ((size_t)1, fixed_queue_length(queue)); EXPECT_EQ(DUMMY_DATA_STRING, fixed_queue_dequeue(queue)); EXPECT_EQ((size_t)0, fixed_queue_length(queue)); // Test non-blocking enqueue and non-blocking dequeue - EXPECT_TRUE(fixed_queue_try_enqueue(queue, (void *)DUMMY_DATA_STRING)); + EXPECT_TRUE(fixed_queue_try_enqueue(queue, (void*)DUMMY_DATA_STRING)); EXPECT_EQ((size_t)1, fixed_queue_length(queue)); EXPECT_EQ(DUMMY_DATA_STRING, fixed_queue_try_dequeue(queue)); EXPECT_EQ((size_t)0, fixed_queue_length(queue)); // Test non-blocking enqueue beyond queue capacity for (size_t i = 0; i < TEST_QUEUE_SIZE; i++) { - EXPECT_TRUE(fixed_queue_try_enqueue(queue, (void *)DUMMY_DATA_STRING)); + EXPECT_TRUE(fixed_queue_try_enqueue(queue, (void*)DUMMY_DATA_STRING)); } // The next enqueue operation is beyond the queue capacity, so it should fail - EXPECT_FALSE(fixed_queue_try_enqueue(queue, (void *)DUMMY_DATA_STRING)); + EXPECT_FALSE(fixed_queue_try_enqueue(queue, (void*)DUMMY_DATA_STRING)); // Test non-blocking dequeue from a queue that is full to max capacity for (size_t i = 0; i < TEST_QUEUE_SIZE; i++) { @@ -236,7 +231,7 @@ TEST_F(FixedQueueTest, test_fixed_queue_enqueue_dequeue) { } TEST_F(FixedQueueTest, test_fixed_queue_try_peek_first_last) { - fixed_queue_t *queue = fixed_queue_new(TEST_QUEUE_SIZE); + fixed_queue_t* queue = fixed_queue_new(TEST_QUEUE_SIZE); ASSERT_TRUE(queue != NULL); // Test peek first/last from a NULL queue @@ -248,17 +243,17 @@ TEST_F(FixedQueueTest, test_fixed_queue_try_peek_first_last) { EXPECT_EQ(NULL, fixed_queue_try_peek_last(queue)); // Test peek first/last from a queue with one element - fixed_queue_enqueue(queue, (void *)DUMMY_DATA_STRING1); + fixed_queue_enqueue(queue, (void*)DUMMY_DATA_STRING1); EXPECT_EQ(DUMMY_DATA_STRING1, fixed_queue_try_peek_first(queue)); EXPECT_EQ(DUMMY_DATA_STRING1, fixed_queue_try_peek_last(queue)); // Test peek first/last from a queue with two elements - fixed_queue_enqueue(queue, (void *)DUMMY_DATA_STRING2); + fixed_queue_enqueue(queue, (void*)DUMMY_DATA_STRING2); EXPECT_EQ(DUMMY_DATA_STRING1, fixed_queue_try_peek_first(queue)); EXPECT_EQ(DUMMY_DATA_STRING2, fixed_queue_try_peek_last(queue)); // Test peek first/last from a queue with three elements - fixed_queue_enqueue(queue, (void *)DUMMY_DATA_STRING3); + fixed_queue_enqueue(queue, (void*)DUMMY_DATA_STRING3); EXPECT_EQ(DUMMY_DATA_STRING1, fixed_queue_try_peek_first(queue)); EXPECT_EQ(DUMMY_DATA_STRING3, fixed_queue_try_peek_last(queue)); @@ -266,38 +261,38 @@ TEST_F(FixedQueueTest, test_fixed_queue_try_peek_first_last) { } TEST_F(FixedQueueTest, test_fixed_queue_try_remove_from_queue) { - fixed_queue_t *queue = fixed_queue_new(TEST_QUEUE_SIZE); + fixed_queue_t* queue = fixed_queue_new(TEST_QUEUE_SIZE); ASSERT_TRUE(queue != NULL); // Test removing from a NULL queue - EXPECT_EQ(NULL, fixed_queue_try_remove_from_queue(NULL, - (void *)DUMMY_DATA_STRING)); + EXPECT_EQ(NULL, + fixed_queue_try_remove_from_queue(NULL, (void*)DUMMY_DATA_STRING)); // Test removing from an empty queue - EXPECT_EQ(NULL, fixed_queue_try_remove_from_queue(queue, - (void *)DUMMY_DATA_STRING)); + EXPECT_EQ(NULL, + fixed_queue_try_remove_from_queue(queue, (void*)DUMMY_DATA_STRING)); // Test removing a queued string from a queue - fixed_queue_enqueue(queue, (void *)DUMMY_DATA_STRING1); - fixed_queue_enqueue(queue, (void *)DUMMY_DATA_STRING2); - fixed_queue_enqueue(queue, (void *)DUMMY_DATA_STRING3); + fixed_queue_enqueue(queue, (void*)DUMMY_DATA_STRING1); + fixed_queue_enqueue(queue, (void*)DUMMY_DATA_STRING2); + fixed_queue_enqueue(queue, (void*)DUMMY_DATA_STRING3); EXPECT_EQ((size_t)3, fixed_queue_length(queue)); - EXPECT_EQ(DUMMY_DATA_STRING2, fixed_queue_try_remove_from_queue(queue, - (void *)DUMMY_DATA_STRING2)); + EXPECT_EQ(DUMMY_DATA_STRING2, fixed_queue_try_remove_from_queue( + queue, (void*)DUMMY_DATA_STRING2)); EXPECT_EQ((size_t)2, fixed_queue_length(queue)); // Removing again should fail EXPECT_EQ(NULL, fixed_queue_try_remove_from_queue(queue, - (void *)DUMMY_DATA_STRING2)); + (void*)DUMMY_DATA_STRING2)); // Test removing a non-queued string from a queue - EXPECT_EQ(NULL, fixed_queue_try_remove_from_queue(queue, - (void *)DUMMY_DATA_STRING)); + EXPECT_EQ(NULL, + fixed_queue_try_remove_from_queue(queue, (void*)DUMMY_DATA_STRING)); fixed_queue_free(queue, NULL); } TEST_F(FixedQueueTest, test_fixed_queue_get_enqueue_dequeue_fd) { - fixed_queue_t *queue = fixed_queue_new(TEST_QUEUE_SIZE); + fixed_queue_t* queue = fixed_queue_new(TEST_QUEUE_SIZE); ASSERT_TRUE(queue != NULL); // Test validity of enqueue and dequeue file descriptors @@ -315,7 +310,7 @@ TEST_F(FixedQueueTest, test_fixed_queue_get_enqueue_dequeue_fd) { // Test the file descriptors of a non-empty queue // Both the enqueue_fd and dequeue_fd should be readable - fixed_queue_enqueue(queue, (void *)DUMMY_DATA_STRING); + fixed_queue_enqueue(queue, (void*)DUMMY_DATA_STRING); EXPECT_TRUE(is_fd_readable(enqueue_fd)); EXPECT_TRUE(is_fd_readable(dequeue_fd)); fixed_queue_dequeue(queue); @@ -323,7 +318,7 @@ TEST_F(FixedQueueTest, test_fixed_queue_get_enqueue_dequeue_fd) { // Test the file descriptors of a full queue // Only the dequeue_fd should be readable for (size_t i = 0; i < TEST_QUEUE_SIZE; i++) { - EXPECT_TRUE(fixed_queue_try_enqueue(queue, (void *)DUMMY_DATA_STRING)); + EXPECT_TRUE(fixed_queue_try_enqueue(queue, (void*)DUMMY_DATA_STRING)); } EXPECT_FALSE(is_fd_readable(enqueue_fd)); EXPECT_TRUE(is_fd_readable(dequeue_fd)); @@ -332,23 +327,21 @@ TEST_F(FixedQueueTest, test_fixed_queue_get_enqueue_dequeue_fd) { } TEST_F(FixedQueueTest, test_fixed_queue_register_dequeue) { - fixed_queue_t *queue = fixed_queue_new(TEST_QUEUE_SIZE); + fixed_queue_t* queue = fixed_queue_new(TEST_QUEUE_SIZE); ASSERT_TRUE(queue != NULL); received_message_future = future_new(); ASSERT_TRUE(received_message_future != NULL); - thread_t *worker_thread = thread_new("test_fixed_queue_worker_thread"); + thread_t* worker_thread = thread_new("test_fixed_queue_worker_thread"); ASSERT_TRUE(worker_thread != NULL); - fixed_queue_register_dequeue(queue, - thread_get_reactor(worker_thread), - fixed_queue_ready, - NULL); + fixed_queue_register_dequeue(queue, thread_get_reactor(worker_thread), + fixed_queue_ready, NULL); // Add a message to the queue, and expect to receive it - fixed_queue_enqueue(queue, (void *)DUMMY_DATA_STRING); - const char *msg = (const char *)future_await(received_message_future); + fixed_queue_enqueue(queue, (void*)DUMMY_DATA_STRING); + const char* msg = (const char*)future_await(received_message_future); EXPECT_EQ(DUMMY_DATA_STRING, msg); fixed_queue_unregister_dequeue(queue); diff --git a/osi/test/future_test.cc b/osi/test/future_test.cc index 9da8c82da..fe5e7fd54 100644 --- a/osi/test/future_test.cc +++ b/osi/test/future_test.cc @@ -24,20 +24,21 @@ #include "osi/include/osi.h" #include "osi/include/thread.h" -static const char *pass_back_data0 = "fancy a sandwich? it's a fancy sandwich"; -static const char *pass_back_data1 = "what kind of ice cream truck plays the worst christmas song of all time?"; +static const char* pass_back_data0 = "fancy a sandwich? it's a fancy sandwich"; +static const char* pass_back_data1 = + "what kind of ice cream truck plays the worst christmas song of all time?"; class FutureTest : public AllocationTestHarness {}; -static void post_to_future(void *context) { - future_ready((future_t *)context, (void *)pass_back_data0); +static void post_to_future(void* context) { + future_ready((future_t*)context, (void*)pass_back_data0); } TEST_F(FutureTest, test_future_non_immediate) { - future_t *future = future_new(); + future_t* future = future_new(); ASSERT_TRUE(future != NULL); - thread_t *worker_thread = thread_new("worker thread"); + thread_t* worker_thread = thread_new("worker thread"); thread_post(worker_thread, post_to_future, future); EXPECT_EQ(pass_back_data0, future_await(future)); @@ -46,7 +47,7 @@ TEST_F(FutureTest, test_future_non_immediate) { } TEST_F(FutureTest, test_future_immediate) { - future_t *future = future_new_immediate((void *)pass_back_data1); + future_t* future = future_new_immediate((void*)pass_back_data1); ASSERT_TRUE(future != NULL); EXPECT_EQ(pass_back_data1, future_await(future)); } diff --git a/osi/test/hash_map_utils_test.cc b/osi/test/hash_map_utils_test.cc index 987a32869..0e483e500 100644 --- a/osi/test/hash_map_utils_test.cc +++ b/osi/test/hash_map_utils_test.cc @@ -27,9 +27,7 @@ class HashMapUtilsTest : public AllocationTestHarness { protected: - virtual void SetUp() { - AllocationTestHarness::SetUp(); - } + virtual void SetUp() { AllocationTestHarness::SetUp(); } virtual void TearDown() { map.clear(); AllocationTestHarness::TearDown(); diff --git a/osi/test/list_test.cc b/osi/test/list_test.cc index af28b8daa..a4d1b6f2f 100644 --- a/osi/test/list_test.cc +++ b/osi/test/list_test.cc @@ -8,7 +8,7 @@ class ListTest : public AllocationTestHarness {}; TEST_F(ListTest, test_new_free_simple) { - list_t *list = list_new(NULL); + list_t* list = list_new(NULL); ASSERT_TRUE(list != NULL); list_free(list); } @@ -19,19 +19,19 @@ TEST_F(ListTest, test_free_null) { } TEST_F(ListTest, test_empty_list_is_empty) { - list_t *list = list_new(NULL); + list_t* list = list_new(NULL); EXPECT_TRUE(list_is_empty(list)); list_free(list); } TEST_F(ListTest, test_empty_list_has_no_length) { - list_t *list = list_new(NULL); + list_t* list = list_new(NULL); EXPECT_EQ(list_length(list), 0U); list_free(list); } TEST_F(ListTest, test_simple_list_prepend) { - list_t *list = list_new(NULL); + list_t* list = list_new(NULL); EXPECT_TRUE(list_prepend(list, &list)); EXPECT_FALSE(list_is_empty(list)); EXPECT_EQ(list_length(list), 1U); @@ -39,7 +39,7 @@ TEST_F(ListTest, test_simple_list_prepend) { } TEST_F(ListTest, test_simple_list_append) { - list_t *list = list_new(NULL); + list_t* list = list_new(NULL); EXPECT_TRUE(list_append(list, &list)); EXPECT_FALSE(list_is_empty(list)); EXPECT_EQ(list_length(list), 1U); @@ -47,17 +47,17 @@ TEST_F(ListTest, test_simple_list_append) { } TEST_F(ListTest, test_list_remove_found) { - list_t *list = list_new(NULL); + list_t* list = list_new(NULL); list_append(list, &list); EXPECT_TRUE(list_remove(list, &list)); EXPECT_TRUE(list_is_empty(list)); - EXPECT_EQ(list_length(list), 0U); + EXPECT_EQ(list_length(list), 0U); list_free(list); } TEST_F(ListTest, test_list_remove_not_found) { int x; - list_t *list = list_new(NULL); + list_t* list = list_new(NULL); list_append(list, &list); EXPECT_FALSE(list_remove(list, &x)); EXPECT_FALSE(list_is_empty(list)); @@ -66,11 +66,10 @@ TEST_F(ListTest, test_list_remove_not_found) { } TEST_F(ListTest, test_list_front) { - int x[] = { 1, 2, 3, 4, 5 }; - list_t *list = list_new(NULL); + int x[] = {1, 2, 3, 4, 5}; + list_t* list = list_new(NULL); - for (size_t i = 0; i < ARRAY_SIZE(x); ++i) - list_append(list, &x[i]); + for (size_t i = 0; i < ARRAY_SIZE(x); ++i) list_append(list, &x[i]); EXPECT_EQ(list_front(list), &x[0]); @@ -78,11 +77,10 @@ TEST_F(ListTest, test_list_front) { } TEST_F(ListTest, test_list_back) { - int x[] = { 1, 2, 3, 4, 5 }; - list_t *list = list_new(NULL); + int x[] = {1, 2, 3, 4, 5}; + list_t* list = list_new(NULL); - for (size_t i = 0; i < ARRAY_SIZE(x); ++i) - list_append(list, &x[i]); + for (size_t i = 0; i < ARRAY_SIZE(x); ++i) list_append(list, &x[i]); EXPECT_EQ(list_back(list), &x[ARRAY_SIZE(x) - 1]); @@ -90,11 +88,10 @@ TEST_F(ListTest, test_list_back) { } TEST_F(ListTest, test_list_clear) { - int x[] = { 1, 2, 3, 4, 5 }; - list_t *list = list_new(NULL); + int x[] = {1, 2, 3, 4, 5}; + list_t* list = list_new(NULL); - for (size_t i = 0; i < ARRAY_SIZE(x); ++i) - list_append(list, &x[i]); + for (size_t i = 0; i < ARRAY_SIZE(x); ++i) list_append(list, &x[i]); list_clear(list); EXPECT_TRUE(list_is_empty(list)); @@ -104,74 +101,73 @@ TEST_F(ListTest, test_list_clear) { } TEST_F(ListTest, test_list_append_multiple) { - int x[] = { 1, 2, 3, 4, 5 }; - list_t *list = list_new(NULL); + int x[] = {1, 2, 3, 4, 5}; + list_t* list = list_new(NULL); - for (size_t i = 0; i < ARRAY_SIZE(x); ++i) - list_append(list, &x[i]); + for (size_t i = 0; i < ARRAY_SIZE(x); ++i) list_append(list, &x[i]); int i = 0; - for (const list_node_t *node = list_begin(list); node != list_end(list); node = list_next(node), ++i) + for (const list_node_t *node = list_begin(list); node != list_end(list); + node = list_next(node), ++i) EXPECT_EQ(list_node(node), &x[i]); list_free(list); } TEST_F(ListTest, test_list_prepend_multiple) { - int x[] = { 1, 2, 3, 4, 5 }; - list_t *list = list_new(NULL); + int x[] = {1, 2, 3, 4, 5}; + list_t* list = list_new(NULL); - for (size_t i = 0; i < ARRAY_SIZE(x); ++i) - list_prepend(list, &x[i]); + for (size_t i = 0; i < ARRAY_SIZE(x); ++i) list_prepend(list, &x[i]); int i = ARRAY_SIZE(x) - 1; - for (const list_node_t *node = list_begin(list); node != list_end(list); node = list_next(node), --i) + for (const list_node_t *node = list_begin(list); node != list_end(list); + node = list_next(node), --i) EXPECT_EQ(list_node(node), &x[i]); list_free(list); } TEST_F(ListTest, test_list_begin_empty_list) { - list_t *list = list_new(NULL); + list_t* list = list_new(NULL); EXPECT_EQ(list_begin(list), list_end(list)); list_free(list); } TEST_F(ListTest, test_list_next) { - list_t *list = list_new(NULL); + list_t* list = list_new(NULL); list_append(list, &list); EXPECT_NE(list_begin(list), list_end(list)); EXPECT_EQ(list_next(list_begin(list)), list_end(list)); list_free(list); } -static bool list_callback_sum(void *data, void *context) { +static bool list_callback_sum(void* data, void* context) { assert(data); assert(context); - int *sum = (int *)context; - int *value = (int *)data; + int* sum = (int*)context; + int* value = (int*)data; *sum += *value; return true; } -static bool list_callback_find_int(void *data, void *context) { +static bool list_callback_find_int(void* data, void* context) { assert(data); assert(context); - return (*(int *)data != *(int *)context); + return (*(int*)data != *(int*)context); } TEST_F(ListTest, test_list_foreach_full) { - list_t *list = list_new(NULL); + list_t* list = list_new(NULL); // Fill in test data - int x[] = { 1, 2, 3, 4, 5 }; - for (size_t i = 0; i < ARRAY_SIZE(x); ++i) - list_append(list, &x[i]); + int x[] = {1, 2, 3, 4, 5}; + for (size_t i = 0; i < ARRAY_SIZE(x); ++i) list_append(list, &x[i]); EXPECT_EQ(list_length(list), (size_t)5); // Test complete iteration int sum = 0; - list_node_t *rc = list_foreach(list, list_callback_sum, &sum); + list_node_t* rc = list_foreach(list, list_callback_sum, &sum); EXPECT_EQ(sum, 15); EXPECT_TRUE(rc == NULL); @@ -179,31 +175,30 @@ TEST_F(ListTest, test_list_foreach_full) { } TEST_F(ListTest, test_list_foreach_partial) { - list_t *list = list_new(NULL); + list_t* list = list_new(NULL); // Fill in test data - int x[] = { 1, 2, 3, 4, 5 }; - for (size_t i = 0; i < ARRAY_SIZE(x); ++i) - list_append(list, &x[i]); + int x[] = {1, 2, 3, 4, 5}; + for (size_t i = 0; i < ARRAY_SIZE(x); ++i) list_append(list, &x[i]); EXPECT_EQ(list_length(list), (size_t)5); // Test partial iteration int find = 4; - list_node_t *rc = list_foreach(list, list_callback_find_int, &find); + list_node_t* rc = list_foreach(list, list_callback_find_int, &find); EXPECT_TRUE(rc != NULL); - int *rc_val = (int *)list_node(rc); + int* rc_val = (int*)list_node(rc); EXPECT_TRUE(*rc_val == 4); find = 1; rc = list_foreach(list, list_callback_find_int, &find); EXPECT_TRUE(rc != NULL); - rc_val = (int *)list_node(rc); + rc_val = (int*)list_node(rc); EXPECT_TRUE(*rc_val == 1); find = 5; rc = list_foreach(list, list_callback_find_int, &find); EXPECT_TRUE(rc != NULL); - rc_val = (int *)list_node(rc); + rc_val = (int*)list_node(rc); EXPECT_TRUE(*rc_val == 5); find = 0; diff --git a/osi/test/reactor_test.cc b/osi/test/reactor_test.cc index 4f8a0bd56..016422732 100644 --- a/osi/test/reactor_test.cc +++ b/osi/test/reactor_test.cc @@ -13,8 +13,8 @@ class ReactorTest : public AllocationTestHarness {}; static pthread_t thread; static volatile bool thread_running; -static void *reactor_thread(void *ptr) { - reactor_t *reactor = (reactor_t *)ptr; +static void* reactor_thread(void* ptr) { + reactor_t* reactor = (reactor_t*)ptr; thread_running = true; reactor_start(reactor); @@ -23,34 +23,30 @@ static void *reactor_thread(void *ptr) { return NULL; } -static void spawn_reactor_thread(reactor_t *reactor) { +static void spawn_reactor_thread(reactor_t* reactor) { int ret = pthread_create(&thread, NULL, reactor_thread, reactor); EXPECT_EQ(ret, 0); } -static void join_reactor_thread() { - pthread_join(thread, NULL); -} +static void join_reactor_thread() { pthread_join(thread, NULL); } TEST_F(ReactorTest, reactor_new) { - reactor_t *reactor = reactor_new(); + reactor_t* reactor = reactor_new(); EXPECT_TRUE(reactor != NULL); reactor_free(reactor); } -TEST_F(ReactorTest, reactor_free_null) { - reactor_free(NULL); -} +TEST_F(ReactorTest, reactor_free_null) { reactor_free(NULL); } TEST_F(ReactorTest, reactor_stop_start) { - reactor_t *reactor = reactor_new(); + reactor_t* reactor = reactor_new(); reactor_stop(reactor); reactor_start(reactor); reactor_free(reactor); } TEST_F(ReactorTest, reactor_repeated_stop_start) { - reactor_t *reactor = reactor_new(); + reactor_t* reactor = reactor_new(); for (int i = 0; i < 10; ++i) { reactor_stop(reactor); reactor_start(reactor); @@ -59,7 +55,7 @@ TEST_F(ReactorTest, reactor_repeated_stop_start) { } TEST_F(ReactorTest, reactor_start_wait_stop) { - reactor_t *reactor = reactor_new(); + reactor_t* reactor = reactor_new(); spawn_reactor_thread(reactor); usleep(50 * 1000); @@ -73,18 +69,18 @@ TEST_F(ReactorTest, reactor_start_wait_stop) { } typedef struct { - reactor_t *reactor; - reactor_object_t *object; + reactor_t* reactor; + reactor_object_t* object; } unregister_arg_t; -static void unregister_cb(void *context) { - unregister_arg_t *arg = (unregister_arg_t *)context; +static void unregister_cb(void* context) { + unregister_arg_t* arg = (unregister_arg_t*)context; reactor_unregister(arg->object); reactor_stop(arg->reactor); } TEST_F(ReactorTest, reactor_unregister_from_callback) { - reactor_t *reactor = reactor_new(); + reactor_t* reactor = reactor_new(); int fd = eventfd(0, 0); unregister_arg_t arg; @@ -100,11 +96,11 @@ TEST_F(ReactorTest, reactor_unregister_from_callback) { } TEST_F(ReactorTest, reactor_unregister_from_separate_thread) { - reactor_t *reactor = reactor_new(); + reactor_t* reactor = reactor_new(); int fd = eventfd(0, 0); - reactor_object_t *object = reactor_register(reactor, fd, NULL, NULL, NULL); + reactor_object_t* object = reactor_register(reactor, fd, NULL, NULL, NULL); spawn_reactor_thread(reactor); usleep(50 * 1000); reactor_unregister(object); diff --git a/osi/test/ringbuffer_test.cc b/osi/test/ringbuffer_test.cc index f4ae86a5e..3475973bf 100644 --- a/osi/test/ringbuffer_test.cc +++ b/osi/test/ringbuffer_test.cc @@ -1,10 +1,10 @@ #include -#include "osi/include/ringbuffer.h" #include "osi/include/osi.h" +#include "osi/include/ringbuffer.h" TEST(RingbufferTest, test_new_simple) { - ringbuffer_t *rb = ringbuffer_init(4096); + ringbuffer_t* rb = ringbuffer_init(4096); ASSERT_TRUE(rb != NULL); EXPECT_EQ((size_t)4096, ringbuffer_available(rb)); EXPECT_EQ((size_t)0, ringbuffer_size(rb)); @@ -12,16 +12,17 @@ TEST(RingbufferTest, test_new_simple) { } TEST(RingbufferTest, test_insert_basic) { - ringbuffer_t *rb = ringbuffer_init(16); + ringbuffer_t* rb = ringbuffer_init(16); - uint8_t buffer[10] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A}; + uint8_t buffer[10] = {0x01, 0x02, 0x03, 0x04, 0x05, + 0x06, 0x07, 0x08, 0x09, 0x0A}; ringbuffer_insert(rb, buffer, 10); EXPECT_EQ((size_t)10, ringbuffer_size(rb)); EXPECT_EQ((size_t)6, ringbuffer_available(rb)); uint8_t peek[10] = {0}; size_t peeked = ringbuffer_peek(rb, 0, peek, 10); - EXPECT_EQ((size_t)10, ringbuffer_size(rb)); // Ensure size doesn't change + EXPECT_EQ((size_t)10, ringbuffer_size(rb)); // Ensure size doesn't change EXPECT_EQ((size_t)6, ringbuffer_available(rb)); EXPECT_EQ((size_t)10, peeked); ASSERT_TRUE(0 == memcmp(buffer, peek, peeked)); @@ -30,7 +31,7 @@ TEST(RingbufferTest, test_insert_basic) { } TEST(RingbufferTest, test_insert_full) { - ringbuffer_t *rb = ringbuffer_init(5); + ringbuffer_t* rb = ringbuffer_init(5); uint8_t aa[] = {0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA}; uint8_t bb[] = {0xBB, 0xBB, 0xBB, 0xBB, 0xBB}; @@ -57,7 +58,7 @@ TEST(RingbufferTest, test_insert_full) { } TEST(RingbufferTest, test_multi_insert_delete) { - ringbuffer_t *rb = ringbuffer_init(16); + ringbuffer_t* rb = ringbuffer_init(16); EXPECT_EQ((size_t)16, ringbuffer_available(rb)); EXPECT_EQ((size_t)0, ringbuffer_size(rb)); @@ -74,7 +75,8 @@ TEST(RingbufferTest, test_multi_insert_delete) { EXPECT_EQ((size_t)3, ringbuffer_available(rb)); EXPECT_EQ((size_t)13, ringbuffer_size(rb)); - uint8_t content[] = {0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB}; + uint8_t content[] = {0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB}; uint8_t peek[16] = {0}; size_t peeked = ringbuffer_peek(rb, 0, peek, 16); EXPECT_EQ((size_t)13, peeked); @@ -108,7 +110,7 @@ TEST(RingbufferTest, test_multi_insert_delete) { // Add more again to check head motion - uint8_t dd[] = { 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD }; + uint8_t dd[] = {0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD}; added = ringbuffer_insert(rb, dd, sizeof(dd)); EXPECT_EQ((size_t)8, added); EXPECT_EQ((size_t)1, ringbuffer_available(rb)); @@ -121,7 +123,7 @@ TEST(RingbufferTest, test_multi_insert_delete) { // Add small token - uint8_t ae[] = { 0xAE, 0xAE, 0xAE }; + uint8_t ae[] = {0xAE, 0xAE, 0xAE}; added = ringbuffer_insert(rb, ae, sizeof(ae)); EXPECT_EQ((size_t)13, ringbuffer_available(rb)); diff --git a/osi/test/semaphore_test.cc b/osi/test/semaphore_test.cc index e52b2d6b1..711ae49ed 100644 --- a/osi/test/semaphore_test.cc +++ b/osi/test/semaphore_test.cc @@ -2,8 +2,8 @@ #include "AllocationTestHarness.h" -#include #include +#include #include "osi/include/osi.h" #include "osi/include/reactor.h" @@ -11,32 +11,32 @@ #include "osi/include/thread.h" struct SemaphoreTestSequenceHelper { - semaphore_t *semaphore; + semaphore_t* semaphore; int counter; }; namespace { - void sleep_then_increment_counter(void *context) { - SemaphoreTestSequenceHelper *helper = - reinterpret_cast(context); - assert(helper); - assert(helper->semaphore); - sleep(1); - ++helper->counter; - semaphore_post(helper->semaphore); - } -} // namespace +void sleep_then_increment_counter(void* context) { + SemaphoreTestSequenceHelper* helper = + reinterpret_cast(context); + assert(helper); + assert(helper->semaphore); + sleep(1); + ++helper->counter; + semaphore_post(helper->semaphore); +} +} // namespace class SemaphoreTest : public AllocationTestHarness {}; TEST_F(SemaphoreTest, test_new_simple) { - semaphore_t *semaphore = semaphore_new(0); + semaphore_t* semaphore = semaphore_new(0); ASSERT_TRUE(semaphore != NULL); semaphore_free(semaphore); } TEST_F(SemaphoreTest, test_new_with_value) { - semaphore_t *semaphore = semaphore_new(3); + semaphore_t* semaphore = semaphore_new(3); ASSERT_TRUE(semaphore != NULL); EXPECT_TRUE(semaphore_try_wait(semaphore)); @@ -48,7 +48,7 @@ TEST_F(SemaphoreTest, test_new_with_value) { } TEST_F(SemaphoreTest, test_try_wait) { - semaphore_t *semaphore = semaphore_new(0); + semaphore_t* semaphore = semaphore_new(0); ASSERT_TRUE(semaphore != NULL); EXPECT_FALSE(semaphore_try_wait(semaphore)); @@ -60,7 +60,7 @@ TEST_F(SemaphoreTest, test_try_wait) { } TEST_F(SemaphoreTest, test_wait_after_post) { - semaphore_t *semaphore = semaphore_new(0); + semaphore_t* semaphore = semaphore_new(0); ASSERT_TRUE(semaphore != NULL); semaphore_post(semaphore); semaphore_wait(semaphore); @@ -68,17 +68,17 @@ TEST_F(SemaphoreTest, test_wait_after_post) { } TEST_F(SemaphoreTest, test_ensure_wait) { - semaphore_t *semaphore = semaphore_new(0); + semaphore_t* semaphore = semaphore_new(0); ASSERT_TRUE(semaphore != NULL); - thread_t *thread = thread_new("semaphore_test_thread"); + thread_t* thread = thread_new("semaphore_test_thread"); ASSERT_TRUE(thread != NULL); EXPECT_FALSE(semaphore_try_wait(semaphore)); SemaphoreTestSequenceHelper sequence_helper = {semaphore, 0}; thread_post(thread, sleep_then_increment_counter, &sequence_helper); semaphore_wait(semaphore); - EXPECT_EQ(sequence_helper.counter, 1) << - "semaphore_wait() did not wait for counter to increment"; + EXPECT_EQ(sequence_helper.counter, 1) + << "semaphore_wait() did not wait for counter to increment"; semaphore_free(semaphore); thread_free(thread); diff --git a/osi/test/test_stubs.h b/osi/test/test_stubs.h index 9f8a607b9..007d9a448 100644 --- a/osi/test/test_stubs.h +++ b/osi/test/test_stubs.h @@ -25,15 +25,16 @@ extern "C" { // Helper macros for stubbing out functions and modules for testing. // Stub out a function, with call counting and mode awareness -#define STUB_FUNCTION(ret, name, params) \ - UNUSED_ATTR static int name##_callcount; \ - static ret name params { \ +#define STUB_FUNCTION(ret, name, params) \ + UNUSED_ATTR static int name##_callcount; \ + static ret name params { \ UNUSED_ATTR int _local_callcount = name##_callcount; \ name##_callcount++; // Expect a certain number of calls to the specified stub function -#define EXPECT_CALL_COUNT(name, count) \ - EXPECT_EQ((count), (name##_callcount)) << "expected " #name " to be called " #count " times" +#define EXPECT_CALL_COUNT(name, count) \ + EXPECT_EQ((count), (name##_callcount)) \ + << "expected " #name " to be called " #count " times" // Reset the call count for the specificed stub function #define RESET_CALL_COUNT(name) ((name##_callcount) = 0) @@ -41,10 +42,9 @@ extern "C" { // Use this in a stub function to catch unexpected calls. // Prints out a nice message including the call count, the // stub function name, and the mode index (sadly no mode name) -#define UNEXPECTED_CALL EXPECT_TRUE(false) \ - << "unexpected call " << _local_callcount \ - << " to " << __func__ \ - << " during mode " << (int)_current_mode +#define UNEXPECTED_CALL \ + EXPECT_TRUE(false) << "unexpected call " << _local_callcount << " to " \ + << __func__ << " during mode " << (int)_current_mode #define MODE_IS(mode) (_current_mode == (mode)) @@ -53,7 +53,8 @@ extern "C" { #define OVERLOAD_SELECT(NAME, NUM) OVERLOAD_CAT(NAME##_, NUM) #define OVERLOAD_GET_COUNT(_1, _2, _3, _4, _5, _6, COUNT, ...) COUNT #define OVERLOAD_VA_SIZE(...) OVERLOAD_GET_COUNT(__VA_ARGS__, 6, 5, 4, 3, 2, 1) -#define OVERLOAD_OF(NAME, ...) OVERLOAD_SELECT(NAME, OVERLOAD_VA_SIZE(__VA_ARGS__))(__VA_ARGS__) +#define OVERLOAD_OF(NAME, ...) \ + OVERLOAD_SELECT(NAME, OVERLOAD_VA_SIZE(__VA_ARGS__))(__VA_ARGS__) // Use this to branch stub function execution to a specific mode or modes. // Treat it like an if statement. For example: @@ -62,18 +63,18 @@ extern "C" { // DURING(midday_snack, midnight_snack) EXPECT_EQ(chocolate, food); #define DURING(...) OVERLOAD_OF(DURING, __VA_ARGS__) -#define DURING_1(mode0) \ - if (MODE_IS(mode0)) -#define DURING_2(mode0, mode1) \ - if (MODE_IS(mode0) || MODE_IS(mode1)) +#define DURING_1(mode0) if (MODE_IS(mode0)) +#define DURING_2(mode0, mode1) if (MODE_IS(mode0) || MODE_IS(mode1)) #define DURING_3(mode0, mode1, mode2) \ if (MODE_IS(mode0) || MODE_IS(mode1) || MODE_IS(mode2)) #define DURING_4(mode0, mode1, mode2, mode3) \ if (MODE_IS(mode0) || MODE_IS(mode1) || MODE_IS(mode2) || MODE_IS(mode3)) -#define DURING_5(mode0, mode1, mode2, mode3, mode4) \ - if (MODE_IS(mode0) || MODE_IS(mode1) || MODE_IS(mode2) || MODE_IS(mode3) || MODE_IS(mode4)) -#define DURING_6(mode0, mode1, mode2, mode3, mode4, mode5) \ - if (MODE_IS(mode0) || MODE_IS(mode1) || MODE_IS(mode2) || MODE_IS(mode3) || MODE_IS(mode4) || MODE_IS(mode5)) +#define DURING_5(mode0, mode1, mode2, mode3, mode4) \ + if (MODE_IS(mode0) || MODE_IS(mode1) || MODE_IS(mode2) || MODE_IS(mode3) || \ + MODE_IS(mode4)) +#define DURING_6(mode0, mode1, mode2, mode3, mode4, mode5) \ + if (MODE_IS(mode0) || MODE_IS(mode1) || MODE_IS(mode2) || MODE_IS(mode3) || \ + MODE_IS(mode4) || MODE_IS(mode5)) // Use this to branch stub function exeuction to a specific call // count index (zero based). Treat it like an if statement. @@ -88,14 +89,13 @@ extern "C" { // AT_CALL(1) EXPECT_EQ(bacon_wrapped_bacon, food); // AT_CALL(1) EXPECT_EQ(chocolate_covered_fake_blueberries, food); // } -#define AT_CALL(index) \ - if (_local_callcount == (index)) +#define AT_CALL(index) if (_local_callcount == (index)) // Declare all the available test modes for the DURING clauses // For example: // // DECLARE_TEST_MODES(breakfast, lunch, dinner); -#define DECLARE_TEST_MODES(...) \ +#define DECLARE_TEST_MODES(...) \ typedef enum { __VA_ARGS__ } _test_modes_t; \ static _test_modes_t _current_mode; diff --git a/osi/test/thread_test.cc b/osi/test/thread_test.cc index 8f0904f71..debf250d8 100644 --- a/osi/test/thread_test.cc +++ b/osi/test/thread_test.cc @@ -4,54 +4,54 @@ #include +#include "osi/include/osi.h" #include "osi/include/reactor.h" #include "osi/include/thread.h" -#include "osi/include/osi.h" class ThreadTest : public AllocationTestHarness {}; TEST_F(ThreadTest, test_new_simple) { - thread_t *thread = thread_new("test_thread"); + thread_t* thread = thread_new("test_thread"); ASSERT_TRUE(thread != NULL); thread_free(thread); } TEST_F(ThreadTest, test_free_simple) { - thread_t *thread = thread_new("test_thread"); + thread_t* thread = thread_new("test_thread"); thread_free(thread); } TEST_F(ThreadTest, test_name) { - thread_t *thread = thread_new("test_name"); + thread_t* thread = thread_new("test_name"); ASSERT_STREQ(thread_name(thread), "test_name"); thread_free(thread); } TEST_F(ThreadTest, test_long_name) { - thread_t *thread = thread_new("0123456789abcdef"); + thread_t* thread = thread_new("0123456789abcdef"); ASSERT_STREQ("0123456789abcdef", thread_name(thread)); thread_free(thread); } TEST_F(ThreadTest, test_very_long_name) { - thread_t *thread = thread_new("0123456789abcdefg"); + thread_t* thread = thread_new("0123456789abcdefg"); ASSERT_STREQ("0123456789abcdef", thread_name(thread)); thread_free(thread); } -static void thread_is_self_fn(void *context) { - thread_t *thread = (thread_t *)context; +static void thread_is_self_fn(void* context) { + thread_t* thread = (thread_t*)context; EXPECT_TRUE(thread_is_self(thread)); } TEST_F(ThreadTest, test_thread_is_self) { - thread_t *thread = thread_new("test_thread"); + thread_t* thread = thread_new("test_thread"); thread_post(thread, thread_is_self_fn, thread); thread_free(thread); } TEST_F(ThreadTest, test_thread_is_not_self) { - thread_t *thread = thread_new("test_thread"); + thread_t* thread = thread_new("test_thread"); EXPECT_FALSE(thread_is_self(thread)); thread_free(thread); } diff --git a/osi/test/wakelock_test.cc b/osi/test/wakelock_test.cc index 24e49caaa..f62eb803f 100644 --- a/osi/test/wakelock_test.cc +++ b/osi/test/wakelock_test.cc @@ -18,10 +18,10 @@ #include +#include #include -#include #include -#include +#include #include "osi/include/wakelock.h" @@ -29,39 +29,33 @@ static bool is_wake_lock_acquired = false; -static int acquire_wake_lock_cb(const char *lock_name) -{ +static int acquire_wake_lock_cb(const char* lock_name) { is_wake_lock_acquired = true; return BT_STATUS_SUCCESS; } -static int release_wake_lock_cb(const char *lock_name) -{ +static int release_wake_lock_cb(const char* lock_name) { is_wake_lock_acquired = false; return BT_STATUS_SUCCESS; } static bt_os_callouts_t bt_wakelock_callouts = { - sizeof(bt_os_callouts_t), - NULL, - acquire_wake_lock_cb, - release_wake_lock_cb -}; + sizeof(bt_os_callouts_t), NULL, acquire_wake_lock_cb, release_wake_lock_cb}; class WakelockTest : public AllocationTestHarness { -protected: + protected: virtual void SetUp() { AllocationTestHarness::SetUp(); - // TODO (jamuraa): maybe use base::CreateNewTempDirectory instead? +// TODO (jamuraa): maybe use base::CreateNewTempDirectory instead? #if defined(OS_GENERIC) tmp_dir_ = "/tmp/btwlXXXXXX"; #else tmp_dir_ = "/data/local/tmp/btwlXXXXXX"; -#endif // !defined(OS_GENERIC) +#endif // !defined(OS_GENERIC) - char *buffer = const_cast(tmp_dir_.c_str()); - char *dtemp = mkdtemp(buffer); + char* buffer = const_cast(tmp_dir_.c_str()); + char* dtemp = mkdtemp(buffer); if (!dtemp) { perror("Can't make wake lock test directory: "); assert(false); @@ -105,10 +99,10 @@ protected: assert(lock_stat.st_size >= unlock_stat.st_size); - void *lock_file = mmap(nullptr, lock_stat.st_size, PROT_READ, - MAP_PRIVATE, lock_fd, 0); + void* lock_file = + mmap(nullptr, lock_stat.st_size, PROT_READ, MAP_PRIVATE, lock_fd, 0); - void *unlock_file = mmap(nullptr, unlock_stat.st_size, PROT_READ, + void* unlock_file = mmap(nullptr, unlock_stat.st_size, PROT_READ, MAP_PRIVATE, unlock_fd, 0); if (memcmp(lock_file, unlock_file, unlock_stat.st_size) == 0) { @@ -147,7 +141,7 @@ TEST_F(WakelockTest, test_set_os_callouts) { } TEST_F(WakelockTest, test_set_paths) { - wakelock_set_os_callouts(NULL); // Make sure we use native wakelocks + wakelock_set_os_callouts(NULL); // Make sure we use native wakelocks wakelock_set_paths(lock_path_.c_str(), unlock_path_.c_str()); // Initially, the wakelock is not acquired -- 2.11.0