Add unit-test for CPU mapping parsing

	- Decompose read_mapping into two functions: *read_mapping* which reads
	CPU mapping data as string from file, and *set_mapping* that actually sets
	the cpu_set_t according to the mapping

	- Add unit test for setting cpu_set_t to various CPU indexes

1 files changed, 37 insertions, 30 deletions

diff --git a/src/migration.c b/src/migration.c
index c1e5a80..efd8d81 100644
--- a/src/migration.c
+++ b/src/migration.c
@@ -27,43 +27,17 @@ int num_online_cpus()
         return sysconf(_SC_NPROCESSORS_ONLN);
 }
 
-static int read_mapping(int idx, const char* which, cpu_set_t** set, size_t *sz)
+void set_mapping(char* buf, int len, cpu_set_t** set, size_t *sz)
 {
-        /* Max CPUs = 4096 */
-
-        int     ret = -1;
-        char buf[4096/4     /* enough chars for hex data (4 CPUs per char) */
-               + 4096/(4*8) /* for commas (separate groups of 8 chars) */
-               + 1] = {0};  /* for \0 */
-        char fname[80] = {0};
-
-        char* chunk_str;
-        int len, nbits;
+        int nbits;
+        char *chunk_str;
         int i;
 
         /* init vals returned to callee */
         *set = NULL;
         *sz = 0;
 
-        if (num_online_cpus() > 4096)
-                goto out;
-
-        /* Read string is in the format of <mask>[,<mask>]*. All <mask>s following
-           a comma are 8 chars (representing a 32-bit mask). The first <mask> may
-           have fewer chars. Bits are MSB to LSB, left to right. */
-        snprintf(fname, sizeof(fname), "/proc/litmus/%s/%d", which, idx);
-        ret = read_file(fname, &buf, sizeof(buf)-1);
-        if (ret <= 0)
-                goto out;
-
-        len = strnlen(buf, sizeof(buf));
-        /* if there is, omit newline at the end of string */
-        if (buf[len-1] == '\n') {
-                buf[len-1] = '\0';
-                len -= 1;
-        }
         nbits = 32*(len/9) + 4*(len%9); /* compute bits, accounting for commas */
-
         *set = CPU_ALLOC(nbits);
         *sz = CPU_ALLOC_SIZE(nbits);
         CPU_ZERO_S(*sz, *set);
@@ -74,7 +48,7 @@ static int read_mapping(int idx, const char* which, cpu_set_t** set, size_t *sz)
         do {
                 unsigned long chunk;
                 /* since strtoul stops processing the string with occurrence of
-                first non-digit character, it is necessary to read 8-bytes 
+                first non-digit character, it is necessary to read 8-bytes
                 on first iteration for ignoring the leading comma*/
                 chunk_str -= (9 + ((i == 0) ? -1 : 0));
                 if (chunk_str < buf)
@@ -88,6 +62,39 @@ static int read_mapping(int idx, const char* which, cpu_set_t** set, size_t *sz)
                 }
                 i += 1;
         } while (chunk_str > buf);
+}
+
+static int read_mapping(int idx, const char* which, cpu_set_t** set, size_t *sz)
+{
+        /* Max CPUs = 4096 */
+
+        int     ret = -1;
+        char buf[4096/4     /* enough chars for hex data (4 CPUs per char) */
+               + 4096/(4*8) /* for commas (separate groups of 8 chars) */
+               + 1] = {0};  /* for \0 */
+        char fname[80] = {0};
+
+        int len;
+
+        if (num_online_cpus() > 4096)
+                goto out;
+
+        /* Read string is in the format of <mask>[,<mask>]*. All <mask>s following
+           a comma are 8 chars (representing a 32-bit mask). The first <mask> may
+           have fewer chars. Bits are MSB to LSB, left to right. */
+        snprintf(fname, sizeof(fname), "/proc/litmus/%s/%d", which, idx);
+        ret = read_file(fname, &buf, sizeof(buf)-1);
+        if (ret <= 0)
+                goto out;
+
+        len = strnlen(buf, sizeof(buf));
+        /* if there is, omit newline at the end of string */
+        if (buf[len-1] == '\n') {
+                buf[len-1] = '\0';
+                len -= 1;
+        }
+
+        set_mapping(buf, len, set, sz);
 
         ret = 0;