1 /*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <gtest/gtest.h>
18
19 #include <errno.h>
20 #include <unistd.h>
21 #include <fcntl.h>
22 #include <sys/mman.h>
23
24 #include "pmemalloc.h"
25
26 class DepsStub : public PmemUserspaceAllocator::Deps, public PmemKernelAllocator::Deps {
27
28 public:
29
getPmemTotalSize(int fd,size_t * size)30 virtual size_t getPmemTotalSize(int fd, size_t* size) {
31 return 0;
32 }
33
connectPmem(int fd,int master_fd)34 virtual int connectPmem(int fd, int master_fd) {
35 return 0;
36 }
37
mapPmem(int fd,int offset,size_t size)38 virtual int mapPmem(int fd, int offset, size_t size) {
39 return 0;
40 }
41
unmapPmem(int fd,int offset,size_t size)42 virtual int unmapPmem(int fd, int offset, size_t size) {
43 return 0;
44 }
45
getErrno()46 virtual int getErrno() {
47 return 0;
48 }
49
mmap(void * start,size_t length,int prot,int flags,int fd,off_t offset)50 virtual void* mmap(void* start, size_t length, int prot, int flags, int fd,
51 off_t offset) {
52 return 0;
53 }
54
munmap(void * start,size_t length)55 virtual int munmap(void* start, size_t length) {
56 return 0;
57 }
58
open(const char * pathname,int flags,int mode)59 virtual int open(const char* pathname, int flags, int mode) {
60 return 0;
61 }
62
close(int fd)63 virtual int close(int fd) {
64 return 0;
65 }
66 };
67
68 /******************************************************************************/
69
70 class AllocatorStub : public PmemUserspaceAllocator::Deps::Allocator {
setSize(size_t size)71 virtual ssize_t setSize(size_t size) {
72 return 0;
73 }
74
size() const75 virtual size_t size() const {
76 return 0;
77 }
78
allocate(size_t size,uint32_t flags=0)79 virtual ssize_t allocate(size_t size, uint32_t flags = 0) {
80 return 0;
81 }
82
deallocate(size_t offset)83 virtual ssize_t deallocate(size_t offset) {
84 return 0;
85 }
86 };
87
88 /******************************************************************************/
89
90 static const char* fakePmemDev = "/foo/bar";
91
92 /******************************************************************************/
93
94 struct Deps_InitPmemAreaLockedWithSuccessfulCompletion : public DepsStub {
95
openDeps_InitPmemAreaLockedWithSuccessfulCompletion96 virtual int open(const char* pathname, int flags, int mode) {
97 EXPECT_EQ(fakePmemDev, pathname);
98 EXPECT_EQ(O_RDWR, flags);
99 EXPECT_EQ(0, mode);
100 return 1234;
101 }
102
getPmemTotalSizeDeps_InitPmemAreaLockedWithSuccessfulCompletion103 virtual size_t getPmemTotalSize(int fd, size_t* size) {
104 EXPECT_EQ(1234, fd);
105 *size = 16 << 20;
106 return 0;
107 }
108
mmapDeps_InitPmemAreaLockedWithSuccessfulCompletion109 virtual void* mmap(void* start, size_t length, int prot, int flags, int fd,
110 off_t offset) {
111 EXPECT_EQ(1234, fd);
112 return (void*)0x87654321;
113 }
114
115 };
116
117 struct Allocator_InitPmemAreaLockedWithSuccessfulCompletion : public AllocatorStub {
118
setSizeAllocator_InitPmemAreaLockedWithSuccessfulCompletion119 virtual ssize_t setSize(size_t size) {
120 EXPECT_EQ(size_t(16 << 20), size);
121 return 0;
122 }
123 };
124
TEST(test_pmem_userspace_allocator,testInitPmemAreaLockedWithSuccessfulCompletion)125 TEST(test_pmem_userspace_allocator, testInitPmemAreaLockedWithSuccessfulCompletion) {
126 Deps_InitPmemAreaLockedWithSuccessfulCompletion depsMock;
127 Allocator_InitPmemAreaLockedWithSuccessfulCompletion allocMock;
128 PmemUserspaceAllocator pma(depsMock, allocMock, fakePmemDev);
129
130 int result = pma.init_pmem_area_locked();
131 ASSERT_EQ(0, result);
132 }
133
134 /******************************************************************************/
135
136 struct Deps_InitPmemAreaLockedWithEnomemOnMmap : public DepsStub {
137
openDeps_InitPmemAreaLockedWithEnomemOnMmap138 virtual int open(const char* pathname, int flags, int mode) {
139 EXPECT_EQ(fakePmemDev, pathname);
140 EXPECT_EQ(O_RDWR, flags);
141 EXPECT_EQ(0, mode);
142 return 1234;
143 }
144
getPmemTotalSizeDeps_InitPmemAreaLockedWithEnomemOnMmap145 virtual size_t getPmemTotalSize(int fd, size_t* size) {
146 EXPECT_EQ(1234, fd);
147 *size = 16 << 20;
148 return 0;
149 }
150
getErrnoDeps_InitPmemAreaLockedWithEnomemOnMmap151 virtual int getErrno() {
152 return ENOMEM;
153 }
154
mmapDeps_InitPmemAreaLockedWithEnomemOnMmap155 virtual void* mmap(void* start, size_t length, int prot, int flags, int fd,
156 off_t offset) {
157 return (void*)MAP_FAILED;
158 }
159
160 };
161
162 struct Allocator_InitPmemAreaLockedWithEnomemOnMmap : public AllocatorStub {
163
setSizeAllocator_InitPmemAreaLockedWithEnomemOnMmap164 virtual ssize_t setSize(size_t size) {
165 EXPECT_EQ(size_t(16 << 20), size);
166 return 0;
167 }
168 };
169
TEST(test_pmem_userspace_allocator,testInitPmemAreaLockedWthEnomemOnMmap)170 TEST(test_pmem_userspace_allocator, testInitPmemAreaLockedWthEnomemOnMmap) {
171 Deps_InitPmemAreaLockedWithEnomemOnMmap depsMock;
172 Allocator_InitPmemAreaLockedWithEnomemOnMmap allocMock;
173 PmemUserspaceAllocator pma(depsMock, allocMock, fakePmemDev);
174
175 int result = pma.init_pmem_area_locked();
176 ASSERT_EQ(-ENOMEM, result);
177 }
178
179 /******************************************************************************/
180
181 struct Deps_InitPmemAreaLockedWithEaccesOnGetPmemTotalSize : public DepsStub {
182
openDeps_InitPmemAreaLockedWithEaccesOnGetPmemTotalSize183 virtual int open(const char* pathname, int flags, int mode) {
184 EXPECT_EQ(fakePmemDev, pathname);
185 EXPECT_EQ(O_RDWR, flags);
186 EXPECT_EQ(0, mode);
187 return 1234;
188 }
189
getPmemTotalSizeDeps_InitPmemAreaLockedWithEaccesOnGetPmemTotalSize190 virtual size_t getPmemTotalSize(int fd, size_t* size) {
191 EXPECT_EQ(1234, fd);
192 return -EACCES;
193 }
194 };
195
TEST(test_pmem_userspace_allocator,testInitPmemAreaLockedWthEaccesOnGetPmemTotalSize)196 TEST(test_pmem_userspace_allocator, testInitPmemAreaLockedWthEaccesOnGetPmemTotalSize) {
197 Deps_InitPmemAreaLockedWithEaccesOnGetPmemTotalSize depsMock;
198 AllocatorStub allocStub;
199 PmemUserspaceAllocator pma(depsMock, allocStub, fakePmemDev);
200
201 int result = pma.init_pmem_area_locked();
202 ASSERT_EQ(-EACCES, result);
203 }
204
205 /******************************************************************************/
206
207 struct Deps_InitPmemAreaLockedWithEaccesOnOpen : public DepsStub {
208
getErrnoDeps_InitPmemAreaLockedWithEaccesOnOpen209 virtual int getErrno() {
210 return EACCES;
211 }
212
openDeps_InitPmemAreaLockedWithEaccesOnOpen213 virtual int open(const char* pathname, int flags, int mode) {
214 EXPECT_EQ(fakePmemDev, pathname);
215 EXPECT_EQ(O_RDWR, flags);
216 EXPECT_EQ(0, mode);
217 return -1;
218 }
219 };
220
TEST(test_pmem_userspace_allocator,testInitPmemAreaLockedWithEaccesOnOpenMaster)221 TEST(test_pmem_userspace_allocator, testInitPmemAreaLockedWithEaccesOnOpenMaster) {
222 Deps_InitPmemAreaLockedWithEaccesOnOpen depsMock;
223 AllocatorStub allocStub;
224 PmemUserspaceAllocator pma(depsMock, allocStub, fakePmemDev);
225
226 int result = pma.init_pmem_area_locked();
227 ASSERT_EQ(-EACCES, result);
228 }
229
230 /******************************************************************************/
231
232 typedef Deps_InitPmemAreaLockedWithSuccessfulCompletion Deps_InitPmemAreaWithSuccessfulInitialCompletion;
233
TEST(test_pmem_userspace_allocator,testInitPmemAreaWithSuccessfulInitialCompletion)234 TEST(test_pmem_userspace_allocator, testInitPmemAreaWithSuccessfulInitialCompletion) {
235 Deps_InitPmemAreaWithSuccessfulInitialCompletion depsMock;
236 AllocatorStub allocStub;
237 PmemUserspaceAllocator pma(depsMock, allocStub, fakePmemDev);
238
239 int result = pma.init_pmem_area();
240 ASSERT_EQ(0, result);
241 }
242
243 /******************************************************************************/
244
245 typedef Deps_InitPmemAreaLockedWithEaccesOnOpen Deps_InitPmemAreaWithEaccesOnInitLocked;
246
TEST(test_pmem_userspace_allocator,testInitPmemAreaWithEaccesOnInitLocked)247 TEST(test_pmem_userspace_allocator, testInitPmemAreaWithEaccesOnInitLocked) {
248 Deps_InitPmemAreaWithEaccesOnInitLocked depsMock;
249 AllocatorStub allocStub;
250 PmemUserspaceAllocator pma(depsMock, allocStub, fakePmemDev);
251
252 int result = pma.init_pmem_area();
253 ASSERT_EQ(-EACCES, result);
254 }
255
256 /******************************************************************************/
257
TEST(test_pmem_userspace_allocator,testInitPmemAreaAfterSuccessfulInitialCompletion)258 TEST(test_pmem_userspace_allocator, testInitPmemAreaAfterSuccessfulInitialCompletion) {
259 DepsStub depsStub;
260 AllocatorStub allocStub;
261 PmemUserspaceAllocator pma(depsStub, allocStub, fakePmemDev);
262
263 pma.set_master_values(1234, 0); // Indicate that the pma has been successfully init'd
264
265 int result = pma.init_pmem_area();
266 ASSERT_EQ(0, result);
267 //XXX JMG: Add this back in maybe? ASSERT_EQ(1234, pmi.master); // Make sure the master fd wasn't changed
268 }
269
270 /******************************************************************************/
271
TEST(test_pmem_userspace_allocator,testInitPmemAreaAfterFailedInit)272 TEST(test_pmem_userspace_allocator, testInitPmemAreaAfterFailedInit) {
273 DepsStub depsStub;
274 AllocatorStub allocStub;
275 PmemUserspaceAllocator pma(depsStub, allocStub, fakePmemDev);
276
277 pma.set_master_values(-EACCES, 0); // Indicate that the pma has failed init
278
279 int result = pma.init_pmem_area();
280 ASSERT_EQ(-EACCES, result);
281 }
282
283 /******************************************************************************/
284
285 struct Deps_InitPmemAreaLockedWithSuccessfulCompletionWithNoFlags : public DepsStub {
286
openDeps_InitPmemAreaLockedWithSuccessfulCompletionWithNoFlags287 virtual int open(const char* pathname, int flags, int mode) {
288 EXPECT_EQ(fakePmemDev, pathname);
289 EXPECT_EQ(O_RDWR, flags & O_RDWR);
290 EXPECT_EQ(0, mode);
291 return 5678;
292 }
293
connectPmemDeps_InitPmemAreaLockedWithSuccessfulCompletionWithNoFlags294 virtual int connectPmem(int fd, int master_fd) {
295 EXPECT_EQ(5678, fd);
296 EXPECT_EQ(1234, master_fd);
297 return 0;
298 }
299
mapPmemDeps_InitPmemAreaLockedWithSuccessfulCompletionWithNoFlags300 virtual int mapPmem(int fd, int offset, size_t size) {
301 EXPECT_EQ(5678, fd);
302 EXPECT_EQ(0x300, offset);
303 EXPECT_EQ(size_t(0x100), size);
304 return 0;
305 }
306 };
307
308
309 struct Allocator_AllocPmemBufferWithSuccessfulCompletionWithNoFlags : public AllocatorStub {
310
allocateAllocator_AllocPmemBufferWithSuccessfulCompletionWithNoFlags311 virtual ssize_t allocate(size_t size, uint32_t flags = 0) {
312 EXPECT_EQ(size_t(0x100), size);
313 EXPECT_EQ(uint32_t(0x0), flags);
314 return 0x300;
315 }
316 };
317
TEST(test_pmem_userspace_allocator,testAllocPmemBufferWithSuccessfulCompletionWithNoFlags)318 TEST(test_pmem_userspace_allocator, testAllocPmemBufferWithSuccessfulCompletionWithNoFlags) {
319 Deps_InitPmemAreaLockedWithSuccessfulCompletionWithNoFlags depsMock;
320 Allocator_AllocPmemBufferWithSuccessfulCompletionWithNoFlags allocMock;
321 PmemUserspaceAllocator pma(depsMock, allocMock, fakePmemDev);
322
323 uint8_t buf[0x300 + 0x100]; // Create a buffer to get memzero'd
324 pma.set_master_values(1234, buf); // Indicate that the pma has been successfully init'd
325
326 void* base = 0;
327 int offset = -9182, fd = -9182;
328 int size = 0x100;
329 int flags = 0;
330 int result = pma.alloc_pmem_buffer(size, flags, &base, &offset, &fd);
331 ASSERT_EQ(0, result);
332 ASSERT_EQ(0x300, offset);
333 ASSERT_EQ(5678, fd);
334 for (int i = 0x300; i < 0x400; ++i) {
335 ASSERT_EQ(uint8_t(0), buf[i]);
336 }
337 }
338
339 /******************************************************************************/
340
341 typedef Deps_InitPmemAreaLockedWithSuccessfulCompletionWithNoFlags Deps_InitPmemAreaLockedWithSuccessfulCompletionWithAllFlags;
342
343 typedef Allocator_AllocPmemBufferWithSuccessfulCompletionWithNoFlags Allocator_AllocPmemBufferWithSuccessfulCompletionWithAllFlags;
344
TEST(test_pmem_userspace_allocator,testAllocPmemBufferWithSuccessfulCompletionWithAllFlags)345 TEST(test_pmem_userspace_allocator, testAllocPmemBufferWithSuccessfulCompletionWithAllFlags) {
346 Deps_InitPmemAreaLockedWithSuccessfulCompletionWithAllFlags depsMock;
347 Allocator_AllocPmemBufferWithSuccessfulCompletionWithAllFlags allocMock;
348 PmemUserspaceAllocator pma(depsMock, allocMock, fakePmemDev);
349
350 uint8_t buf[0x300 + 0x100]; // Create a buffer to get memzero'd
351 pma.set_master_values(1234, buf); // Indicate that the pma has been successfully init'd
352
353 void* base = 0;
354 int offset = -9182, fd = -9182;
355 int size = 0x100;
356 int flags = ~0;
357 int result = pma.alloc_pmem_buffer(size, flags, &base, &offset, &fd);
358 ASSERT_EQ(0, result);
359 ASSERT_EQ(0x300, offset);
360 ASSERT_EQ(5678, fd);
361 for (int i = 0x300; i < 0x400; ++i) {
362 ASSERT_EQ(0, buf[i]);
363 }
364 }
365
366 /******************************************************************************/
367
368 struct Deps_InitPmemAreaLockedWithEnodevOnOpen : public Deps_InitPmemAreaLockedWithSuccessfulCompletionWithNoFlags {
369
getErrnoDeps_InitPmemAreaLockedWithEnodevOnOpen370 virtual int getErrno() {
371 return ENODEV;
372 }
373
openDeps_InitPmemAreaLockedWithEnodevOnOpen374 virtual int open(const char* pathname, int flags, int mode) {
375 EXPECT_EQ(fakePmemDev, pathname);
376 EXPECT_EQ(O_RDWR, flags & O_RDWR);
377 EXPECT_EQ(0, mode);
378 return -1;
379 }
380 };
381
382 typedef Allocator_AllocPmemBufferWithSuccessfulCompletionWithNoFlags Allocator_AllocPmemBufferWithEnodevOnOpen;
383
TEST(test_pmem_userspace_allocator,testAllocPmemBufferWithSuccessfulCompletionWithEnodevOnOpen)384 TEST(test_pmem_userspace_allocator, testAllocPmemBufferWithSuccessfulCompletionWithEnodevOnOpen) {
385 Deps_InitPmemAreaLockedWithEnodevOnOpen depsMock;
386 Allocator_AllocPmemBufferWithEnodevOnOpen allocMock;
387 PmemUserspaceAllocator pma(depsMock, allocMock, fakePmemDev);
388
389 uint8_t buf[0x300 + 0x100]; // Create a buffer to get memzero'd
390 pma.set_master_values(1234, buf); // Indicate that the pma has been successfully init'd
391
392 void* base = 0;
393 int offset = -9182, fd = -9182;
394 int size = 0x100;
395 int flags = ~0;
396 int result = pma.alloc_pmem_buffer(size, flags, &base, &offset, &fd);
397 ASSERT_EQ(-ENODEV, result);
398 }
399
400 /******************************************************************************/
401
402 struct Deps_InitPmemAreaLockedWithEnomemOnConnectPmem : public Deps_InitPmemAreaLockedWithSuccessfulCompletionWithNoFlags {
403
getErrnoDeps_InitPmemAreaLockedWithEnomemOnConnectPmem404 virtual int getErrno() {
405 return ENOMEM;
406 }
407
connectPmemDeps_InitPmemAreaLockedWithEnomemOnConnectPmem408 virtual int connectPmem(int fd, int master_fd) {
409 EXPECT_EQ(5678, fd);
410 EXPECT_EQ(1234, master_fd);
411 return -1;
412 }
413 };
414
415 typedef Allocator_AllocPmemBufferWithSuccessfulCompletionWithNoFlags Allocator_AllocPmemBufferWithEnomemOnConnectPmem;
416
TEST(test_pmem_userspace_allocator,testAllocPmemBufferWithSuccessfulCompletionWithEnomemOnConnectPmem)417 TEST(test_pmem_userspace_allocator, testAllocPmemBufferWithSuccessfulCompletionWithEnomemOnConnectPmem) {
418 Deps_InitPmemAreaLockedWithEnomemOnConnectPmem depsMock;
419 Allocator_AllocPmemBufferWithEnomemOnConnectPmem allocMock;
420 PmemUserspaceAllocator pma(depsMock, allocMock, fakePmemDev);
421
422 uint8_t buf[0x300 + 0x100]; // Create a buffer to get memzero'd
423 pma.set_master_values(1234, buf); // Indicate that the pma has been successfully init'd
424
425 void* base = 0;
426 int offset = -9182, fd = -9182;
427 int size = 0x100;
428 int flags = ~0;
429 int result = pma.alloc_pmem_buffer(size, flags, &base, &offset, &fd);
430 ASSERT_EQ(-ENOMEM, result);
431 }
432
433 /******************************************************************************/
434
435 struct Deps_InitPmemAreaLockedWithEnomemOnMapPmem : public Deps_InitPmemAreaLockedWithSuccessfulCompletionWithNoFlags {
436
getErrnoDeps_InitPmemAreaLockedWithEnomemOnMapPmem437 virtual int getErrno() {
438 return ENOMEM;
439 }
440
mapPmemDeps_InitPmemAreaLockedWithEnomemOnMapPmem441 virtual int mapPmem(int fd, int offset, size_t size) {
442 EXPECT_EQ(5678, fd);
443 EXPECT_EQ(0x300, offset);
444 EXPECT_EQ(size_t(0x100), size);
445 return -1;
446 }
447 };
448
449 typedef Allocator_AllocPmemBufferWithSuccessfulCompletionWithNoFlags Allocator_AllocPmemBufferWithEnomemOnMapPmem;
450
TEST(test_pmem_userspace_allocator,testAllocPmemBufferWithEnomemOnMapPmem)451 TEST(test_pmem_userspace_allocator, testAllocPmemBufferWithEnomemOnMapPmem) {
452 Deps_InitPmemAreaLockedWithEnomemOnMapPmem depsMock;
453 Allocator_AllocPmemBufferWithEnomemOnMapPmem allocMock;
454 PmemUserspaceAllocator pma(depsMock, allocMock, fakePmemDev);
455
456 uint8_t buf[0x300 + 0x100]; // Create a buffer to get memzero'd
457 pma.set_master_values(1234, buf); // Indicate that the pma has been successfully init'd
458
459 void* base = 0;
460 int offset = -9182, fd = -9182;
461 int size = 0x100;
462 int flags = ~0;
463 int result = pma.alloc_pmem_buffer(size, flags, &base, &offset, &fd);
464 ASSERT_EQ(-ENOMEM, result);
465 }
466
467 /******************************************************************************/
468
469 struct Deps_KernelAllocPmemBufferWithSuccessfulCompletionWithNoFlags : public DepsStub {
470
471 void* mmapResult;
472
Deps_KernelAllocPmemBufferWithSuccessfulCompletionWithNoFlagsDeps_KernelAllocPmemBufferWithSuccessfulCompletionWithNoFlags473 Deps_KernelAllocPmemBufferWithSuccessfulCompletionWithNoFlags(void* mmapResult) :
474 mmapResult(mmapResult) {}
475
openDeps_KernelAllocPmemBufferWithSuccessfulCompletionWithNoFlags476 virtual int open(const char* pathname, int flags, int mode) {
477 EXPECT_EQ(fakePmemDev, pathname);
478 EXPECT_EQ(O_RDWR, flags & O_RDWR);
479 EXPECT_EQ(0, mode);
480 return 5678;
481 }
482
mmapDeps_KernelAllocPmemBufferWithSuccessfulCompletionWithNoFlags483 virtual void* mmap(void* start, size_t length, int prot, int flags, int fd,
484 off_t offset) {
485 EXPECT_EQ(5678, fd);
486 return mmapResult;
487 }
488 };
489
TEST(test_pmem_kernel_allocator,testAllocPmemBufferWithSuccessfulCompletionWithNoFlags)490 TEST(test_pmem_kernel_allocator, testAllocPmemBufferWithSuccessfulCompletionWithNoFlags) {
491 uint8_t buf[0x100]; // Create a buffer to get memzero'd
492 Deps_KernelAllocPmemBufferWithSuccessfulCompletionWithNoFlags depsMock(buf);
493 PmemKernelAllocator pma(depsMock, fakePmemDev);
494
495 void* base = 0;
496 int offset = -9182, fd = -9182;
497 int size = 0x100;
498 int flags = 0;
499 int result = pma.alloc_pmem_buffer(size, flags, &base, &offset, &fd);
500 ASSERT_EQ(0, result);
501 ASSERT_EQ(buf, base);
502 ASSERT_EQ(0, offset);
503 ASSERT_EQ(5678, fd);
504 for (int i = 0; i < 0x100; ++i) {
505 ASSERT_EQ(0, buf[i]);
506 }
507 }
508
509 /******************************************************************************/
510
511 typedef Deps_KernelAllocPmemBufferWithSuccessfulCompletionWithNoFlags Deps_KernelAllocPmemBufferWithSuccessfulCompletionWithAllFlags;
512
TEST(test_pmem_kernel_allocator,testAllocPmemBufferWithSuccessfulCompletionWithAllFlags)513 TEST(test_pmem_kernel_allocator, testAllocPmemBufferWithSuccessfulCompletionWithAllFlags) {
514 uint8_t buf[0x100]; // Create a buffer to get memzero'd
515 Deps_KernelAllocPmemBufferWithSuccessfulCompletionWithAllFlags depsMock(buf);
516 PmemKernelAllocator pma(depsMock, fakePmemDev);
517
518 void* base = 0;
519 int offset = -9182, fd = -9182;
520 int size = 0x100;
521 int flags = ~0;
522 int result = pma.alloc_pmem_buffer(size, flags, &base, &offset, &fd);
523 ASSERT_EQ(0, result);
524 ASSERT_EQ(buf, base);
525 ASSERT_EQ(0, offset);
526 ASSERT_EQ(5678, fd);
527 for (int i = 0; i < 0x100; ++i) {
528 ASSERT_EQ(0, buf[i]);
529 }
530 }
531
532 /******************************************************************************/
533
534 struct Deps_KernelAllocPmemBufferWithEpermOnOpen : public DepsStub {
535
getErrnoDeps_KernelAllocPmemBufferWithEpermOnOpen536 virtual int getErrno() {
537 return EPERM;
538 }
539
openDeps_KernelAllocPmemBufferWithEpermOnOpen540 virtual int open(const char* pathname, int flags, int mode) {
541 EXPECT_EQ(fakePmemDev, pathname);
542 EXPECT_EQ(O_RDWR, flags & O_RDWR);
543 EXPECT_EQ(0, mode);
544 return -1;
545 }
546 };
547
548
TEST(test_pmem_kernel_allocator,testAllocPmemBufferWithEpermOnOpen)549 TEST(test_pmem_kernel_allocator, testAllocPmemBufferWithEpermOnOpen) {
550 Deps_KernelAllocPmemBufferWithEpermOnOpen depsMock;
551 PmemKernelAllocator pma(depsMock, fakePmemDev);
552
553 void* base = 0;
554 int offset = -9182, fd = -9182;
555 int size = 0x100;
556 int flags = ~0;
557 int result = pma.alloc_pmem_buffer(size, flags, &base, &offset, &fd);
558 ASSERT_EQ(-EPERM, result);
559 ASSERT_EQ(0, base);
560 ASSERT_EQ(0, offset);
561 ASSERT_EQ(-1, fd);
562 }
563
564 /******************************************************************************/
565
566 struct Deps_KernelAllocPmemBufferWithEnomemOnMmap : DepsStub {
567
openDeps_KernelAllocPmemBufferWithEnomemOnMmap568 virtual int open(const char* pathname, int flags, int mode) {
569 EXPECT_EQ(fakePmemDev, pathname);
570 EXPECT_EQ(O_RDWR, flags & O_RDWR);
571 EXPECT_EQ(0, mode);
572 return 5678;
573 }
574
mmapDeps_KernelAllocPmemBufferWithEnomemOnMmap575 virtual void* mmap(void* start, size_t length, int prot, int flags, int fd,
576 off_t offset) {
577 return (void*)MAP_FAILED;
578 }
579
getErrnoDeps_KernelAllocPmemBufferWithEnomemOnMmap580 virtual int getErrno() {
581 return ENOMEM;
582 }
583 };
584
585
TEST(test_pmem_kernel_allocator,testAllocPmemBufferWithEnomemOnMmap)586 TEST(test_pmem_kernel_allocator, testAllocPmemBufferWithEnomemOnMmap) {
587 Deps_KernelAllocPmemBufferWithEnomemOnMmap depsMock;
588 PmemKernelAllocator pma(depsMock, fakePmemDev);
589
590 void* base = 0;
591 int offset = -9182, fd = -9182;
592 int size = 0x100;
593 int flags = ~0;
594 int result = pma.alloc_pmem_buffer(size, flags, &base, &offset, &fd);
595 ASSERT_EQ(-ENOMEM, result);
596 ASSERT_EQ(0, base);
597 ASSERT_EQ(0, offset);
598 ASSERT_EQ(-1, fd);
599 }
600
601 /******************************************************************************/
602