Skip to content

Commit 56a7c1d

Browse files
ldorauldorau
committed
Add missing checks to memory_provider.c
Add missing checks to memory_provider.c. Unify checks of parameters. Signed-off-by: Lukasz Dorau <[email protected]>
1 parent 508162e commit 56a7c1d

File tree

2 files changed

+42
-31
lines changed

2 files changed

+42
-31
lines changed

‎src/memory_provider.c

Lines changed: 29 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -226,6 +226,7 @@ checkErrorAndSetLastProvider(umf_result_t result,
226226
umf_result_t umfMemoryProviderAlloc(umf_memory_provider_handle_t hProvider,
227227
size_t size, size_t alignment, void **ptr) {
228228
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
229+
UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
229230
umf_result_t res =
230231
hProvider->ops.alloc(hProvider->provider_priv, size, alignment, ptr);
231232
checkErrorAndSetLastProvider(res, hProvider);
@@ -258,6 +259,7 @@ umf_result_t
258259
umfMemoryProviderGetRecommendedPageSize(umf_memory_provider_handle_t hProvider,
259260
size_t size, size_t *pageSize) {
260261
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
262+
UMF_CHECK((pageSize != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
261263
umf_result_t res = hProvider->ops.get_recommended_page_size(
262264
hProvider->provider_priv, size, pageSize);
263265
checkErrorAndSetLastProvider(res, hProvider);
@@ -268,6 +270,7 @@ umf_result_t
268270
umfMemoryProviderGetMinPageSize(umf_memory_provider_handle_t hProvider,
269271
void *ptr, size_t *pageSize) {
270272
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
273+
UMF_CHECK((pageSize != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
271274
umf_result_t res = hProvider->ops.get_min_page_size(
272275
hProvider->provider_priv, ptr, pageSize);
273276
checkErrorAndSetLastProvider(res, hProvider);
@@ -282,6 +285,7 @@ const char *umfMemoryProviderGetName(umf_memory_provider_handle_t hProvider) {
282285
umf_result_t umfMemoryProviderPurgeLazy(umf_memory_provider_handle_t hProvider,
283286
void *ptr, size_t size) {
284287
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
288+
UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
285289
umf_result_t res =
286290
hProvider->ops.ext.purge_lazy(hProvider->provider_priv, ptr, size);
287291
checkErrorAndSetLastProvider(res, hProvider);
@@ -291,6 +295,7 @@ umf_result_t umfMemoryProviderPurgeLazy(umf_memory_provider_handle_t hProvider,
291295
umf_result_t umfMemoryProviderPurgeForce(umf_memory_provider_handle_t hProvider,
292296
void *ptr, size_t size) {
293297
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
298+
UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
294299
umf_result_t res =
295300
hProvider->ops.ext.purge_force(hProvider->provider_priv, ptr, size);
296301
checkErrorAndSetLastProvider(res, hProvider);
@@ -305,15 +310,11 @@ umf_result_t
305310
umfMemoryProviderAllocationSplit(umf_memory_provider_handle_t hProvider,
306311
void *ptr, size_t totalSize,
307312
size_t firstSize) {
308-
if (!ptr) {
309-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
310-
}
311-
if (firstSize == 0 || totalSize == 0) {
312-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
313-
}
314-
if (firstSize >= totalSize) {
315-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
316-
}
313+
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
314+
UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
315+
UMF_CHECK((firstSize != 0 && totalSize != 0),
316+
UMF_RESULT_ERROR_INVALID_ARGUMENT);
317+
UMF_CHECK((firstSize < totalSize), UMF_RESULT_ERROR_INVALID_ARGUMENT);
317318

318319
umf_result_t res = hProvider->ops.ext.allocation_split(
319320
hProvider->provider_priv, ptr, totalSize, firstSize);
@@ -325,18 +326,13 @@ umf_result_t
325326
umfMemoryProviderAllocationMerge(umf_memory_provider_handle_t hProvider,
326327
void *lowPtr, void *highPtr,
327328
size_t totalSize) {
328-
if (!lowPtr || !highPtr) {
329-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
330-
}
331-
if (totalSize == 0) {
332-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
333-
}
334-
if ((uintptr_t)lowPtr >= (uintptr_t)highPtr) {
335-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
336-
}
337-
if ((uintptr_t)highPtr - (uintptr_t)lowPtr > totalSize) {
338-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
339-
}
329+
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
330+
UMF_CHECK((lowPtr && highPtr), UMF_RESULT_ERROR_INVALID_ARGUMENT);
331+
UMF_CHECK((totalSize != 0), UMF_RESULT_ERROR_INVALID_ARGUMENT);
332+
UMF_CHECK(((uintptr_t)lowPtr < (uintptr_t)highPtr),
333+
UMF_RESULT_ERROR_INVALID_ARGUMENT);
334+
UMF_CHECK(((uintptr_t)highPtr - (uintptr_t)lowPtr < totalSize),
335+
UMF_RESULT_ERROR_INVALID_ARGUMENT);
340336

341337
umf_result_t res = hProvider->ops.ext.allocation_merge(
342338
hProvider->provider_priv, lowPtr, highPtr, totalSize);
@@ -347,6 +343,8 @@ umfMemoryProviderAllocationMerge(umf_memory_provider_handle_t hProvider,
347343
umf_result_t
348344
umfMemoryProviderGetIPCHandleSize(umf_memory_provider_handle_t hProvider,
349345
size_t *size) {
346+
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
347+
UMF_CHECK((size != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
350348
return hProvider->ops.ipc.get_ipc_handle_size(hProvider->provider_priv,
351349
size);
352350
}
@@ -355,27 +353,37 @@ umf_result_t
355353
umfMemoryProviderGetIPCHandle(umf_memory_provider_handle_t hProvider,
356354
const void *ptr, size_t size,
357355
void *providerIpcData) {
356+
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
357+
UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
358+
UMF_CHECK((providerIpcData != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
358359
return hProvider->ops.ipc.get_ipc_handle(hProvider->provider_priv, ptr,
359360
size, providerIpcData);
360361
}
361362

362363
umf_result_t
363364
umfMemoryProviderPutIPCHandle(umf_memory_provider_handle_t hProvider,
364365
void *providerIpcData) {
366+
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
367+
UMF_CHECK((providerIpcData != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
365368
return hProvider->ops.ipc.put_ipc_handle(hProvider->provider_priv,
366369
providerIpcData);
367370
}
368371

369372
umf_result_t
370373
umfMemoryProviderOpenIPCHandle(umf_memory_provider_handle_t hProvider,
371374
void *providerIpcData, void **ptr) {
375+
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
376+
UMF_CHECK((providerIpcData != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
377+
UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
372378
return hProvider->ops.ipc.open_ipc_handle(hProvider->provider_priv,
373379
providerIpcData, ptr);
374380
}
375381

376382
umf_result_t
377383
umfMemoryProviderCloseIPCHandle(umf_memory_provider_handle_t hProvider,
378384
void *ptr, size_t size) {
385+
UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
386+
UMF_CHECK((ptr != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
379387
return hProvider->ops.ipc.close_ipc_handle(hProvider->provider_priv, ptr,
380388
size);
381389
}

‎test/memoryProviderAPI.cpp

Lines changed: 13 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -43,14 +43,15 @@ TEST_F(test, memoryProviderTrace) {
4343
ASSERT_EQ(calls["get_last_native_error"], 1);
4444
ASSERT_EQ(calls.size(), ++call_count);
4545

46+
size_t page_size;
4647
ret = umfMemoryProviderGetRecommendedPageSize(tracingProvider.get(), 0,
47-
nullptr);
48+
&page_size);
4849
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
4950
ASSERT_EQ(calls["get_recommended_page_size"], 1);
5051
ASSERT_EQ(calls.size(), ++call_count);
5152

5253
ret = umfMemoryProviderGetMinPageSize(tracingProvider.get(), nullptr,
53-
nullptr);
54+
&page_size);
5455
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
5556
ASSERT_EQ(calls["get_min_page_size"], 1);
5657
ASSERT_EQ(calls.size(), ++call_count);
@@ -60,12 +61,14 @@ TEST_F(test, memoryProviderTrace) {
6061
ASSERT_EQ(calls.size(), ++call_count);
6162
ASSERT_EQ(std::string(pName), std::string("null"));
6263

63-
ret = umfMemoryProviderPurgeLazy(tracingProvider.get(), nullptr, 0);
64+
ret = umfMemoryProviderPurgeLazy(tracingProvider.get(), &page_size,
65+
sizeof(page_size));
6466
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
6567
ASSERT_EQ(calls["purge_lazy"], 1);
6668
ASSERT_EQ(calls.size(), ++call_count);
6769

68-
ret = umfMemoryProviderPurgeForce(tracingProvider.get(), nullptr, 0);
70+
ret = umfMemoryProviderPurgeForce(tracingProvider.get(), &page_size,
71+
sizeof(page_size));
6972
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
7073
ASSERT_EQ(calls["purge_force"], 1);
7174
ASSERT_EQ(calls.size(), ++call_count);
@@ -107,7 +110,7 @@ TEST_F(test, memoryProviderOpsNullPurgeLazyField) {
107110
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
108111

109112
ret = umfMemoryProviderPurgeLazy(hProvider, nullptr, 0);
110-
ASSERT_EQ(ret, UMF_RESULT_ERROR_NOT_SUPPORTED);
113+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
111114

112115
umfMemoryProviderDestroy(hProvider);
113116
}
@@ -120,7 +123,7 @@ TEST_F(test, memoryProviderOpsNullPurgeForceField) {
120123
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
121124

122125
ret = umfMemoryProviderPurgeForce(hProvider, nullptr, 0);
123-
ASSERT_EQ(ret, UMF_RESULT_ERROR_NOT_SUPPORTED);
126+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
124127

125128
umfMemoryProviderDestroy(hProvider);
126129
}
@@ -165,16 +168,16 @@ TEST_F(test, memoryProviderOpsNullAllIPCFields) {
165168
void *ptr = nullptr;
166169
void *providerIpcData = nullptr;
167170
ret = umfMemoryProviderGetIPCHandle(hProvider, ptr, size, providerIpcData);
168-
ASSERT_EQ(ret, UMF_RESULT_ERROR_NOT_SUPPORTED);
171+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
169172

170173
ret = umfMemoryProviderPutIPCHandle(hProvider, providerIpcData);
171-
ASSERT_EQ(ret, UMF_RESULT_ERROR_NOT_SUPPORTED);
174+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
172175

173176
ret = umfMemoryProviderOpenIPCHandle(hProvider, providerIpcData, &ptr);
174-
ASSERT_EQ(ret, UMF_RESULT_ERROR_NOT_SUPPORTED);
177+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
175178

176179
ret = umfMemoryProviderCloseIPCHandle(hProvider, ptr, size);
177-
ASSERT_EQ(ret, UMF_RESULT_ERROR_NOT_SUPPORTED);
180+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
178181

179182
umfMemoryProviderDestroy(hProvider);
180183
}

0 commit comments

Comments
 (0)