X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fcommon%2Fcommon.h;h=ab19d098b37a693e3dbb318afe2cf1d09474b043;hb=98b15851a941e7342b8bb19e265cdc3a40fabfb8;hp=570eec67cbe51d5d94db8370693a3eba2807d1ba;hpb=3f7d4d90b0456de9d34fac337350818ef06163bd;p=babeltrace.git diff --git a/src/common/common.h b/src/common/common.h index 570eec67..ab19d098 100644 --- a/src/common/common.h +++ b/src/common/common.h @@ -31,13 +31,14 @@ #include #include #include +#include #include +#include -#include -#include -#include -#include -#include +#include + +#define __BT_IN_BABELTRACE_H +#include #include "common/assert.h" #include "common/macros.h" @@ -92,7 +93,7 @@ const char *bt_common_get_system_plugin_path(void); * return value. */ BT_HIDDEN -char *bt_common_get_home_plugin_path(void); +char *bt_common_get_home_plugin_path(int log_level); /* * Appends the list of directories in `paths` to the array `dirs`. @@ -309,7 +310,7 @@ void bt_common_custom_snprintf(char *buf, size_t buf_size, * Returns the system page size. */ BT_HIDDEN -size_t bt_common_get_page_size(void); +size_t bt_common_get_page_size(int log_level); /* * Adds the digit separator `sep` as many times as needed to form groups @@ -327,41 +328,77 @@ size_t bt_common_get_page_size(void); BT_HIDDEN void bt_common_sep_digits(char *str, unsigned int digits_per_group, char sep); +/* + * This is similar to what the command `fold --spaces` does: it wraps + * the input lines of `str`, breaking at spaces, and indenting each line + * with `indent` spaces so that each line fits the total length + * `total_length`. + * + * If an original line in `str` contains a word which is >= the content + * length (`total_length - indent`), then the corresponding folded line + * is also larger than the content length. In other words, breaking at + * spaces is a best effort, but it might not be possible. + * + * The returned string, on success, is owned by the caller. + */ +BT_HIDDEN +GString *bt_common_fold(const char *str, unsigned int total_length, + unsigned int indent); + +/* + * Writes the terminal's width to `*width`, its height to `*height`, + * and returns 0 on success, or returns -1 on error. + */ +BT_HIDDEN +int bt_common_get_term_size(unsigned int *width, unsigned int *height); + +/* + * Appends the textual content of `fp` to `str`, starting from its + * current position to the end of the file. + * + * This function does NOT rewind `fp` once it's done or on error. + */ +BT_HIDDEN +int bt_common_append_file_content_to_g_string(GString *str, FILE *fp); + /* * Wraps read() function to handle EINTR and partial reads. * On success, it returns `count` received as parameter. On error, it returns a * value smaller than the requested `count`. */ static inline -ssize_t bt_common_read(int fd, void *buf, size_t count) +ssize_t bt_common_read(int fd, void *buf, size_t count, int log_level) { size_t i = 0; ssize_t ret; - BT_ASSERT(buf); + BT_ASSERT_DBG(buf); /* Never return an overflow value. */ - BT_ASSERT(count <= SSIZE_MAX); + BT_ASSERT_DBG(count <= SSIZE_MAX); do { ret = read(fd, buf + i, count - i); if (ret < 0) { if (errno == EINTR) { -#ifdef BT_LOGD_STR - BT_LOGD_STR("read() call interrupted; retrying..."); +#ifdef BT_LOG_WRITE_CUR_LVL + BT_LOG_WRITE_CUR_LVL(BT_LOG_DEBUG, log_level, + BT_LOG_TAG, + "read() call interrupted; retrying..."); #endif /* retry operation */ continue; } else { -#ifdef BT_LOGE_ERRNO - BT_LOGE_ERRNO("Error while reading", ": fd=%d", - fd); +#ifdef BT_LOG_WRITE_ERRNO_CUR_LVL + BT_LOG_WRITE_ERRNO_CUR_LVL(BT_LOG_ERROR, + log_level, BT_LOG_TAG, + "Error while reading", ": fd=%d", fd); #endif goto end; } } i += ret; - BT_ASSERT(i <= count); + BT_ASSERT_DBG(i <= count); } while (count - i > 0 && ret > 0); end: @@ -380,26 +417,46 @@ static inline const char *bt_common_field_class_type_string(enum bt_field_class_type class_type) { switch (class_type) { + case BT_FIELD_CLASS_TYPE_BOOL: + return "BOOL"; + case BT_FIELD_CLASS_TYPE_BIT_ARRAY: + return "BIT_ARRAY"; case BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER: - return "BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER"; + return "UNSIGNED_INTEGER"; case BT_FIELD_CLASS_TYPE_SIGNED_INTEGER: - return "BT_FIELD_CLASS_TYPE_SIGNED_INTEGER"; - case BT_FIELD_CLASS_TYPE_REAL: - return "BT_FIELD_CLASS_TYPE_REAL"; + return "SIGNED_INTEGER"; case BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION: - return "BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION"; + return "UNSIGNED_ENUMERATION"; case BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION: - return "BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION"; + return "SIGNED_ENUMERATION"; + case BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL: + return "SINGLE_PRECISION_REAL"; + case BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL: + return "DOUBLE_PRECISION_REAL"; case BT_FIELD_CLASS_TYPE_STRING: - return "BT_FIELD_CLASS_TYPE_STRING"; + return "STRING"; case BT_FIELD_CLASS_TYPE_STRUCTURE: - return "BT_FIELD_CLASS_TYPE_STRUCTURE"; + return "STRUCTURE"; case BT_FIELD_CLASS_TYPE_STATIC_ARRAY: - return "BT_FIELD_CLASS_TYPE_STATIC_ARRAY"; - case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY: - return "BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY"; - case BT_FIELD_CLASS_TYPE_VARIANT: - return "BT_FIELD_CLASS_TYPE_VARIANT"; + return "STATIC_ARRAY"; + case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD: + return "DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD"; + case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD: + return "DYNAMIC_ARRAY_WITH_LENGTH_FIELD"; + case BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD: + return "OPTION_WITHOUT_SELECTOR_FIELD"; + case BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD: + return "OPTION_WITH_BOOL_SELECTOR_FIELD"; + case BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD: + return "OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD"; + case BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD: + return "OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD"; + case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD: + return "VARIANT_WITHOUT_SELECTOR_FIELD"; + case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD: + return "VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD"; + case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD: + return "VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD"; default: return "(unknown)"; } @@ -410,30 +467,30 @@ const char *bt_common_field_class_integer_preferred_display_base_string(enum bt_ { switch (base) { case BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY: - return "BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY"; + return "BINARY"; case BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL: - return "BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL"; + return "OCTAL"; case BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL: - return "BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL"; + return "DECIMAL"; case BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL: - return "BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL"; + return "HEXADECIMAL"; default: return "(unknown)"; } } static inline -const char *bt_common_scope_string(enum bt_scope scope) +const char *bt_common_scope_string(enum bt_field_path_scope scope) { switch (scope) { - case BT_SCOPE_PACKET_CONTEXT: - return "BT_SCOPE_PACKET_CONTEXT"; - case BT_SCOPE_EVENT_COMMON_CONTEXT: - return "BT_SCOPE_EVENT_COMMON_CONTEXT"; - case BT_SCOPE_EVENT_SPECIFIC_CONTEXT: - return "BT_SCOPE_EVENT_SPECIFIC_CONTEXT"; - case BT_SCOPE_EVENT_PAYLOAD: - return "BT_SCOPE_EVENT_PAYLOAD"; + case BT_FIELD_PATH_SCOPE_PACKET_CONTEXT: + return "PACKET_CONTEXT"; + case BT_FIELD_PATH_SCOPE_EVENT_COMMON_CONTEXT: + return "EVENT_COMMON_CONTEXT"; + case BT_FIELD_PATH_SCOPE_EVENT_SPECIFIC_CONTEXT: + return "EVENT_SPECIFIC_CONTEXT"; + case BT_FIELD_PATH_SCOPE_EVENT_PAYLOAD: + return "EVENT_PAYLOAD"; default: return "(unknown)"; } @@ -445,35 +502,35 @@ const char *bt_common_event_class_log_level_string( { switch (level) { case BT_EVENT_CLASS_LOG_LEVEL_EMERGENCY: - return "BT_EVENT_CLASS_LOG_LEVEL_EMERGENCY"; + return "EMERGENCY"; case BT_EVENT_CLASS_LOG_LEVEL_ALERT: - return "BT_EVENT_CLASS_LOG_LEVEL_ALERT"; + return "ALERT"; case BT_EVENT_CLASS_LOG_LEVEL_CRITICAL: - return "BT_EVENT_CLASS_LOG_LEVEL_CRITICAL"; + return "CRITICAL"; case BT_EVENT_CLASS_LOG_LEVEL_ERROR: - return "BT_EVENT_CLASS_LOG_LEVEL_ERROR"; + return "ERROR"; case BT_EVENT_CLASS_LOG_LEVEL_WARNING: - return "BT_EVENT_CLASS_LOG_LEVEL_WARNING"; + return "WARNING"; case BT_EVENT_CLASS_LOG_LEVEL_NOTICE: - return "BT_EVENT_CLASS_LOG_LEVEL_NOTICE"; + return "NOTICE"; case BT_EVENT_CLASS_LOG_LEVEL_INFO: - return "BT_EVENT_CLASS_LOG_LEVEL_INFO"; + return "INFO"; case BT_EVENT_CLASS_LOG_LEVEL_DEBUG_SYSTEM: - return "BT_EVENT_CLASS_LOG_LEVEL_DEBUG_SYSTEM"; + return "DEBUG_SYSTEM"; case BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROGRAM: - return "BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROGRAM"; + return "DEBUG_PROGRAM"; case BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROCESS: - return "BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROCESS"; + return "DEBUG_PROCESS"; case BT_EVENT_CLASS_LOG_LEVEL_DEBUG_MODULE: - return "BT_EVENT_CLASS_LOG_LEVEL_DEBUG_MODULE"; + return "DEBUG_MODULE"; case BT_EVENT_CLASS_LOG_LEVEL_DEBUG_UNIT: - return "BT_EVENT_CLASS_LOG_LEVEL_DEBUG_UNIT"; + return "DEBUG_UNIT"; case BT_EVENT_CLASS_LOG_LEVEL_DEBUG_FUNCTION: - return "BT_EVENT_CLASS_LOG_LEVEL_DEBUG_FUNCTION"; + return "DEBUG_FUNCTION"; case BT_EVENT_CLASS_LOG_LEVEL_DEBUG_LINE: - return "BT_EVENT_CLASS_LOG_LEVEL_DEBUG_LINE"; + return "DEBUG_LINE"; case BT_EVENT_CLASS_LOG_LEVEL_DEBUG: - return "BT_EVENT_CLASS_LOG_LEVEL_DEBUG"; + return "DEBUG"; default: return "(unknown)"; } @@ -484,21 +541,21 @@ const char *bt_common_value_type_string(enum bt_value_type type) { switch (type) { case BT_VALUE_TYPE_NULL: - return "BT_VALUE_TYPE_NULL"; + return "NULL"; case BT_VALUE_TYPE_BOOL: - return "BT_VALUE_TYPE_BOOL"; + return "BOOL"; case BT_VALUE_TYPE_UNSIGNED_INTEGER: - return "BT_VALUE_TYPE_UNSIGNED_INTEGER"; + return "UNSIGNED_INTEGER"; case BT_VALUE_TYPE_SIGNED_INTEGER: - return "BT_VALUE_TYPE_SIGNED_INTEGER"; + return "SIGNED_INTEGER"; case BT_VALUE_TYPE_REAL: - return "BT_VALUE_TYPE_REAL"; + return "REAL"; case BT_VALUE_TYPE_STRING: - return "BT_VALUE_TYPE_STRING"; + return "STRING"; case BT_VALUE_TYPE_ARRAY: - return "BT_VALUE_TYPE_ARRAY"; + return "ARRAY"; case BT_VALUE_TYPE_MAP: - return "BT_VALUE_TYPE_MAP"; + return "MAP"; default: return "(unknown)"; } @@ -510,7 +567,7 @@ GString *bt_common_field_path_string(struct bt_field_path *path) GString *str = g_string_new(NULL); uint64_t i; - BT_ASSERT(path); + BT_ASSERT_DBG(path); if (!str) { goto end; @@ -543,25 +600,56 @@ end: } static inline -const char *bt_common_self_message_iterator_status_string( - enum bt_self_message_iterator_status status) +const char *bt_common_logging_level_string( + enum bt_logging_level level) { - switch (status) { - case BT_SELF_MESSAGE_ITERATOR_STATUS_AGAIN: - return "BT_SELF_MESSAGE_ITERATOR_STATUS_AGAIN"; - case BT_SELF_MESSAGE_ITERATOR_STATUS_END: - return "BT_SELF_MESSAGE_ITERATOR_STATUS_END"; - case BT_SELF_MESSAGE_ITERATOR_STATUS_OK: - return "BT_SELF_MESSAGE_ITERATOR_STATUS_OK"; - case BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR: - return "BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR"; - case BT_SELF_MESSAGE_ITERATOR_STATUS_NOMEM: - return "BT_SELF_MESSAGE_ITERATOR_STATUS_NOMEM"; + switch (level) { + case BT_LOGGING_LEVEL_TRACE: + return "TRACE"; + case BT_LOGGING_LEVEL_DEBUG: + return "DEBUG"; + case BT_LOGGING_LEVEL_INFO: + return "INFO"; + case BT_LOGGING_LEVEL_WARNING: + return "WARNING"; + case BT_LOGGING_LEVEL_ERROR: + return "ERROR"; + case BT_LOGGING_LEVEL_FATAL: + return "FATAL"; + case BT_LOGGING_LEVEL_NONE: + return "NONE"; default: return "(unknown)"; } }; +static inline +const char *bt_common_func_status_string(int status) +{ + switch (status) { + case __BT_FUNC_STATUS_OVERFLOW_ERROR: + return "OVERFLOW"; + case __BT_FUNC_STATUS_UNKNOWN_OBJECT: + return "UNKNOWN_OBJECT"; + case __BT_FUNC_STATUS_MEMORY_ERROR: + return "MEMORY_ERROR"; + case __BT_FUNC_STATUS_ERROR: + return "ERROR"; + case __BT_FUNC_STATUS_OK: + return "OK"; + case __BT_FUNC_STATUS_END: + return "END"; + case __BT_FUNC_STATUS_NOT_FOUND: + return "NOT_FOUND"; + case __BT_FUNC_STATUS_AGAIN: + return "AGAIN"; + case __BT_FUNC_STATUS_INTERRUPTED: + return "INTERRUPTED"; + default: + return "(unknown)"; + } +} + #define NS_PER_S_I INT64_C(1000000000) #define NS_PER_S_U UINT64_C(1000000000) @@ -579,7 +667,7 @@ int bt_common_clock_value_from_ns_from_origin( uint64_t value_period_cycles; int64_t ns_to_add; - BT_ASSERT(raw_value); + BT_ASSERT_DBG(raw_value); /* Compute offset part of requested value, in nanoseconds */ if (!bt_safe_to_mul_int64(cc_offset_seconds, NS_PER_S_I)) { @@ -653,11 +741,50 @@ end: return ret; } +/* + * bt_g_string_append_printf cannot be inlined because it expects a + * variadic argument list. + */ +BT_HIDDEN +int bt_common_g_string_append_printf(GString *str, const char *fmt, ...); + static inline -enum bt_self_message_iterator_status bt_common_message_iterator_status_to_self( - enum bt_message_iterator_status status) +void bt_common_g_string_append(GString *str, const char *s) { - return (int) status; + gsize len, allocated_len, s_len; + + /* str->len excludes \0. */ + len = str->len; + /* Exclude \0. */ + allocated_len = str->allocated_len - 1; + s_len = strlen(s); + if (G_UNLIKELY(allocated_len < len + s_len)) { + /* Resize. */ + g_string_set_size(str, len + s_len); + } else { + str->len = len + s_len; + } + memcpy(str->str + len, s, s_len + 1); +} + +static inline +void bt_common_g_string_append_c(GString *str, char c) +{ + gsize len, allocated_len, s_len; + + /* str->len excludes \0. */ + len = str->len; + /* Exclude \0. */ + allocated_len = str->allocated_len - 1; + s_len = 1; + if (G_UNLIKELY(allocated_len < len + s_len)) { + /* Resize. */ + g_string_set_size(str, len + s_len); + } else { + str->len = len + s_len; + } + str->str[len] = c; + str->str[len + 1] = '\0'; } #endif /* BABELTRACE_COMMON_INTERNAL_H */