Fix handling arguments of devdax_alloc()

Fix handling arguments of devdax_alloc():
- both size and alignment have to be a multiple of the page size
- alignment have to be a power of 2.

Signed-off-by: Lukasz Dorau <lukasz.dorau@intel.com>

Author: ldorau

src/provider/provider_devdax_memory.c

@@ -228,15 +228,24 @@ static umf_result_t devdax_alloc(void *provider, size_t size, size_t alignment,
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    // alignment must be a power of two and a multiple of sizeof(void *)
-    if (alignment &&
-        ((alignment & (alignment - 1)) || (alignment % sizeof(void *)))) {
-        LOG_ERR("wrong alignment: %zu (not a power of 2 or a multiple of "
-                "sizeof(void *))",
-                alignment);
+    // 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) &&
+                       (DEVDAX_PAGE_SIZE_2MB % alignment)))) {
+        LOG_ERR("wrong alignment: %zu (not a power of 2 or a multiple or a "
+                "divider of the page size (%zu))",
+                alignment, DEVDAX_PAGE_SIZE_2MB);
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
+    if (IS_NOT_ALIGNED(alignment, DEVDAX_PAGE_SIZE_2MB)) {
+        alignment = ALIGN_UP(alignment, DEVDAX_PAGE_SIZE_2MB);
+    }
+
+    if (IS_NOT_ALIGNED(size, DEVDAX_PAGE_SIZE_2MB)) {
+        size = ALIGN_UP(size, DEVDAX_PAGE_SIZE_2MB);
+    }
+
     devdax_memory_provider_t *devdax_provider =
         (devdax_memory_provider_t *)provider;
 

test/provider_devdax_memory.cpp

@@ -195,25 +195,30 @@ INSTANTIATE_TEST_SUITE_P(devdaxProviderTest, umfProviderTest,
 
 TEST_P(umfProviderTest, create_destroy) {}
 
-TEST_P(umfProviderTest, alloc_page64_align_0) {
-    test_alloc_free_success(provider.get(), page_plus_64, 0, PURGE_NONE);
+TEST_P(umfProviderTest, alloc_page_align_0) {
+    test_alloc_free_success(provider.get(), page_size, 0, PURGE_NONE);
 }
 
-TEST_P(umfProviderTest, alloc_page64_align_page_div_2) {
-    test_alloc_free_success(provider.get(), page_plus_64, page_size / 2,
+TEST_P(umfProviderTest, alloc_2page_align_page_size) {
+    test_alloc_free_success(provider.get(), 2 * page_size, page_size,
                             PURGE_NONE);
 }
 
 TEST_P(umfProviderTest, purge_lazy) {
-    test_alloc_free_success(provider.get(), page_plus_64, 0, PURGE_LAZY);
+    test_alloc_free_success(provider.get(), page_size, 0, PURGE_LAZY);
 }
 
 TEST_P(umfProviderTest, purge_force) {
-    test_alloc_free_success(provider.get(), page_plus_64, 0, PURGE_FORCE);
+    test_alloc_free_success(provider.get(), page_size, 0, PURGE_FORCE);
 }
 
 // negative tests using test_alloc_failure
 
+TEST_P(umfProviderTest, alloc_page64_align_page_div_2) {
+    test_alloc_failure(provider.get(), page_plus_64, page_size / 2,
+                       UMF_RESULT_ERROR_INVALID_ARGUMENT, 0);
+}
+
 TEST_P(umfProviderTest, alloc_page64_align_page_minus_1_WRONG_ALIGNMENT_1) {
     test_alloc_failure(provider.get(), page_plus_64, page_size - 1,
                        UMF_RESULT_ERROR_INVALID_ARGUMENT, 0);
@@ -236,7 +241,8 @@ TEST_P(umfProviderTest, alloc_3_pages_WRONG_ALIGNMENT_3_pages) {
 }
 
 TEST_P(umfProviderTest, alloc_WRONG_SIZE) {
-    test_alloc_failure(provider.get(), -1, 0,
+    size_t size = (size_t)(-1) & ~(page_size - 1);
+    test_alloc_failure(provider.get(), size, 0,
                        UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC,
                        UMF_DEVDAX_RESULT_ERROR_ALLOC_FAILED);
 }