diff --git a/examples/custom_file_provider/custom_file_provider.c b/examples/custom_file_provider/custom_file_provider.c
index b0f1bc0628..ffa61d63f5 100644
--- a/examples/custom_file_provider/custom_file_provider.c
+++ b/examples/custom_file_provider/custom_file_provider.c
@@ -113,10 +113,6 @@ static void file_deinit(void *provider) {
 // Function to allocate memory from the file provider
 static umf_result_t file_alloc(void *provider, size_t size, size_t alignment,
                                void **ptr) {
-    if (provider == NULL || ptr == NULL) {
-        fprintf(stderr, "Provider or ptr cannot be null\n");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
     file_provider_t *file_provider = (file_provider_t *)provider;
     size_t page_size = file_provider->page_size;
 
@@ -165,8 +161,8 @@ static umf_result_t file_alloc(void *provider, size_t size, size_t alignment,
 
 // Function to free allocated memory from the file provider
 static umf_result_t file_free(void *provider, void *ptr, size_t size) {
-    if (provider == NULL || ptr == NULL) {
-        fprintf(stderr, "Provider or ptr cannot be null\n");
+    if (ptr == NULL) {
+        fprintf(stderr, "ptr cannot be null\n");
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
     file_provider_t *file_provider = (file_provider_t *)provider;
@@ -221,11 +217,6 @@ static void file_get_last_native_error(void *provider, const char **ppMessage,
 static umf_result_t file_get_recommended_page_size(void *provider, size_t size,
                                                    size_t *pageSize) {
     (void)size; // Unused parameter
-    if (provider == NULL || pageSize == NULL) {
-        fprintf(stderr, "Provider or pageSize cannot be null\n");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     file_provider_t *file_provider = (file_provider_t *)provider;
     *pageSize = file_provider->page_size;
     return UMF_RESULT_SUCCESS;
@@ -235,11 +226,6 @@ static umf_result_t file_get_recommended_page_size(void *provider, size_t size,
 static umf_result_t file_get_min_page_size(void *provider, void *ptr,
                                            size_t *pageSize) {
     (void)ptr; // Unused parameter
-    if (provider == NULL || pageSize == NULL) {
-        fprintf(stderr, "Provider or pageSize cannot be null\n");
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     file_provider_t *file_provider = (file_provider_t *)provider;
     *pageSize = file_provider->page_size;
     return UMF_RESULT_SUCCESS;
diff --git a/src/memory_provider.c b/src/memory_provider.c
index 3d823a4a8b..883f1be263 100644
--- a/src/memory_provider.c
+++ b/src/memory_provider.c
@@ -226,6 +226,7 @@ checkErrorAndSetLastProvider(umf_result_t result,
 umf_result_t umfMemoryProviderAlloc(umf_memory_provider_handle_t hProvider,
                                     size_t size, size_t alignment, void **ptr) {
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     umf_result_t res =
         hProvider->ops.alloc(hProvider->provider_priv, size, alignment, ptr);
     checkErrorAndSetLastProvider(res, hProvider);
@@ -258,6 +259,7 @@ umf_result_t
 umfMemoryProviderGetRecommendedPageSize(umf_memory_provider_handle_t hProvider,
                                         size_t size, size_t *pageSize) {
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((pageSize != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     umf_result_t res = hProvider->ops.get_recommended_page_size(
         hProvider->provider_priv, size, pageSize);
     checkErrorAndSetLastProvider(res, hProvider);
@@ -268,6 +270,7 @@ umf_result_t
 umfMemoryProviderGetMinPageSize(umf_memory_provider_handle_t hProvider,
                                 void *ptr, size_t *pageSize) {
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((pageSize != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     umf_result_t res = hProvider->ops.get_min_page_size(
         hProvider->provider_priv, ptr, pageSize);
     checkErrorAndSetLastProvider(res, hProvider);
@@ -282,6 +285,7 @@ const char *umfMemoryProviderGetName(umf_memory_provider_handle_t hProvider) {
 umf_result_t umfMemoryProviderPurgeLazy(umf_memory_provider_handle_t hProvider,
                                         void *ptr, size_t size) {
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     umf_result_t res =
         hProvider->ops.ext.purge_lazy(hProvider->provider_priv, ptr, size);
     checkErrorAndSetLastProvider(res, hProvider);
@@ -291,6 +295,7 @@ umf_result_t umfMemoryProviderPurgeLazy(umf_memory_provider_handle_t hProvider,
 umf_result_t umfMemoryProviderPurgeForce(umf_memory_provider_handle_t hProvider,
                                          void *ptr, size_t size) {
     UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     umf_result_t res =
         hProvider->ops.ext.purge_force(hProvider->provider_priv, ptr, size);
     checkErrorAndSetLastProvider(res, hProvider);
@@ -305,15 +310,11 @@ umf_result_t
 umfMemoryProviderAllocationSplit(umf_memory_provider_handle_t hProvider,
                                  void *ptr, size_t totalSize,
                                  size_t firstSize) {
-    if (!ptr) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-    if (firstSize == 0 || totalSize == 0) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-    if (firstSize >= totalSize) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((firstSize != 0 && totalSize != 0),
+              UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((firstSize < totalSize), UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
     umf_result_t res = hProvider->ops.ext.allocation_split(
         hProvider->provider_priv, ptr, totalSize, firstSize);
@@ -325,18 +326,13 @@ umf_result_t
 umfMemoryProviderAllocationMerge(umf_memory_provider_handle_t hProvider,
                                  void *lowPtr, void *highPtr,
                                  size_t totalSize) {
-    if (!lowPtr || !highPtr) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-    if (totalSize == 0) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-    if ((uintptr_t)lowPtr >= (uintptr_t)highPtr) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-    if ((uintptr_t)highPtr - (uintptr_t)lowPtr > totalSize) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((lowPtr && highPtr), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((totalSize != 0), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK(((uintptr_t)lowPtr < (uintptr_t)highPtr),
+              UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK(((uintptr_t)highPtr - (uintptr_t)lowPtr < totalSize),
+              UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
     umf_result_t res = hProvider->ops.ext.allocation_merge(
         hProvider->provider_priv, lowPtr, highPtr, totalSize);
@@ -347,6 +343,8 @@ umfMemoryProviderAllocationMerge(umf_memory_provider_handle_t hProvider,
 umf_result_t
 umfMemoryProviderGetIPCHandleSize(umf_memory_provider_handle_t hProvider,
                                   size_t *size) {
+    UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((size != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     return hProvider->ops.ipc.get_ipc_handle_size(hProvider->provider_priv,
                                                   size);
 }
@@ -355,6 +353,9 @@ umf_result_t
 umfMemoryProviderGetIPCHandle(umf_memory_provider_handle_t hProvider,
                               const void *ptr, size_t size,
                               void *providerIpcData) {
+    UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((providerIpcData != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     return hProvider->ops.ipc.get_ipc_handle(hProvider->provider_priv, ptr,
                                              size, providerIpcData);
 }
@@ -362,6 +363,8 @@ umfMemoryProviderGetIPCHandle(umf_memory_provider_handle_t hProvider,
 umf_result_t
 umfMemoryProviderPutIPCHandle(umf_memory_provider_handle_t hProvider,
                               void *providerIpcData) {
+    UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((providerIpcData != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     return hProvider->ops.ipc.put_ipc_handle(hProvider->provider_priv,
                                              providerIpcData);
 }
@@ -369,6 +372,9 @@ umfMemoryProviderPutIPCHandle(umf_memory_provider_handle_t hProvider,
 umf_result_t
 umfMemoryProviderOpenIPCHandle(umf_memory_provider_handle_t hProvider,
                                void *providerIpcData, void **ptr) {
+    UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((providerIpcData != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     return hProvider->ops.ipc.open_ipc_handle(hProvider->provider_priv,
                                               providerIpcData, ptr);
 }
@@ -376,6 +382,8 @@ umfMemoryProviderOpenIPCHandle(umf_memory_provider_handle_t hProvider,
 umf_result_t
 umfMemoryProviderCloseIPCHandle(umf_memory_provider_handle_t hProvider,
                                 void *ptr, size_t size) {
+    UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
     return hProvider->ops.ipc.close_ipc_handle(hProvider->provider_priv, ptr,
                                                size);
 }
diff --git a/src/provider/provider_coarse.c b/src/provider/provider_coarse.c
index ed7bb1cba8..c3027b91d7 100644
--- a/src/provider/provider_coarse.c
+++ b/src/provider/provider_coarse.c
@@ -1478,10 +1478,6 @@ coarse_memory_provider_get_stats(void *provider,
 
 static umf_result_t coarse_memory_provider_purge_lazy(void *provider, void *ptr,
                                                       size_t size) {
-    if (provider == NULL || ptr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     coarse_memory_provider_t *coarse_provider =
         (struct coarse_memory_provider_t *)provider;
     if (coarse_provider->upstream_memory_provider == NULL) {
@@ -1495,10 +1491,6 @@ static umf_result_t coarse_memory_provider_purge_lazy(void *provider, void *ptr,
 
 static umf_result_t coarse_memory_provider_purge_force(void *provider,
                                                        void *ptr, size_t size) {
-    if (provider == NULL || ptr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     coarse_memory_provider_t *coarse_provider =
         (struct coarse_memory_provider_t *)provider;
     if (coarse_provider->upstream_memory_provider == NULL) {
@@ -1514,11 +1506,6 @@ static umf_result_t coarse_memory_provider_allocation_split(void *provider,
                                                             void *ptr,
                                                             size_t totalSize,
                                                             size_t firstSize) {
-    if (provider == NULL || ptr == NULL || (firstSize >= totalSize) ||
-        firstSize == 0) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     umf_result_t umf_result;
 
     coarse_memory_provider_t *coarse_provider =
@@ -1578,12 +1565,6 @@ static umf_result_t coarse_memory_provider_allocation_merge(void *provider,
                                                             void *lowPtr,
                                                             void *highPtr,
                                                             size_t totalSize) {
-    if (provider == NULL || lowPtr == NULL || highPtr == NULL ||
-        ((uintptr_t)highPtr <= (uintptr_t)lowPtr) ||
-        ((uintptr_t)highPtr - (uintptr_t)lowPtr >= totalSize)) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     umf_result_t umf_result;
 
     coarse_memory_provider_t *coarse_provider =
diff --git a/src/provider/provider_cuda.c b/src/provider/provider_cuda.c
index a1f9df0344..db0016c445 100644
--- a/src/provider/provider_cuda.c
+++ b/src/provider/provider_cuda.c
@@ -160,7 +160,7 @@ static void init_cu_global_state(void) {
 
 static umf_result_t cu_memory_provider_initialize(void *params,
                                                   void **provider) {
-    if (provider == NULL || params == NULL) {
+    if (params == NULL) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
@@ -214,11 +214,6 @@ static umf_result_t cu_memory_provider_initialize(void *params,
 }
 
 static void cu_memory_provider_finalize(void *provider) {
-    if (provider == NULL) {
-        ASSERT(0);
-        return;
-    }
-
     umf_ba_global_free(provider);
 }
 
@@ -250,10 +245,6 @@ static inline umf_result_t set_context(CUcontext required_ctx,
 static umf_result_t cu_memory_provider_alloc(void *provider, size_t size,
                                              size_t alignment,
                                              void **resultPtr) {
-    if (provider == NULL || resultPtr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     cu_memory_provider_t *cu_provider = (cu_memory_provider_t *)provider;
 
     if (alignment > cu_provider->min_alignment) {
@@ -318,10 +309,6 @@ static umf_result_t cu_memory_provider_free(void *provider, void *ptr,
                                             size_t bytes) {
     (void)bytes;
 
-    if (provider == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     if (ptr == NULL) {
         return UMF_RESULT_SUCCESS;
     }
@@ -385,10 +372,6 @@ static umf_result_t cu_memory_provider_get_min_page_size(void *provider,
                                                          size_t *pageSize) {
     (void)ptr;
 
-    if (provider == NULL || pageSize == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     cu_memory_provider_t *cu_provider = (cu_memory_provider_t *)provider;
 
     CUmemAllocationProp allocProps = {0};
@@ -407,10 +390,6 @@ cu_memory_provider_get_recommended_page_size(void *provider, size_t size,
                                              size_t *pageSize) {
     (void)size;
 
-    if (provider == NULL || pageSize == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     cu_memory_provider_t *cu_provider = (cu_memory_provider_t *)provider;
 
     CUmemAllocationProp allocProps = {0};
@@ -431,10 +410,7 @@ static const char *cu_memory_provider_get_name(void *provider) {
 
 static umf_result_t cu_memory_provider_get_ipc_handle_size(void *provider,
                                                            size_t *size) {
-    if (provider == NULL || size == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
+    (void)provider;
     *size = sizeof(cu_ipc_data_t);
     return UMF_RESULT_SUCCESS;
 }
@@ -443,12 +419,9 @@ static umf_result_t cu_memory_provider_get_ipc_handle(void *provider,
                                                       const void *ptr,
                                                       size_t size,
                                                       void *providerIpcData) {
+    (void)provider;
     (void)size;
 
-    if (provider == NULL || ptr == NULL || providerIpcData == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     CUresult cu_result;
     cu_ipc_data_t *cu_ipc_data = (cu_ipc_data_t *)providerIpcData;
 
@@ -463,20 +436,14 @@ static umf_result_t cu_memory_provider_get_ipc_handle(void *provider,
 
 static umf_result_t cu_memory_provider_put_ipc_handle(void *provider,
                                                       void *providerIpcData) {
-    if (provider == NULL || providerIpcData == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
+    (void)provider;
+    (void)providerIpcData;
     return UMF_RESULT_SUCCESS;
 }
 
 static umf_result_t cu_memory_provider_open_ipc_handle(void *provider,
                                                        void *providerIpcData,
                                                        void **ptr) {
-    if (provider == NULL || ptr == NULL || providerIpcData == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     cu_memory_provider_t *cu_provider = (cu_memory_provider_t *)provider;
 
     CUresult cu_result;
@@ -505,10 +472,6 @@ static umf_result_t
 cu_memory_provider_close_ipc_handle(void *provider, void *ptr, size_t size) {
     (void)size;
 
-    if (provider == NULL || ptr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     CUresult cu_result;
 
     cu_result = g_cu_ops.cuIpcCloseMemHandle((CUdeviceptr)ptr);
diff --git a/src/provider/provider_devdax_memory.c b/src/provider/provider_devdax_memory.c
index c7f644db35..f4996fa0d9 100644
--- a/src/provider/provider_devdax_memory.c
+++ b/src/provider/provider_devdax_memory.c
@@ -97,7 +97,7 @@ devdax_translate_params(umf_devdax_memory_provider_params_t *in_params,
 static umf_result_t devdax_initialize(void *params, void **provider) {
     umf_result_t ret;
 
-    if (provider == NULL || params == NULL) {
+    if (params == NULL) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
@@ -185,11 +185,6 @@ static umf_result_t devdax_initialize(void *params, void **provider) {
 }
 
 static void devdax_finalize(void *provider) {
-    if (provider == NULL) {
-        assert(0);
-        return;
-    }
-
     devdax_memory_provider_t *devdax_provider = provider;
     utils_mutex_destroy_not_free(&devdax_provider->lock);
     utils_munmap(devdax_provider->base, devdax_provider->size);
@@ -234,10 +229,6 @@ static umf_result_t devdax_alloc(void *provider, size_t size, size_t alignment,
                                  void **resultPtr) {
     int ret;
 
-    if (provider == NULL || resultPtr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     // alignment must be a power of two and a multiple or a divider of the page size
     if (alignment && ((alignment & (alignment - 1)) ||
                       ((alignment % DEVDAX_PAGE_SIZE_2MB) &&
@@ -309,11 +300,8 @@ static void devdax_get_last_native_error(void *provider, const char **ppMessage,
 static umf_result_t devdax_get_recommended_page_size(void *provider,
                                                      size_t size,
                                                      size_t *page_size) {
-    (void)size; // unused
-
-    if (provider == NULL || page_size == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    (void)provider; // unused
+    (void)size;     // unused
 
     *page_size = DEVDAX_PAGE_SIZE_2MB;
 
@@ -338,10 +326,6 @@ static umf_result_t devdax_purge_lazy(void *provider, void *ptr, size_t size) {
 }
 
 static umf_result_t devdax_purge_force(void *provider, void *ptr, size_t size) {
-    if (provider == NULL || ptr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     errno = 0;
     if (utils_purge(ptr, size, UMF_PURGE_FORCE)) {
         devdax_store_last_native_error(
@@ -364,18 +348,15 @@ static umf_result_t devdax_allocation_split(void *provider, void *ptr,
     (void)ptr;
     (void)totalSize;
     (void)firstSize;
-
     return UMF_RESULT_SUCCESS;
 }
 
 static umf_result_t devdax_allocation_merge(void *provider, void *lowPtr,
                                             void *highPtr, size_t totalSize) {
-    if (provider == NULL || lowPtr == NULL || highPtr == NULL ||
-        ((uintptr_t)highPtr <= (uintptr_t)lowPtr) ||
-        ((uintptr_t)highPtr - (uintptr_t)lowPtr >= totalSize)) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
+    (void)provider;
+    (void)lowPtr;
+    (void)highPtr;
+    (void)totalSize;
     return UMF_RESULT_SUCCESS;
 }
 
@@ -388,9 +369,7 @@ typedef struct devdax_ipc_data_t {
 } devdax_ipc_data_t;
 
 static umf_result_t devdax_get_ipc_handle_size(void *provider, size_t *size) {
-    if (provider == NULL || size == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    (void)provider;
 
     *size = sizeof(devdax_ipc_data_t);
 
@@ -399,10 +378,6 @@ static umf_result_t devdax_get_ipc_handle_size(void *provider, size_t *size) {
 
 static umf_result_t devdax_get_ipc_handle(void *provider, const void *ptr,
                                           size_t size, void *providerIpcData) {
-    if (provider == NULL || ptr == NULL || providerIpcData == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     devdax_memory_provider_t *devdax_provider =
         (devdax_memory_provider_t *)provider;
 
@@ -419,10 +394,6 @@ static umf_result_t devdax_get_ipc_handle(void *provider, const void *ptr,
 
 static umf_result_t devdax_put_ipc_handle(void *provider,
                                           void *providerIpcData) {
-    if (provider == NULL || providerIpcData == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     devdax_memory_provider_t *devdax_provider =
         (devdax_memory_provider_t *)provider;
     devdax_ipc_data_t *devdax_ipc_data = (devdax_ipc_data_t *)providerIpcData;
@@ -439,10 +410,6 @@ static umf_result_t devdax_put_ipc_handle(void *provider,
 
 static umf_result_t devdax_open_ipc_handle(void *provider,
                                            void *providerIpcData, void **ptr) {
-    if (provider == NULL || providerIpcData == NULL || ptr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     *ptr = NULL;
 
     devdax_ipc_data_t *devdax_ipc_data = (devdax_ipc_data_t *)providerIpcData;
@@ -502,10 +469,6 @@ static umf_result_t devdax_open_ipc_handle(void *provider,
 
 static umf_result_t devdax_close_ipc_handle(void *provider, void *ptr,
                                             size_t size) {
-    if (provider == NULL || ptr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     size = ALIGN_UP(size, DEVDAX_PAGE_SIZE_2MB);
 
     errno = 0;
diff --git a/src/provider/provider_file_memory.c b/src/provider/provider_file_memory.c
index ec3cd25cdb..67f7dc924c 100644
--- a/src/provider/provider_file_memory.c
+++ b/src/provider/provider_file_memory.c
@@ -123,7 +123,7 @@ file_translate_params(umf_file_memory_provider_params_t *in_params,
 static umf_result_t file_initialize(void *params, void **provider) {
     umf_result_t ret;
 
-    if (provider == NULL || params == NULL) {
+    if (params == NULL) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
@@ -210,11 +210,6 @@ static umf_result_t file_initialize(void *params, void **provider) {
 }
 
 static void file_finalize(void *provider) {
-    if (provider == NULL) {
-        assert(0);
-        return;
-    }
-
     file_memory_provider_t *file_provider = provider;
 
     uintptr_t key = 0;
@@ -392,10 +387,6 @@ static umf_result_t file_alloc(void *provider, size_t size, size_t alignment,
     umf_result_t umf_result;
     int ret;
 
-    if (provider == NULL || resultPtr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
 
     // alignment must be a power of two and a multiple or a divider of the page size
@@ -474,11 +465,8 @@ static void file_get_last_native_error(void *provider, const char **ppMessage,
 
 static umf_result_t file_get_recommended_page_size(void *provider, size_t size,
                                                    size_t *page_size) {
-    (void)size; // unused
-
-    if (provider == NULL || page_size == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    (void)provider; // unused
+    (void)size;     // unused
 
     *page_size = utils_get_page_size();
 
@@ -503,9 +491,7 @@ static umf_result_t file_purge_lazy(void *provider, void *ptr, size_t size) {
 }
 
 static umf_result_t file_purge_force(void *provider, void *ptr, size_t size) {
-    if (provider == NULL || ptr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    (void)provider; // unused
 
     errno = 0;
     if (utils_purge(ptr, size, UMF_PURGE_FORCE)) {
@@ -587,10 +573,6 @@ typedef struct file_ipc_data_t {
 } file_ipc_data_t;
 
 static umf_result_t file_get_ipc_handle_size(void *provider, size_t *size) {
-    if (provider == NULL || size == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
     if (!file_provider->IPC_enabled) {
         LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
@@ -604,10 +586,6 @@ static umf_result_t file_get_ipc_handle_size(void *provider, size_t *size) {
 
 static umf_result_t file_get_ipc_handle(void *provider, const void *ptr,
                                         size_t size, void *providerIpcData) {
-    if (provider == NULL || ptr == NULL || providerIpcData == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
     if (!file_provider->IPC_enabled) {
         LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
@@ -634,10 +612,6 @@ static umf_result_t file_get_ipc_handle(void *provider, const void *ptr,
 }
 
 static umf_result_t file_put_ipc_handle(void *provider, void *providerIpcData) {
-    if (provider == NULL || providerIpcData == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
     if (!file_provider->IPC_enabled) {
         LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
@@ -655,10 +629,6 @@ static umf_result_t file_put_ipc_handle(void *provider, void *providerIpcData) {
 
 static umf_result_t file_open_ipc_handle(void *provider, void *providerIpcData,
                                          void **ptr) {
-    if (provider == NULL || providerIpcData == NULL || ptr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
     if (!file_provider->IPC_enabled) {
         LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
@@ -701,10 +671,6 @@ static umf_result_t file_open_ipc_handle(void *provider, void *providerIpcData,
 
 static umf_result_t file_close_ipc_handle(void *provider, void *ptr,
                                           size_t size) {
-    if (provider == NULL || ptr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
     if (!file_provider->IPC_enabled) {
         LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
diff --git a/src/provider/provider_level_zero.c b/src/provider/provider_level_zero.c
index 3f122cd6a1..3339042ce3 100644
--- a/src/provider/provider_level_zero.c
+++ b/src/provider/provider_level_zero.c
@@ -136,7 +136,7 @@ static void init_ze_global_state(void) {
 
 static umf_result_t ze_memory_provider_initialize(void *params,
                                                   void **provider) {
-    if (provider == NULL || params == NULL) {
+    if (params == NULL) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
@@ -211,11 +211,6 @@ static umf_result_t ze_memory_provider_initialize(void *params,
 }
 
 static void ze_memory_provider_finalize(void *provider) {
-    if (provider == NULL) {
-        ASSERT(0);
-        return;
-    }
-
     ze_memory_provider_t *ze_provider = (ze_memory_provider_t *)provider;
     umf_ba_global_free(ze_provider->resident_device_handles);
 
@@ -239,10 +234,6 @@ static ze_relaxed_allocation_limits_exp_desc_t relaxed_device_allocation_desc =
 static umf_result_t ze_memory_provider_alloc(void *provider, size_t size,
                                              size_t alignment,
                                              void **resultPtr) {
-    if (provider == NULL || resultPtr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     ze_memory_provider_t *ze_provider = (ze_memory_provider_t *)provider;
 
     ze_result_t ze_result = ZE_RESULT_SUCCESS;
@@ -315,10 +306,6 @@ static umf_result_t ze_memory_provider_free(void *provider, void *ptr,
                                             size_t bytes) {
     (void)bytes;
 
-    if (provider == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     if (ptr == NULL) {
         return UMF_RESULT_SUCCESS;
     }
@@ -344,12 +331,9 @@ static void ze_memory_provider_get_last_native_error(void *provider,
 static umf_result_t ze_memory_provider_get_min_page_size(void *provider,
                                                          void *ptr,
                                                          size_t *pageSize) {
+    (void)provider;
     (void)ptr;
 
-    if (provider == NULL || pageSize == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     // TODO
     *pageSize = 1024 * 64;
     return UMF_RESULT_SUCCESS;
@@ -378,12 +362,9 @@ static umf_result_t ze_memory_provider_purge_force(void *provider, void *ptr,
 static umf_result_t
 ze_memory_provider_get_recommended_page_size(void *provider, size_t size,
                                              size_t *pageSize) {
+    (void)provider;
     (void)size;
 
-    if (provider == NULL || pageSize == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     // TODO
     *pageSize = 1024 * 64;
     return UMF_RESULT_SUCCESS;
@@ -427,9 +408,7 @@ typedef struct ze_ipc_data_t {
 
 static umf_result_t ze_memory_provider_get_ipc_handle_size(void *provider,
                                                            size_t *size) {
-    if (provider == NULL || size == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    (void)provider;
 
     *size = sizeof(ze_ipc_data_t);
     return UMF_RESULT_SUCCESS;
@@ -441,10 +420,6 @@ static umf_result_t ze_memory_provider_get_ipc_handle(void *provider,
                                                       void *providerIpcData) {
     (void)size;
 
-    if (provider == NULL || ptr == NULL || providerIpcData == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     ze_result_t ze_result;
     ze_ipc_data_t *ze_ipc_data = (ze_ipc_data_t *)providerIpcData;
     struct ze_memory_provider_t *ze_provider =
@@ -464,10 +439,6 @@ static umf_result_t ze_memory_provider_get_ipc_handle(void *provider,
 
 static umf_result_t ze_memory_provider_put_ipc_handle(void *provider,
                                                       void *providerIpcData) {
-    if (provider == NULL || providerIpcData == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     ze_result_t ze_result;
     struct ze_memory_provider_t *ze_provider =
         (struct ze_memory_provider_t *)provider;
@@ -492,10 +463,6 @@ static umf_result_t ze_memory_provider_put_ipc_handle(void *provider,
 static umf_result_t ze_memory_provider_open_ipc_handle(void *provider,
                                                        void *providerIpcData,
                                                        void **ptr) {
-    if (provider == NULL || ptr == NULL || providerIpcData == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     ze_result_t ze_result;
     ze_ipc_data_t *ze_ipc_data = (ze_ipc_data_t *)providerIpcData;
     struct ze_memory_provider_t *ze_provider =
@@ -532,10 +499,6 @@ static umf_result_t
 ze_memory_provider_close_ipc_handle(void *provider, void *ptr, size_t size) {
     (void)size;
 
-    if (provider == NULL || ptr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     ze_result_t ze_result;
     struct ze_memory_provider_t *ze_provider =
         (struct ze_memory_provider_t *)provider;
diff --git a/src/provider/provider_os_memory.c b/src/provider/provider_os_memory.c
index 8c5a9dc46a..3ea5cf2200 100644
--- a/src/provider/provider_os_memory.c
+++ b/src/provider/provider_os_memory.c
@@ -478,7 +478,7 @@ static umf_result_t translate_params(umf_os_memory_provider_params_t *in_params,
 static umf_result_t os_initialize(void *params, void **provider) {
     umf_result_t ret;
 
-    if (provider == NULL || params == NULL) {
+    if (params == NULL) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
@@ -572,11 +572,6 @@ static umf_result_t os_initialize(void *params, void **provider) {
 }
 
 static void os_finalize(void *provider) {
-    if (provider == NULL) {
-        assert(0);
-        return;
-    }
-
     os_memory_provider_t *os_provider = provider;
 
     if (os_provider->fd > 0) {
@@ -900,10 +895,6 @@ static umf_result_t os_alloc(void *provider, size_t size, size_t alignment,
                              void **resultPtr) {
     int ret;
 
-    if (provider == NULL || resultPtr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
 
     size_t page_size;
@@ -1004,10 +995,6 @@ static umf_result_t os_alloc(void *provider, size_t size, size_t alignment,
 }
 
 static umf_result_t os_free(void *provider, void *ptr, size_t size) {
-    if (provider == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     if (ptr == NULL) {
         return UMF_RESULT_SUCCESS;
     }
@@ -1067,11 +1054,8 @@ static void os_get_last_native_error(void *provider, const char **ppMessage,
 
 static umf_result_t os_get_recommended_page_size(void *provider, size_t size,
                                                  size_t *page_size) {
-    (void)size; // unused
-
-    if (provider == NULL || page_size == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    (void)provider; // unused
+    (void)size;     // unused
 
     *page_size = utils_get_page_size();
 
@@ -1086,9 +1070,7 @@ static umf_result_t os_get_min_page_size(void *provider, void *ptr,
 }
 
 static umf_result_t os_purge_lazy(void *provider, void *ptr, size_t size) {
-    if (provider == NULL || ptr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    (void)provider; // unused
 
     errno = 0;
     if (utils_purge(ptr, size, UMF_PURGE_LAZY)) {
@@ -1102,9 +1084,7 @@ static umf_result_t os_purge_lazy(void *provider, void *ptr, size_t size) {
 }
 
 static umf_result_t os_purge_force(void *provider, void *ptr, size_t size) {
-    if (provider == NULL || ptr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    (void)provider; // unused
 
     errno = 0;
     if (utils_purge(ptr, size, UMF_PURGE_FORCE)) {
@@ -1191,10 +1171,6 @@ typedef struct os_ipc_data_t {
 } os_ipc_data_t;
 
 static umf_result_t os_get_ipc_handle_size(void *provider, size_t *size) {
-    if (provider == NULL || size == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
     if (!os_provider->IPC_enabled) {
         LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
@@ -1209,10 +1185,6 @@ static umf_result_t os_get_ipc_handle_size(void *provider, size_t *size) {
 
 static umf_result_t os_get_ipc_handle(void *provider, const void *ptr,
                                       size_t size, void *providerIpcData) {
-    if (provider == NULL || ptr == NULL || providerIpcData == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
     if (!os_provider->IPC_enabled) {
         LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
@@ -1245,10 +1217,6 @@ static umf_result_t os_get_ipc_handle(void *provider, const void *ptr,
 }
 
 static umf_result_t os_put_ipc_handle(void *provider, void *providerIpcData) {
-    if (provider == NULL || providerIpcData == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
     if (!os_provider->IPC_enabled) {
         LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
@@ -1280,10 +1248,6 @@ static umf_result_t os_put_ipc_handle(void *provider, void *providerIpcData) {
 
 static umf_result_t os_open_ipc_handle(void *provider, void *providerIpcData,
                                        void **ptr) {
-    if (provider == NULL || providerIpcData == NULL || ptr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
     if (!os_provider->IPC_enabled) {
         LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
@@ -1326,10 +1290,6 @@ static umf_result_t os_open_ipc_handle(void *provider, void *providerIpcData,
 
 static umf_result_t os_close_ipc_handle(void *provider, void *ptr,
                                         size_t size) {
-    if (provider == NULL || ptr == NULL) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     os_memory_provider_t *os_provider = (os_memory_provider_t *)provider;
     if (!os_provider->IPC_enabled) {
         LOG_ERR("memory visibility mode is not UMF_MEM_MAP_SHARED")
diff --git a/test/memoryProviderAPI.cpp b/test/memoryProviderAPI.cpp
index 5208f81570..866ae6dae3 100644
--- a/test/memoryProviderAPI.cpp
+++ b/test/memoryProviderAPI.cpp
@@ -43,14 +43,15 @@ TEST_F(test, memoryProviderTrace) {
     ASSERT_EQ(calls["get_last_native_error"], 1);
     ASSERT_EQ(calls.size(), ++call_count);
 
+    size_t page_size;
     ret = umfMemoryProviderGetRecommendedPageSize(tracingProvider.get(), 0,
-                                                  nullptr);
+                                                  &page_size);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     ASSERT_EQ(calls["get_recommended_page_size"], 1);
     ASSERT_EQ(calls.size(), ++call_count);
 
     ret = umfMemoryProviderGetMinPageSize(tracingProvider.get(), nullptr,
-                                          nullptr);
+                                          &page_size);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     ASSERT_EQ(calls["get_min_page_size"], 1);
     ASSERT_EQ(calls.size(), ++call_count);
@@ -60,12 +61,14 @@ TEST_F(test, memoryProviderTrace) {
     ASSERT_EQ(calls.size(), ++call_count);
     ASSERT_EQ(std::string(pName), std::string("null"));
 
-    ret = umfMemoryProviderPurgeLazy(tracingProvider.get(), nullptr, 0);
+    ret = umfMemoryProviderPurgeLazy(tracingProvider.get(), &page_size,
+                                     sizeof(page_size));
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     ASSERT_EQ(calls["purge_lazy"], 1);
     ASSERT_EQ(calls.size(), ++call_count);
 
-    ret = umfMemoryProviderPurgeForce(tracingProvider.get(), nullptr, 0);
+    ret = umfMemoryProviderPurgeForce(tracingProvider.get(), &page_size,
+                                      sizeof(page_size));
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     ASSERT_EQ(calls["purge_force"], 1);
     ASSERT_EQ(calls.size(), ++call_count);
@@ -107,7 +110,7 @@ TEST_F(test, memoryProviderOpsNullPurgeLazyField) {
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 
     ret = umfMemoryProviderPurgeLazy(hProvider, nullptr, 0);
-    ASSERT_EQ(ret, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
     umfMemoryProviderDestroy(hProvider);
 }
@@ -120,7 +123,7 @@ TEST_F(test, memoryProviderOpsNullPurgeForceField) {
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 
     ret = umfMemoryProviderPurgeForce(hProvider, nullptr, 0);
-    ASSERT_EQ(ret, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
     umfMemoryProviderDestroy(hProvider);
 }
@@ -165,16 +168,16 @@ TEST_F(test, memoryProviderOpsNullAllIPCFields) {
     void *ptr = nullptr;
     void *providerIpcData = nullptr;
     ret = umfMemoryProviderGetIPCHandle(hProvider, ptr, size, providerIpcData);
-    ASSERT_EQ(ret, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
     ret = umfMemoryProviderPutIPCHandle(hProvider, providerIpcData);
-    ASSERT_EQ(ret, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
     ret = umfMemoryProviderOpenIPCHandle(hProvider, providerIpcData, &ptr);
-    ASSERT_EQ(ret, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
     ret = umfMemoryProviderCloseIPCHandle(hProvider, ptr, size);
-    ASSERT_EQ(ret, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
     umfMemoryProviderDestroy(hProvider);
 }