Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

1 files changed, 70 insertions, 27 deletions

diff --git a/lib/flex_array.c b/lib/flex_array.c
index 77a6fea7481e..9b8b89458c4c 100644
--- a/lib/flex_array.c
+++ b/lib/flex_array.c
@@ -23,6 +23,8 @@
 #include <linux/flex_array.h>
 #include <linux/slab.h>
 #include <linux/stddef.h>
+#include <linux/module.h>
+#include <linux/reciprocal_div.h>
 
 struct flex_array_part {
         char elements[FLEX_ARRAY_PART_SIZE];
@@ -69,15 +71,15 @@ static inline int elements_fit_in_base(struct flex_array *fa)
  * Element size | Objects | Objects |
  * PAGE_SIZE=4k |  32-bit |  64-bit |
  * ---------------------------------|
- *      1 bytes | 4186112 | 2093056 |
- *      2 bytes | 2093056 | 1046528 |
- *      3 bytes | 1395030 |  697515 |
- *      4 bytes | 1046528 |  523264 |
- *     32 bytes |  130816 |   65408 |
- *     33 bytes |  126728 |   63364 |
- *   2048 bytes |    2044 |    1022 |
- *   2049 bytes |    1022 |     511 |
- *       void * | 1046528 |  261632 |
+ *      1 bytes | 4177920 | 2088960 |
+ *      2 bytes | 2088960 | 1044480 |
+ *      3 bytes | 1392300 |  696150 |
+ *      4 bytes | 1044480 |  522240 |
+ *     32 bytes |  130560 |   65408 |
+ *     33 bytes |  126480 |   63240 |
+ *   2048 bytes |    2040 |    1020 |
+ *   2049 bytes |    1020 |     510 |
+ *       void * | 1044480 |  261120 |
  *
  * Since 64-bit pointers are twice the size, we lose half the
  * capacity in the base structure.  Also note that no effort is made
@@ -87,8 +89,15 @@ struct flex_array *flex_array_alloc(int element_size, unsigned int total,
                                         gfp_t flags)
 {
         struct flex_array *ret;
-        int max_size = FLEX_ARRAY_NR_BASE_PTRS *
-                                FLEX_ARRAY_ELEMENTS_PER_PART(element_size);
+        int elems_per_part = 0;
+        int reciprocal_elems = 0;
+        int max_size = 0;
+
+        if (element_size) {
+                elems_per_part = FLEX_ARRAY_ELEMENTS_PER_PART(element_size);
+                reciprocal_elems = reciprocal_value(elems_per_part);
+                max_size = FLEX_ARRAY_NR_BASE_PTRS * elems_per_part;
+        }
 
         /* max_size will end up 0 if element_size > PAGE_SIZE */
         if (total > max_size)
@@ -98,16 +107,19 @@ struct flex_array *flex_array_alloc(int element_size, unsigned int total,
                 return NULL;
         ret->element_size = element_size;
         ret->total_nr_elements = total;
+        ret->elems_per_part = elems_per_part;
+        ret->reciprocal_elems = reciprocal_elems;
         if (elements_fit_in_base(ret) && !(flags & __GFP_ZERO))
                 memset(&ret->parts[0], FLEX_ARRAY_FREE,
                                                 FLEX_ARRAY_BASE_BYTES_LEFT);
         return ret;
 }
+EXPORT_SYMBOL(flex_array_alloc);
 
 static int fa_element_to_part_nr(struct flex_array *fa,
                                         unsigned int element_nr)
 {
-        return element_nr / FLEX_ARRAY_ELEMENTS_PER_PART(fa->element_size);
+        return reciprocal_divide(element_nr, fa->reciprocal_elems);
 }
 
 /**
@@ -126,20 +138,22 @@ void flex_array_free_parts(struct flex_array *fa)
         for (part_nr = 0; part_nr < FLEX_ARRAY_NR_BASE_PTRS; part_nr++)
                 kfree(fa->parts[part_nr]);
 }
+EXPORT_SYMBOL(flex_array_free_parts);
 
 void flex_array_free(struct flex_array *fa)
 {
         flex_array_free_parts(fa);
         kfree(fa);
 }
+EXPORT_SYMBOL(flex_array_free);
 
 static unsigned int index_inside_part(struct flex_array *fa,
-                                        unsigned int element_nr)
+                                        unsigned int element_nr,
+                                        unsigned int part_nr)
 {
         unsigned int part_offset;
 
-        part_offset = element_nr %
-                                FLEX_ARRAY_ELEMENTS_PER_PART(fa->element_size);
+        part_offset = element_nr - part_nr * fa->elems_per_part;
         return part_offset * fa->element_size;
 }
 
@@ -179,23 +193,27 @@ __fa_get_part(struct flex_array *fa, int part_nr, gfp_t flags)
 int flex_array_put(struct flex_array *fa, unsigned int element_nr, void *src,
                         gfp_t flags)
 {
-        int part_nr = fa_element_to_part_nr(fa, element_nr);
+        int part_nr = 0;
         struct flex_array_part *part;
         void *dst;
 
         if (element_nr >= fa->total_nr_elements)
                 return -ENOSPC;
+        if (!fa->element_size)
+                return 0;
         if (elements_fit_in_base(fa))
                 part = (struct flex_array_part *)&fa->parts[0];
         else {
+                part_nr = fa_element_to_part_nr(fa, element_nr);
                 part = __fa_get_part(fa, part_nr, flags);
                 if (!part)
                         return -ENOMEM;
         }
-        dst = &part->elements[index_inside_part(fa, element_nr)];
+        dst = &part->elements[index_inside_part(fa, element_nr, part_nr)];
         memcpy(dst, src, fa->element_size);
         return 0;
 }
+EXPORT_SYMBOL(flex_array_put);
 
 /**
  * flex_array_clear - clear element in array at @element_nr
@@ -206,30 +224,34 @@ int flex_array_put(struct flex_array *fa, unsigned int element_nr, void *src,
  */
 int flex_array_clear(struct flex_array *fa, unsigned int element_nr)
 {
-        int part_nr = fa_element_to_part_nr(fa, element_nr);
+        int part_nr = 0;
         struct flex_array_part *part;
         void *dst;
 
         if (element_nr >= fa->total_nr_elements)
                 return -ENOSPC;
+        if (!fa->element_size)
+                return 0;
         if (elements_fit_in_base(fa))
                 part = (struct flex_array_part *)&fa->parts[0];
         else {
+                part_nr = fa_element_to_part_nr(fa, element_nr);
                 part = fa->parts[part_nr];
                 if (!part)
                         return -EINVAL;
         }
-        dst = &part->elements[index_inside_part(fa, element_nr)];
+        dst = &part->elements[index_inside_part(fa, element_nr, part_nr)];
         memset(dst, FLEX_ARRAY_FREE, fa->element_size);
         return 0;
 }
+EXPORT_SYMBOL(flex_array_clear);
 
 /**
  * flex_array_prealloc - guarantee that array space exists
- * @fa:         the flex array for which to preallocate parts
- * @start:      index of first array element for which space is allocated
- * @end:        index of last (inclusive) element for which space is allocated
- * @flags:      page allocation flags
+ * @fa:                 the flex array for which to preallocate parts
+ * @start:              index of first array element for which space is allocated
+ * @nr_elements:        number of elements for which space is allocated
+ * @flags:              page allocation flags
  *
  * This will guarantee that no future calls to flex_array_put()
  * will allocate memory.  It can be used if you are expecting to
@@ -239,15 +261,27 @@ int flex_array_clear(struct flex_array *fa, unsigned int element_nr)
  * Locking must be provided by the caller.
  */
 int flex_array_prealloc(struct flex_array *fa, unsigned int start,
-                        unsigned int end, gfp_t flags)
+                        unsigned int nr_elements, gfp_t flags)
 {
         int start_part;
         int end_part;
         int part_nr;
+        unsigned int end;
         struct flex_array_part *part;
 
-        if (start >= fa->total_nr_elements || end >= fa->total_nr_elements)
+        if (!start && !nr_elements)
+                return 0;
+        if (start >= fa->total_nr_elements)
                 return -ENOSPC;
+        if (!nr_elements)
+                return 0;
+
+        end = start + nr_elements - 1;
+
+        if (end >= fa->total_nr_elements)
+                return -ENOSPC;
+        if (!fa->element_size)
+                return 0;
         if (elements_fit_in_base(fa))
                 return 0;
         start_part = fa_element_to_part_nr(fa, start);
@@ -259,6 +293,7 @@ int flex_array_prealloc(struct flex_array *fa, unsigned int start,
         }
         return 0;
 }
+EXPORT_SYMBOL(flex_array_prealloc);
 
 /**
  * flex_array_get - pull data back out of the array
@@ -274,20 +309,24 @@ int flex_array_prealloc(struct flex_array *fa, unsigned int start,
  */
 void *flex_array_get(struct flex_array *fa, unsigned int element_nr)
 {
-        int part_nr = fa_element_to_part_nr(fa, element_nr);
+        int part_nr = 0;
         struct flex_array_part *part;
 
+        if (!fa->element_size)
+                return NULL;
         if (element_nr >= fa->total_nr_elements)
                 return NULL;
         if (elements_fit_in_base(fa))
                 part = (struct flex_array_part *)&fa->parts[0];
         else {
+                part_nr = fa_element_to_part_nr(fa, element_nr);
                 part = fa->parts[part_nr];
                 if (!part)
                         return NULL;
         }
-        return &part->elements[index_inside_part(fa, element_nr)];
+        return &part->elements[index_inside_part(fa, element_nr, part_nr)];
 }
+EXPORT_SYMBOL(flex_array_get);
 
 /**
  * flex_array_get_ptr - pull a ptr back out of the array
@@ -308,6 +347,7 @@ void *flex_array_get_ptr(struct flex_array *fa, unsigned int element_nr)
 
         return *tmp;
 }
+EXPORT_SYMBOL(flex_array_get_ptr);
 
 static int part_is_free(struct flex_array_part *part)
 {
@@ -334,6 +374,8 @@ int flex_array_shrink(struct flex_array *fa)
         int part_nr;
         int ret = 0;
 
+        if (!fa->total_nr_elements || !fa->element_size)
+                return 0;
         if (elements_fit_in_base(fa))
                 return ret;
         for (part_nr = 0; part_nr < FLEX_ARRAY_NR_BASE_PTRS; part_nr++) {
@@ -348,3 +390,4 @@ int flex_array_shrink(struct flex_array *fa)
         }
         return ret;
 }
+EXPORT_SYMBOL(flex_array_shrink);