Refactor to avoid some duplicated code.

Invert ashmem_pin_unpin() logic assuming the memory is pinned by default.

1 files changed, 76 insertions, 112 deletions

diff --git a/ashmemtest-basic/ashmemtest.c b/ashmemtest-basic/ashmemtest.c
index 0b27b2d..b95909d 100644
--- a/ashmemtest-basic/ashmemtest.c
+++ b/ashmemtest-basic/ashmemtest.c
@@ -27,6 +27,9 @@
 #define ASHMEM_MAJOR 10 /* misc device, should match MISC_DEVICE in linux/major.h */
 #endif
 
+/* Stolen from the kernel */
+#define DEFAULT_PROT_MASK (PROT_READ | PROT_WRITE | PROT_EXEC)
+
 #ifndef _LINUX_ASHMEM_H
 /* only if not defined already */
 struct ashmem_pin {
@@ -35,8 +38,15 @@ struct ashmem_pin {
 };
 #endif
 
+/* current test run */
 int testno = -1;
 
+/* device name */
+char ashmemdev[64];
+
+/* guess what */
+size_t pagesize;
+
 void fatal (int error, const char *fmt, ...)
 {
     va_list ap;
@@ -61,13 +71,22 @@ int test_open (char *name, mode_t mode)
     return fd;
 }
 
+int test_open_and_set_size (char *name, mode_t mode, size_t size)
+{
+    int ret, fd = test_open (name, mode);
+    ret = ioctl (fd, ASHMEM_SET_SIZE, size);
+    if (ret < 0)
+	fatal (errno, "can''t set size to %ld bytes\n", size);
+    return fd;
+}
+
 void test_close (int fd)
 {
     if (close (fd) < 0)
 	fatal (errno, "can't close fd %d", fd);
 }
 
-void ashmem_basic (char *ashmemdev)
+void ashmem_basic (void)
 {
     int fd;
     struct stat st;
@@ -91,7 +110,7 @@ void ashmem_basic (char *ashmemdev)
     printf ("%d [%s]: test passed\n", testno, __func__);
 }
 
-void ashmem_anonymous_region (char *ashmemdev, size_t pagesize)
+void ashmem_anonymous_region (void)
 {
     int fd, ret;
     char name[ASHMEM_NAME_LEN];
@@ -108,10 +127,7 @@ void ashmem_anonymous_region (char *ashmemdev, size_t pagesize)
     test_close (fd);
 
     /* test whether normal anonymous region has the default name */
-    fd = test_open (ashmemdev, O_RDWR);
-    ret = ioctl (fd, ASHMEM_SET_SIZE, pagesize);
-    if (ret < 0)
-	fatal (errno, "can't allocate %ld-bytes region", pagesize);
+    fd = test_open_and_set_size (ashmemdev, O_RDWR, pagesize);
     ret = ioctl (fd, ASHMEM_GET_NAME, name);
     if (ret < 0)
 	fatal (errno, "can't get region name");
@@ -122,7 +138,7 @@ void ashmem_anonymous_region (char *ashmemdev, size_t pagesize)
     printf ("%d [%s]: test passed\n", testno, __func__);
 }
 
-void ashmem_named_region (char *ashmemdev, size_t pagesize)
+void ashmem_named_region (void)
 {
     int fd, ret, i;
     char name[ASHMEM_NAME_LEN], name2[ASHMEM_NAME_LEN];
@@ -138,13 +154,10 @@ void ashmem_named_region (char *ashmemdev, size_t pagesize)
 
     /* test whether normal name matches between set and get */
     snprintf (name, ASHMEM_NAME_LEN, "Test memory region");
-    fd = test_open (ashmemdev, O_RDWR);
+    fd = test_open_and_set_size (ashmemdev, O_RDWR, pagesize);
     ret = ioctl (fd, ASHMEM_SET_NAME, name);
     if (ret < 0)
 	fatal (errno, "can't set name '%s'", name);
-    ret = ioctl (fd, ASHMEM_SET_SIZE, pagesize);
-    if (ret < 0)
-	fatal (errno, "can't set size to %ld bytes", pagesize);
     ret = ioctl (fd, ASHMEM_GET_NAME, name2);
     if (strcmp (name, name2))
 	fatal (0, "name mismatch: expect '%s', got '%s'", name, name2);
@@ -153,7 +166,7 @@ void ashmem_named_region (char *ashmemdev, size_t pagesize)
     printf ("%d [%s]: test passed\n", testno, __func__);
 }
 
-void ashmem_pin_unpin (char *ashmemdev, size_t pagesize)
+void ashmem_pin_unpin (void)
 {
     int fd, ret;
     size_t size;
@@ -162,88 +175,75 @@ void ashmem_pin_unpin (char *ashmemdev, size_t pagesize)
 
     testno++;
 
-    /* normal pin/unpin for the whole single-page region */
-    fd = test_open (ashmemdev, O_RDWR);
-    ret = ioctl (fd, ASHMEM_SET_SIZE, pagesize);
-    if (ret < 0)
-	fatal (errno, "can't allocate %ld-bytes region", pagesize);
+    /* note the memory is pinned by default */
+
+    /* normal unpin/pin for the whole single-page region */
+    fd = test_open_and_set_size (ashmemdev, O_RDWR, pagesize);
     mem = mmap (NULL, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
     if (mem == MAP_FAILED)
 	fatal (errno, "can't map ashmem region");
     pin.offset = 0, pin.len = pagesize;
-    ret = ioctl (fd, ASHMEM_PIN, &pin);
-    if (ret < 0)
-	fatal (errno, "can't pin region with offset %ld and size %ld", 0, pagesize);
     ret = ioctl (fd, ASHMEM_UNPIN, &pin);
     if (ret < 0)
 	fatal (errno, "can't unpin region with offset %ld and size %ld", 0, pagesize);
+    ret = ioctl (fd, ASHMEM_PIN, &pin);
+    if (ret < 0)
+	fatal (errno, "can't pin region with offset %ld and size %ld", 0, pagesize);
     if (munmap (mem, pagesize))
 	fatal (errno, "can't unmap ashmem region");
     test_close (fd);
 
-    /* make sure we can pin zero bytes (means everything onward) */
-    fd = test_open (ashmemdev, O_RDWR);
-    ret = ioctl (fd, ASHMEM_SET_SIZE, pagesize);
-    if (ret < 0)
-	fatal (errno, "can't allocate %ld-bytes region", pagesize);
+    /* make sure we can unpin zero bytes (means everything onward) */
+    fd = test_open_and_set_size (ashmemdev, O_RDWR, pagesize);
     mem = mmap (NULL, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
     if (mem == MAP_FAILED)
 	fatal (errno, "can't map ashmem region");
     pin.offset = 0, pin.len = 0;
-    ret = ioctl (fd, ASHMEM_PIN, &pin);
+    ret = ioctl (fd, ASHMEM_UNPIN, &pin);
     if (ret < 0)
-	fatal (errno, "should be able to pin zero bytes");
+	fatal (errno, "should be able to unpin zero bytes");
     if (munmap (mem, pagesize))
 	fatal (errno, "can't unmap ashmem region");
     test_close (fd);
 
-    /* make sure we can't pin across page boundaries */
-    fd = test_open (ashmemdev, O_RDWR);
+    /* make sure we can't unpin across page boundaries */
     size = pagesize * 16;
-    ret = ioctl (fd, ASHMEM_SET_SIZE, size);
-    if (ret < 0)
-	fatal (errno, "can't allocate %ld-bytes region", size);
+    fd = test_open_and_set_size (ashmemdev, O_RDWR, size);
     mem = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
     if (mem == MAP_FAILED)
 	fatal (errno, "can't map ashmem region");
     pin.offset = pagesize + 7, pin.len = 3 * pagesize + 11;
-    ret = ioctl (fd, ASHMEM_PIN, &pin);
+    ret = ioctl (fd, ASHMEM_UNPIN, &pin);
     if (ret >= 0)
-	fatal (errno, "should not be able to pin across page boundaries");
+	fatal (errno, "should not be able to unpin across page boundaries");
     if (munmap (mem, size))
 	fatal (errno, "can't unmap ashmem region");
     test_close (fd);
 
-    /* make sure we can't pin more than requested */
-    fd = test_open (ashmemdev, O_RDWR);
+    /* make sure we can't unpin more than requested */
     size = pagesize * 8;
-    ret = ioctl (fd, ASHMEM_SET_SIZE, size);
-    if (ret < 0)
-	fatal (errno, "can't allocate %ld-bytes region", size);
+    fd = test_open_and_set_size (ashmemdev, O_RDWR, size);
     mem = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
     if (mem == MAP_FAILED)
 	fatal (errno, "can't map ashmem region");
     pin.offset = 0, pin.len = size * 2;
-    ret = ioctl (fd, ASHMEM_PIN, &pin);
+    ret = ioctl (fd, ASHMEM_UNPIN, &pin);
     if (ret >= 0)
-	fatal (errno, "should not be able to pin more than allocated");
+	fatal (errno, "should not be able to unpin more than allocated");
     if (munmap (mem, size))
 	fatal (errno, "can't unmap ashmem region");
     test_close (fd);
 
-    /* make sure we can't pin beyond the region */
-    fd = test_open (ashmemdev, O_RDWR);
+    /* make sure we can't unpin beyond the region */
     size = pagesize * 8;
-    ret = ioctl (fd, ASHMEM_SET_SIZE, size);
-    if (ret < 0)
-	fatal (errno, "can't allocate %ld-bytes region", size);
+    fd = test_open_and_set_size (ashmemdev, O_RDWR, size);
     mem = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
     if (mem == MAP_FAILED)
 	fatal (errno, "can't map ashmem region");
     pin.offset = size * 2, pin.len = pagesize;
-    ret = ioctl (fd, ASHMEM_PIN, &pin);
+    ret = ioctl (fd, ASHMEM_UNPIN, &pin);
     if (ret >= 0)
-	fatal (errno, "should not be able to pin beyond the region");
+	fatal (errno, "should not be able to unpin beyond the region");
     if (munmap (mem, size))
 	fatal (errno, "can't unmap ashmem region");
     test_close (fd);
@@ -251,7 +251,7 @@ void ashmem_pin_unpin (char *ashmemdev, size_t pagesize)
     printf ("%d [%s]: test passed\n", testno, __func__);
 }
 
-void ashmem_pin_status (char *ashmemdev, size_t pagesize)
+void ashmem_pin_status (void)
 {
     int fd, ret;
     void *mem;
@@ -261,10 +261,7 @@ void ashmem_pin_status (char *ashmemdev, size_t pagesize)
     testno++;
 
     /* get 4-pages region */
-    fd = test_open (ashmemdev, O_RDWR);
-    ret = ioctl (fd, ASHMEM_SET_SIZE, size);
-    if (ret < 0)
-	fatal (errno, "can't allocate %ld-bytes region", size);
+    fd = test_open_and_set_size (ashmemdev, O_RDWR, size);
     mem = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
     if (mem == MAP_FAILED)
 	fatal (errno, "can't map ashmem region");
@@ -312,17 +309,14 @@ void ashmem_pin_status (char *ashmemdev, size_t pagesize)
     printf ("%d [%s]: test passed\n", testno, __func__);
 }
 
-void ashmem_size (char *ashmemdev, size_t pagesize)
+void ashmem_size (void)
 {
     int fd, ret;
 
     testno++;
 
     /* check whether set and get sizes match */
-    fd = test_open (ashmemdev, O_RDWR);
-    ret = ioctl (fd, ASHMEM_SET_SIZE, pagesize);
-    if (ret < 0)
-	fatal (errno, "can't allocate %ld-bytes region");
+    fd = test_open_and_set_size (ashmemdev, O_RDWR, pagesize);
     ret = ioctl (fd, ASHMEM_GET_SIZE, 0);
     if (ret != pagesize)
 	fatal (0, "size mismatch: expect %ld, got %d", pagesize, ret);
@@ -331,7 +325,7 @@ void ashmem_size (char *ashmemdev, size_t pagesize)
     printf ("%d [%s]: test passed\n", testno, __func__);
 }
 
-void ashmem_mmap (char *ashmemdev, size_t pagesize)
+void ashmem_mmap (void)
 {
     void *mem;
     int i, fd, ret;
@@ -345,10 +339,7 @@ void ashmem_mmap (char *ashmemdev, size_t pagesize)
 	pattern[i] = 'a' + rand () % ('z' - 'a');
 
     /* write the pattern to ashmem region, then compare with origin */
-    fd = test_open (ashmemdev, O_RDWR);
-    ret = ioctl (fd, ASHMEM_SET_SIZE, size);
-    if (ret < 0)
-	fatal (errno, "can't allocate %ld-bytes region");
+    fd = test_open_and_set_size (ashmemdev, O_RDWR, size);
     mem = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
     if (mem == MAP_FAILED)
 	fatal (errno, "can't map ashmem region");
@@ -360,10 +351,7 @@ void ashmem_mmap (char *ashmemdev, size_t pagesize)
     test_close (fd);
 
     /* make sure we can mmap a half in the middle */
-    fd = test_open (ashmemdev, O_RDWR);
-    ret = ioctl (fd, ASHMEM_SET_SIZE, size);
-    if (ret < 0)
-	fatal (errno, "can't allocate %ld-bytes region");
+    fd = test_open_and_set_size (ashmemdev, O_RDWR, size);
     mem = mmap (NULL, size / 2, PROT_READ | PROT_WRITE, MAP_SHARED, fd, pagesize);
     if (mem == MAP_FAILED)
 	fatal (errno, "can't map ashmem region in the middle");
@@ -372,20 +360,14 @@ void ashmem_mmap (char *ashmemdev, size_t pagesize)
     test_close (fd);
 
     /* make sure we can't mmap read-only region for read/write */
-    fd = test_open (ashmemdev, O_RDONLY);
-    ret = ioctl (fd, ASHMEM_SET_SIZE, size);
-    if (ret < 0)
-	fatal (errno, "can't allocate %ld-bytes read-only region");
+    fd = test_open_and_set_size (ashmemdev, O_RDONLY, size);
     mem = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
     if (mem != MAP_FAILED || errno != EACCES)
 	fatal (errno, "should not allow read-write map for read-only region");
     test_close (fd);
 
     /* make sure we can't mmap write-only region for read/write */
-    fd = test_open (ashmemdev, O_WRONLY);
-    ret = ioctl (fd, ASHMEM_SET_SIZE, size);
-    if (ret < 0)
-	fatal (errno, "can't allocate %ld-bytes read-only region");
+    fd = test_open_and_set_size (ashmemdev, O_WRONLY, size);
     mem = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
     if (mem != MAP_FAILED || errno != EACCES)
 	fatal (errno, "should not allow read-write map for write-only region");
@@ -394,10 +376,7 @@ void ashmem_mmap (char *ashmemdev, size_t pagesize)
     printf ("%d [%s]: test passed\n", testno, __func__);
 }
 
-/* Stolen from the kernel */
-#define DEFAULT_PROT_MASK (PROT_READ | PROT_WRITE | PROT_EXEC)
-
-void ashmem_prot (char *ashmemdev, size_t pagesize)
+void ashmem_prot (void)
 {
     void *mem;
     int fd, ret;
@@ -405,10 +384,7 @@ void ashmem_prot (char *ashmemdev, size_t pagesize)
     testno++;
 
     /* check whether default protection is read/write/exec */
-    fd = test_open (ashmemdev, O_RDWR);
-    ret = ioctl (fd, ASHMEM_SET_SIZE, pagesize);
-    if (ret < 0)
-	fatal (errno, "can't allocate %ld-bytes read-only region");
+    fd = test_open_and_set_size (ashmemdev, O_RDWR, pagesize);
     ret = ioctl (fd, ASHMEM_GET_PROT_MASK);
     if (ret != DEFAULT_PROT_MASK)
 	fatal (0, "default protection mask mismatch (got %x expect %x)",
@@ -416,10 +392,7 @@ void ashmem_prot (char *ashmemdev, size_t pagesize)
     test_close (fd);
 
     /* check whether we can remove some protection bits */
-    fd = test_open (ashmemdev, O_RDWR);
-    ret = ioctl (fd, ASHMEM_SET_SIZE, pagesize);
-    if (ret < 0)
-	fatal (errno, "can't allocate %ld-bytes read-only region");
+    fd = test_open_and_set_size (ashmemdev, O_RDWR, pagesize);
     ret = ioctl (fd, ASHMEM_GET_PROT_MASK);
     if (ret != DEFAULT_PROT_MASK)
 	fatal (errno, "can't get protection mask or unexpected mask");
@@ -433,10 +406,7 @@ void ashmem_prot (char *ashmemdev, size_t pagesize)
     test_close (fd);
 
     /* check whether we can't map read/write after removing PROT_READ... */
-    fd = test_open (ashmemdev, O_RDWR);
-    ret = ioctl (fd, ASHMEM_SET_SIZE, pagesize);
-    if (ret < 0)
-	fatal (errno, "can't allocate %ld-bytes read-only region");
+    fd = test_open_and_set_size (ashmemdev, O_RDWR, pagesize);
     ret = ioctl (fd, ASHMEM_GET_PROT_MASK);
     if (ret != DEFAULT_PROT_MASK)
 	fatal (errno, "can't get protection mask or unexpected mask");
@@ -456,10 +426,7 @@ void ashmem_prot (char *ashmemdev, size_t pagesize)
     test_close (fd);
 
     /* likewise after removing PROT_WRITE... */
-    fd = test_open (ashmemdev, O_RDWR);
-    ret = ioctl (fd, ASHMEM_SET_SIZE, pagesize);
-    if (ret < 0)
-	fatal (errno, "can't allocate %ld-bytes read-only region");
+    fd = test_open_and_set_size (ashmemdev, O_RDWR, pagesize);
     ret = ioctl (fd, ASHMEM_GET_PROT_MASK);
     if (ret != DEFAULT_PROT_MASK)
 	fatal (errno, "can't get protection mask or unexpected mask");
@@ -481,7 +448,7 @@ void ashmem_prot (char *ashmemdev, size_t pagesize)
     printf ("%d [%s]: test passed\n", testno, __func__);
 }
 
-void ashmem_purge (char *ashmemdev, size_t pagesize)
+void ashmem_purge (void)
 {
     void *mem;
     struct ashmem_pin pin;
@@ -490,10 +457,7 @@ void ashmem_purge (char *ashmemdev, size_t pagesize)
     testno++;
 
     /* allocate 16 pages */
-    fd = test_open (ashmemdev, O_RDWR);
-    ret = ioctl (fd, ASHMEM_SET_SIZE, size);
-    if (ret < 0)
-	fatal (errno, "can't allocate %ld-bytes read-only region");
+    fd = test_open_and_set_size (ashmemdev, O_RDWR, size);
     mem = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
     if (mem == MAP_FAILED)
 	fatal (errno, "can't map ashmem region");
@@ -522,18 +486,18 @@ void ashmem_purge (char *ashmemdev, size_t pagesize)
 
 int main(int argc, char *argv[])
 {
-    char ashmemdev[64];
-    size_t pagesize = getpagesize ();
-
     snprintf (ashmemdev, sizeof (ashmemdev), "/%s", ASHMEM_NAME_DEF);
-    ashmem_basic (ashmemdev);
-    ashmem_anonymous_region (ashmemdev, pagesize);
-    ashmem_named_region (ashmemdev, pagesize);
-    ashmem_pin_unpin (ashmemdev, pagesize);
-    ashmem_pin_status (ashmemdev, pagesize);
-    ashmem_size (ashmemdev, pagesize);
-    ashmem_mmap (ashmemdev, pagesize);
-    ashmem_prot (ashmemdev, pagesize);
-    ashmem_purge (ashmemdev, pagesize);
+    pagesize = getpagesize ();
+
+    ashmem_basic ();
+    ashmem_anonymous_region ();
+    ashmem_named_region ();
+    ashmem_pin_unpin ();
+    ashmem_pin_status ();
+    ashmem_size ();
+    ashmem_mmap ();
+    ashmem_prot ();
+    ashmem_purge ();
+
     return 0;
 }