aws-crt 0.1.9 → 0.2.0

data/aws-crt-ffi/crt/aws-c-common/include/aws/common/system_resource_util.h

@@ -0,0 +1,30 @@
+#ifndef AWS_COMMON_SYSTEM_RESOURCE_UTIL_H
+#define AWS_COMMON_SYSTEM_RESOURCE_UTIL_H
+
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+#include <aws/common/common.h>
+
+AWS_PUSH_SANE_WARNING_LEVEL
+
+AWS_EXTERN_C_BEGIN
+
+struct aws_memory_usage_stats {
+    size_t maxrss;      /* max resident set size in kilobytes since program start */
+    size_t page_faults; /* num of page faults since program start */
+
+    size_t _reserved[8];
+};
+
+/*
+ * Get memory usage for current process.
+ * Raises AWS_ERROR_SYS_CALL_FAILURE on failure.
+ */
+AWS_COMMON_API int aws_init_memory_usage_for_current_process(struct aws_memory_usage_stats *memory_usage);
+
+AWS_EXTERN_C_END
+AWS_POP_SANE_WARNING_LEVEL
+
+#endif /* AWS_COMMON_SYSTEM_RESOURCE_UTIL_H */

data/aws-crt-ffi/crt/aws-c-common/include/aws/testing/aws_test_harness.h

@@ -474,10 +474,11 @@ static inline int s_aws_run_test_case(struct aws_test_harness *harness) {
          * but aws_mem_tracer_dump() needs a valid logger to be active */
         aws_logger_set(&err_logger);
 
-        const size_t leaked_bytes = aws_mem_tracer_count(allocator);
+        const size_t leaked_allocations = aws_mem_tracer_count(allocator);
+        const size_t leaked_bytes = aws_mem_tracer_bytes(allocator);
         if (leaked_bytes) {
             aws_mem_tracer_dump(allocator);
-            PRINT_FAIL_INTERNAL0("Test leaked memory: %zu bytes", leaked_bytes);
+            PRINT_FAIL_INTERNAL0("Test leaked memory: %zu bytes %zu allocations", leaked_bytes, leaked_allocations);
             goto fail;
         }
 

data/aws-crt-ffi/crt/aws-c-common/source/allocator.c

@@ -34,7 +34,7 @@ bool aws_allocator_is_valid(const struct aws_allocator *alloc) {
     return alloc && AWS_OBJECT_PTR_IS_READABLE(alloc) && alloc->mem_acquire && alloc->mem_release;
 }
 
-static void *s_default_malloc(struct aws_allocator *allocator, size_t size) {
+static void *s_aligned_malloc(struct aws_allocator *allocator, size_t size) {
     (void)allocator;
     /* larger allocations should be aligned so that AVX and friends can avoid
      * the extra preamble during unaligned versions of memcpy/memset on big buffers
@@ -62,7 +62,7 @@ static void *s_default_malloc(struct aws_allocator *allocator, size_t size) {
 #endif
 }
 
-static void s_default_free(struct aws_allocator *allocator, void *ptr) {
+static void s_aligned_free(struct aws_allocator *allocator, void *ptr) {
     (void)allocator;
 #if !defined(_WIN32)
     free(ptr);
@@ -71,7 +71,7 @@ static void s_default_free(struct aws_allocator *allocator, void *ptr) {
 #endif
 }
 
-static void *s_default_realloc(struct aws_allocator *allocator, void *ptr, size_t oldsize, size_t newsize) {
+static void *s_aligned_realloc(struct aws_allocator *allocator, void *ptr, size_t oldsize, size_t newsize) {
     (void)allocator;
     (void)oldsize;
     AWS_FATAL_PRECONDITION(newsize);
@@ -82,12 +82,12 @@ static void *s_default_realloc(struct aws_allocator *allocator, void *ptr, size_
     }
 
     /* newsize is > oldsize, need more memory */
-    void *new_mem = s_default_malloc(allocator, newsize);
-    AWS_PANIC_OOM(new_mem, "Unhandled OOM encountered in s_default_malloc");
+    void *new_mem = s_aligned_malloc(allocator, newsize);
+    AWS_PANIC_OOM(new_mem, "Unhandled OOM encountered in s_aligned_malloc");
 
     if (ptr) {
         memcpy(new_mem, ptr, oldsize);
-        s_default_free(allocator, ptr);
+        s_aligned_free(allocator, ptr);
     }
 
     return new_mem;
@@ -99,24 +99,75 @@ static void *s_default_realloc(struct aws_allocator *allocator, void *ptr, size_
 #endif
 }
 
-static void *s_default_calloc(struct aws_allocator *allocator, size_t num, size_t size) {
-    void *mem = s_default_malloc(allocator, num * size);
-    AWS_PANIC_OOM(mem, "Unhandled OOM encountered in s_default_malloc");
+static void *s_aligned_calloc(struct aws_allocator *allocator, size_t num, size_t size) {
+    void *mem = s_aligned_malloc(allocator, num * size);
+    AWS_PANIC_OOM(mem, "Unhandled OOM encountered in s_aligned_calloc");
     memset(mem, 0, num * size);
     return mem;
 }
 
+static void *s_non_aligned_malloc(struct aws_allocator *allocator, size_t size) {
+    (void)allocator;
+    void *result = malloc(size);
+    AWS_PANIC_OOM(result, "malloc failed to allocate memory");
+    return result;
+}
+
+static void s_non_aligned_free(struct aws_allocator *allocator, void *ptr) {
+    (void)allocator;
+    free(ptr);
+}
+
+static void *s_non_aligned_realloc(struct aws_allocator *allocator, void *ptr, size_t oldsize, size_t newsize) {
+    (void)allocator;
+    (void)oldsize;
+    AWS_FATAL_PRECONDITION(newsize);
+
+    if (newsize <= oldsize) {
+        return ptr;
+    }
+
+    /* newsize is > oldsize, need more memory */
+    void *new_mem = s_non_aligned_malloc(allocator, newsize);
+    AWS_PANIC_OOM(new_mem, "Unhandled OOM encountered in s_non_aligned_realloc");
+
+    if (ptr) {
+        memcpy(new_mem, ptr, oldsize);
+        s_non_aligned_free(allocator, ptr);
+    }
+
+    return new_mem;
+}
+
+static void *s_non_aligned_calloc(struct aws_allocator *allocator, size_t num, size_t size) {
+    (void)allocator;
+    void *mem = calloc(num, size);
+    AWS_PANIC_OOM(mem, "Unhandled OOM encountered in s_non_aligned_calloc");
+    return mem;
+}
+
 static struct aws_allocator default_allocator = {
-    .mem_acquire = s_default_malloc,
-    .mem_release = s_default_free,
-    .mem_realloc = s_default_realloc,
-    .mem_calloc = s_default_calloc,
+    .mem_acquire = s_non_aligned_malloc,
+    .mem_release = s_non_aligned_free,
+    .mem_realloc = s_non_aligned_realloc,
+    .mem_calloc = s_non_aligned_calloc,
 };
 
 struct aws_allocator *aws_default_allocator(void) {
     return &default_allocator;
 }
 
+static struct aws_allocator aligned_allocator = {
+    .mem_acquire = s_aligned_malloc,
+    .mem_release = s_aligned_free,
+    .mem_realloc = s_aligned_realloc,
+    .mem_calloc = s_aligned_calloc,
+};
+
+struct aws_allocator *aws_aligned_allocator(void) {
+    return &aligned_allocator;
+}
+
 void *aws_mem_acquire(struct aws_allocator *allocator, size_t size) {
     AWS_FATAL_PRECONDITION(allocator != NULL);
     AWS_FATAL_PRECONDITION(allocator->mem_acquire != NULL);

data/aws-crt-ffi/crt/aws-c-common/source/android/logging.c

@@ -5,9 +5,11 @@
 
 #include <android/log.h>
 
+#include <aws/common/clock.h>
 #include <aws/common/logging.h>
 #include <aws/common/string.h>
 
+#include <inttypes.h>
 #include <stdarg.h>
 
 #define LOGCAT_MAX_BUFFER_SIZE (4 * 1024)
@@ -58,6 +60,18 @@ static int s_logcat_format(struct logcat_format_data *formatting_data, va_list a
         current_index = s_advance_and_clamp_index(current_index, thread_id_written, fake_total_length);
     }
 
+    if (current_index < fake_total_length) {
+        uint64_t now = 0;
+        aws_high_res_clock_get_ticks(&now);
+
+        int current_time_written = snprintf(
+            formatting_data->buffer + current_index, fake_total_length - current_index, "(HRC:%" PRIu64 ") ", now);
+        if (current_time_written < 0) {
+            return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
+        }
+        current_index = s_advance_and_clamp_index(current_index, current_time_written, fake_total_length);
+    }
+
     if (current_index < fake_total_length) {
         int separator_written =
             snprintf(formatting_data->buffer + current_index, fake_total_length - current_index, " - ");

data/aws-crt-ffi/crt/aws-c-common/source/common.c

@@ -323,15 +323,15 @@ void aws_common_library_init(struct aws_allocator *allocator) {
            assumptions due to the way loaders and dlload are often implemented and those symbols are defined by things
            like libpthread.so on some unix distros. Sorry about the memory usage here, but it's our only safe choice.
            Also, please don't do numa configurations if memory is your economic bottleneck. */
-        g_libnuma_handle = dlopen("libnuma.so", RTLD_LOCAL);
+        g_libnuma_handle = dlopen("libnuma.so", RTLD_LAZY | RTLD_LOCAL);
 
         /* turns out so versioning is really inconsistent these days */
         if (!g_libnuma_handle) {
-            g_libnuma_handle = dlopen("libnuma.so.1", RTLD_LOCAL);
+            g_libnuma_handle = dlopen("libnuma.so.1", RTLD_LAZY | RTLD_LOCAL);
         }
 
         if (!g_libnuma_handle) {
-            g_libnuma_handle = dlopen("libnuma.so.2", RTLD_LOCAL);
+            g_libnuma_handle = dlopen("libnuma.so.2", RTLD_LAZY | RTLD_LOCAL);
         }
 
         if (g_libnuma_handle) {

data/aws-crt-ffi/crt/aws-c-common/source/file.c

@@ -11,6 +11,16 @@
 
 #include <errno.h>
 
+/* For "special files", the OS often lies about size.
+ * For example, on Amazon Linux 2:
+ * /proc/cpuinfo: size is 0, but contents are several KB of data.
+ * /sys/devices/virtual/dmi/id/product_name: size is 4096, but contents are "c5.2xlarge"
+ *
+ * Therefore, we may need to grow the buffer as we read until EOF.
+ * This is the min/max step size for growth. */
+#define MIN_BUFFER_GROWTH_READING_FILES 32
+#define MAX_BUFFER_GROWTH_READING_FILES 4096
+
 FILE *aws_fopen(const char *file_path, const char *mode) {
     if (!file_path || strlen(file_path) == 0) {
         AWS_LOGF_ERROR(AWS_LS_COMMON_IO, "static: Failed to open file. path is empty");
@@ -34,7 +44,13 @@ FILE *aws_fopen(const char *file_path, const char *mode) {
     return file;
 }
 
-int aws_byte_buf_init_from_file(struct aws_byte_buf *out_buf, struct aws_allocator *alloc, const char *filename) {
+/* Helper function used by aws_byte_buf_init_from_file() and aws_byte_buf_init_from_file_with_size_hint() */
+static int s_byte_buf_init_from_file_impl(
+    struct aws_byte_buf *out_buf,
+    struct aws_allocator *alloc,
+    const char *filename,
+    bool use_file_size_as_hint,
+    size_t size_hint) {
 
     AWS_ZERO_STRUCT(*out_buf);
     FILE *fp = aws_fopen(filename, "rb");
@@ -42,46 +58,78 @@ int aws_byte_buf_init_from_file(struct aws_byte_buf *out_buf, struct aws_allocat
         goto error;
     }
 
-    int64_t len64 = 0;
-    if (aws_file_get_length(fp, &len64)) {
-        AWS_LOGF_ERROR(
-            AWS_LS_COMMON_IO,
-            "static: Failed to get file length. file:'%s' error:%s",
-            filename,
-            aws_error_name(aws_last_error()));
-        goto error;
-    }
+    if (use_file_size_as_hint) {
+        int64_t len64 = 0;
+        if (aws_file_get_length(fp, &len64)) {
+            AWS_LOGF_ERROR(
+                AWS_LS_COMMON_IO,
+                "static: Failed to get file length. file:'%s' error:%s",
+                filename,
+                aws_error_name(aws_last_error()));
+            goto error;
+        }
 
-    if (len64 >= SIZE_MAX) {
-        aws_raise_error(AWS_ERROR_OVERFLOW_DETECTED);
-        AWS_LOGF_ERROR(
-            AWS_LS_COMMON_IO,
-            "static: File too large to read into memory. file:'%s' error:%s",
-            filename,
-            aws_error_name(aws_last_error()));
-        goto error;
+        if (len64 >= SIZE_MAX) {
+            aws_raise_error(AWS_ERROR_OVERFLOW_DETECTED);
+            AWS_LOGF_ERROR(
+                AWS_LS_COMMON_IO,
+                "static: File too large to read into memory. file:'%s' error:%s",
+                filename,
+                aws_error_name(aws_last_error()));
+            goto error;
+        }
+
+        /* Leave space for null terminator at end of buffer */
+        size_hint = (size_t)len64 + 1;
     }
 
-    size_t allocation_size = (size_t)len64 + 1;
-    aws_byte_buf_init(out_buf, alloc, allocation_size);
+    aws_byte_buf_init(out_buf, alloc, size_hint);
+
+    /* Read in a loop until we hit EOF */
+    while (true) {
+        /* Expand buffer if necessary (at a reasonable rate) */
+        if (out_buf->len == out_buf->capacity) {
+            size_t additional_capacity = out_buf->capacity;
+            additional_capacity = aws_max_size(MIN_BUFFER_GROWTH_READING_FILES, additional_capacity);
+            additional_capacity = aws_min_size(MAX_BUFFER_GROWTH_READING_FILES, additional_capacity);
+            if (aws_byte_buf_reserve_relative(out_buf, additional_capacity)) {
+                AWS_LOGF_ERROR(AWS_LS_COMMON_IO, "static: Failed to grow buffer for file:'%s'", filename);
+                goto error;
+            }
+        }
 
-    /* Ensure compatibility with null-terminated APIs, but don't consider
-     * the null terminator part of the length of the payload */
-    out_buf->len = out_buf->capacity - 1;
-    out_buf->buffer[out_buf->len] = 0;
+        size_t space_available = out_buf->capacity - out_buf->len;
+        size_t bytes_read = fread(out_buf->buffer + out_buf->len, 1, space_available, fp);
+        out_buf->len += bytes_read;
 
-    size_t read = fread(out_buf->buffer, 1, out_buf->len, fp);
-    if (read < out_buf->len) {
-        int errno_value = ferror(fp) ? errno : 0; /* Always cache errno before potential side-effect */
-        aws_translate_and_raise_io_error_or(errno_value, AWS_ERROR_FILE_READ_FAILURE);
-        AWS_LOGF_ERROR(
-            AWS_LS_COMMON_IO,
-            "static: Failed reading file:'%s' errno:%d aws-error:%s",
-            filename,
-            errno_value,
-            aws_error_name(aws_last_error()));
-        goto error;
+        /* If EOF, we're done! */
+        if (feof(fp)) {
+            break;
+        }
+
+        /* If no EOF but we read 0 bytes, there's been an error or at least we need
+         * to treat it like one because we can't just infinitely loop. */
+        if (bytes_read == 0) {
+            int errno_value = ferror(fp) ? errno : 0; /* Always cache errno before potential side-effect */
+            aws_translate_and_raise_io_error_or(errno_value, AWS_ERROR_FILE_READ_FAILURE);
+            AWS_LOGF_ERROR(
+                AWS_LS_COMMON_IO,
+                "static: Failed reading file:'%s' errno:%d aws-error:%s",
+                filename,
+                errno_value,
+                aws_error_name(aws_last_error()));
+            goto error;
+        }
+    }
+
+    /* A null terminator is appended, but is not included as part of the length field. */
+    if (out_buf->len == out_buf->capacity) {
+        if (aws_byte_buf_reserve_relative(out_buf, 1)) {
+            AWS_LOGF_ERROR(AWS_LS_COMMON_IO, "static: Failed to grow buffer for file:'%s'", filename);
+            goto error;
+        }
     }
+    out_buf->buffer[out_buf->len] = 0;
 
     fclose(fp);
     return AWS_OP_SUCCESS;
@@ -94,6 +142,19 @@ error:
     return AWS_OP_ERR;
 }
 
+int aws_byte_buf_init_from_file(struct aws_byte_buf *out_buf, struct aws_allocator *alloc, const char *filename) {
+    return s_byte_buf_init_from_file_impl(out_buf, alloc, filename, true /*use_file_size_as_hint*/, 0 /*size_hint*/);
+}
+
+int aws_byte_buf_init_from_file_with_size_hint(
+    struct aws_byte_buf *out_buf,
+    struct aws_allocator *alloc,
+    const char *filename,
+    size_t size_hint) {
+
+    return s_byte_buf_init_from_file_impl(out_buf, alloc, filename, false /*use_file_size_as_hint*/, size_hint);
+}
+
 bool aws_is_any_directory_separator(char value) {
     return value == '\\' || value == '/';
 }

data/aws-crt-ffi/crt/aws-c-common/source/linux/system_info.c

@@ -0,0 +1,24 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+#include <aws/common/file.h>
+#include <aws/common/private/system_info_priv.h>
+
+int aws_system_environment_load_platform_impl(struct aws_system_environment *env) {
+    /* provide size_hint when reading "special files", since some platforms mis-report these files' size as 4KB */
+    aws_byte_buf_init_from_file_with_size_hint(
+        &env->virtualization_vendor, env->allocator, "/sys/devices/virtual/dmi/id/sys_vendor", 32 /*size_hint*/);
+
+    /* whether this one works depends on if this is a sysfs filesystem. If it fails, it will just be empty
+     * and these APIs are a best effort at the moment. We can add fallbacks as the loaders get more complicated. */
+    aws_byte_buf_init_from_file_with_size_hint(
+        &env->product_name, env->allocator, "/sys/devices/virtual/dmi/id/product_name", 32 /*size_hint*/);
+
+    return AWS_OP_SUCCESS;
+}
+
+void aws_system_environment_destroy_platform_impl(struct aws_system_environment *env) {
+    aws_byte_buf_clean_up(&env->virtualization_vendor);
+    aws_byte_buf_clean_up(&env->product_name);
+}

data/aws-crt-ffi/crt/aws-c-common/source/memtrace.c

@@ -438,11 +438,18 @@ static void s_trace_mem_release(struct aws_allocator *allocator, void *ptr) {
 static void *s_trace_mem_realloc(struct aws_allocator *allocator, void *old_ptr, size_t old_size, size_t new_size) {
     struct alloc_tracer *tracer = allocator->impl;
     void *new_ptr = old_ptr;
-    if (aws_mem_realloc(tracer->traced_allocator, &new_ptr, old_size, new_size)) {
-        return NULL;
-    }
 
+    /*
+     * Careful with the ordering of state clean up here.
+     * Tracer keeps a hash table (alloc ptr as key) of meta info about each allocation.
+     * To avoid race conditions during realloc state update needs to be done in
+     * following order to avoid race conditions:
+     * - remove meta info (other threads cant reuse that key, cause ptr is still valid )
+     * - realloc (cant fail, ptr might remain the same)
+     * - add meta info for reallocated mem
+     */
     s_alloc_tracer_untrack(tracer, old_ptr);
+    aws_mem_realloc(tracer->traced_allocator, &new_ptr, old_size, new_size);
     s_alloc_tracer_track(tracer, new_ptr, new_size);
 
     return new_ptr;

data/aws-crt-ffi/crt/aws-c-common/source/platform_fallback_stubs/system_info.c

@@ -0,0 +1,21 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+#include <aws/common/private/system_info_priv.h>
+
+#include <aws/common/logging.h>
+
+int aws_system_environment_load_platform_impl(struct aws_system_environment *env) {
+    (void)env;
+    AWS_LOGF_DEBUG(
+        AWS_LS_COMMON_GENERAL,
+        "id=%p: platform specific environment loading is not implemented for this platform.",
+        (void *)env);
+
+    return AWS_OP_SUCCESS;
+}
+
+void aws_system_environment_destroy_platform_impl(struct aws_system_environment *env) {
+    (void)env;
+}

data/aws-crt-ffi/crt/aws-c-common/source/posix/cross_process_lock.c

@@ -0,0 +1,141 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+#include <aws/common/cross_process_lock.h>
+
+#include <aws/common/byte_buf.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <aws/common/error.h>
+#include <aws/common/file.h>
+#include <aws/common/logging.h>
+
+struct aws_cross_process_lock {
+    struct aws_allocator *allocator;
+    int locked_fd;
+};
+
+struct aws_cross_process_lock *aws_cross_process_lock_try_acquire(
+    struct aws_allocator *allocator,
+    struct aws_byte_cursor instance_nonce) {
+
+    /* validate we don't have a directory slash. */
+    struct aws_byte_cursor to_find = aws_byte_cursor_from_c_str("/");
+    struct aws_byte_cursor found;
+    AWS_ZERO_STRUCT(found);
+    if (aws_byte_cursor_find_exact(&instance_nonce, &to_find, &found) != AWS_OP_ERR &&
+        aws_last_error() != AWS_ERROR_STRING_MATCH_NOT_FOUND) {
+        AWS_LOGF_ERROR(
+            AWS_LS_COMMON_GENERAL,
+            "static: Lock " PRInSTR "creation has illegal character /",
+            AWS_BYTE_CURSOR_PRI(instance_nonce));
+        aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
+        return NULL;
+    }
+
+    /*
+     * The unix standard says /tmp has to be there and be writable. However, while it may be tempting to just use the
+     * /tmp/ directory, it often has the sticky bit set which would prevent a subprocess from being able to call open
+     * with create on the file. The solution is simple, just write it to a subdirectory inside
+     * /tmp and override umask via. chmod of 0777.
+     */
+    struct aws_byte_cursor path_prefix = aws_byte_cursor_from_c_str("/tmp/aws_crt_cross_process_lock/");
+    struct aws_string *path_to_create = aws_string_new_from_cursor(allocator, &path_prefix);
+
+    /* It's probably there already and we don't care if it is. */
+    if (!aws_directory_exists(path_to_create)) {
+        /* if this call fails just let it fail on open below. */
+        aws_directory_create(path_to_create);
+        /* bypass umask by setting the perms we actually requested */
+        chmod(aws_string_c_str(path_to_create), S_IRWXU | S_IRWXG | S_IRWXO);
+    }
+    aws_string_destroy(path_to_create);
+
+    struct aws_byte_cursor path_suffix = aws_byte_cursor_from_c_str(".lock");
+
+    struct aws_byte_buf nonce_buf;
+    aws_byte_buf_init_copy_from_cursor(&nonce_buf, allocator, path_prefix);
+    aws_byte_buf_append_dynamic(&nonce_buf, &instance_nonce);
+    aws_byte_buf_append_dynamic(&nonce_buf, &path_suffix);
+    aws_byte_buf_append_null_terminator(&nonce_buf);
+
+    struct aws_cross_process_lock *instance_lock = NULL;
+
+    errno = 0;
+    int fd = open((const char *)nonce_buf.buffer, O_CREAT | O_RDWR, 0666);
+    if (fd < 0) {
+        AWS_LOGF_DEBUG(
+            AWS_LS_COMMON_GENERAL,
+            "static: Lock file %s failed to open with errno %d",
+            (const char *)nonce_buf.buffer,
+            errno);
+
+        aws_translate_and_raise_io_error_or(errno, AWS_ERROR_MUTEX_FAILED);
+
+        if (aws_last_error() == AWS_ERROR_NO_PERMISSION) {
+            AWS_LOGF_DEBUG(
+                AWS_LS_COMMON_GENERAL,
+                "static: Lock file %s couldn't be opened due to file ownership permissions. Attempting to open as read "
+                "only",
+                (const char *)nonce_buf.buffer);
+
+            errno = 0;
+            fd = open((const char *)nonce_buf.buffer, O_RDONLY);
+
+            if (fd < 0) {
+                AWS_LOGF_ERROR(
+                    AWS_LS_COMMON_GENERAL,
+                    "static: Lock file %s failed to open with read-only permissions with errno %d",
+                    (const char *)nonce_buf.buffer,
+                    errno);
+                aws_translate_and_raise_io_error_or(errno, AWS_ERROR_MUTEX_FAILED);
+                goto cleanup;
+            }
+        } else {
+            AWS_LOGF_ERROR(
+                AWS_LS_COMMON_GENERAL,
+                "static: Lock file %s failed to open. The lock cannot be acquired.",
+                (const char *)nonce_buf.buffer);
+            goto cleanup;
+        }
+    }
+
+    if (flock(fd, LOCK_EX | LOCK_NB) == -1) {
+        AWS_LOGF_TRACE(
+            AWS_LS_COMMON_GENERAL,
+            "static: Lock file %s already acquired by another instance",
+            (const char *)nonce_buf.buffer);
+        close(fd);
+        aws_raise_error(AWS_ERROR_MUTEX_CALLER_NOT_OWNER);
+        goto cleanup;
+    }
+
+    instance_lock = aws_mem_calloc(allocator, 1, sizeof(struct aws_cross_process_lock));
+    instance_lock->locked_fd = fd;
+    instance_lock->allocator = allocator;
+
+    AWS_LOGF_TRACE(
+        AWS_LS_COMMON_GENERAL,
+        "static: Lock file %s acquired by this instance with fd %d",
+        (const char *)nonce_buf.buffer,
+        fd);
+
+cleanup:
+    aws_byte_buf_clean_up(&nonce_buf);
+
+    return instance_lock;
+}
+
+void aws_cross_process_lock_release(struct aws_cross_process_lock *instance_lock) {
+    if (instance_lock) {
+        flock(instance_lock->locked_fd, LOCK_UN);
+        close(instance_lock->locked_fd);
+        AWS_LOGF_TRACE(AWS_LS_COMMON_GENERAL, "static: Lock file released for fd %d", instance_lock->locked_fd);
+        aws_mem_release(instance_lock->allocator, instance_lock);
+    }
+}

data/aws-crt-ffi/crt/aws-c-common/source/posix/system_info.c

@@ -50,7 +50,7 @@ size_t aws_system_info_processor_count(void) {
 
 uint16_t aws_get_cpu_group_count(void) {
     if (g_numa_num_configured_nodes_ptr) {
-        return (uint16_t)g_numa_num_configured_nodes_ptr();
+        return aws_max_u16(1, (uint16_t)g_numa_num_configured_nodes_ptr());
     }
 
     return 1U;

data/aws-crt-ffi/crt/aws-c-common/source/posix/system_resource_utils.c

@@ -0,0 +1,32 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/common/system_resource_util.h>
+
+#include <sys/resource.h>
+
+int aws_init_memory_usage_for_current_process(struct aws_memory_usage_stats *memory_usage) {
+    AWS_PRECONDITION(memory_usage);
+
+    AWS_ZERO_STRUCT(*memory_usage);
+    struct rusage usage;
+
+    if (getrusage(RUSAGE_SELF, &usage)) {
+        return aws_raise_error(AWS_ERROR_SYS_CALL_FAILURE);
+    }
+
+#if defined(AWS_OS_APPLE)
+    /*
+     * For some reason Apple switched to reporting this in bytes instead of KB
+     * around MacOS 10.6.
+     * Make it back to KB. Result might be slightly off due to rounding.
+     */
+    memory_usage->maxrss = usage.ru_maxrss / 1024;
+#else
+    memory_usage->maxrss = usage.ru_maxrss;
+#endif
+    memory_usage->page_faults = usage.ru_majflt;
+    return AWS_OP_SUCCESS;
+}

data/aws-crt-ffi/crt/aws-c-common/source/priority_queue.c

@@ -400,3 +400,27 @@ size_t aws_priority_queue_size(const struct aws_priority_queue *queue) {
 size_t aws_priority_queue_capacity(const struct aws_priority_queue *queue) {
     return aws_array_list_capacity(&queue->container);
 }
+
+void aws_priority_queue_clear(struct aws_priority_queue *queue) {
+    AWS_PRECONDITION(aws_priority_queue_is_valid(queue));
+    size_t backpointer_count = aws_array_list_length(&queue->backpointers);
+    for (size_t i = 0; i < backpointer_count; ++i) {
+        struct aws_priority_queue_node *node = NULL;
+        aws_array_list_get_at(&queue->backpointers, &node, i);
+        if (node != NULL) {
+            node->current_index = SIZE_MAX;
+        }
+    }
+
+    aws_array_list_clear(&queue->backpointers);
+    aws_array_list_clear(&queue->container);
+    AWS_PRECONDITION(aws_priority_queue_is_valid(queue));
+}
+
+void aws_priority_queue_node_init(struct aws_priority_queue_node *node) {
+    node->current_index = SIZE_MAX;
+}
+
+bool aws_priority_queue_node_is_in_queue(const struct aws_priority_queue_node *node) {
+    return node->current_index != SIZE_MAX;
+}