misc: sram-exec: Use aligned fncpy instead of memcpy

[linux-2.6-microblaze.git] / drivers / misc / sram-exec.c

diff --git a/drivers/misc/sram-exec.c b/drivers/misc/sram-exec.c
index 3d528a1..426ad91 100644 (file)
--- a/drivers/misc/sram-exec.c
+++ b/drivers/misc/sram-exec.c
@@ -19,6 +19,7 @@
 #include <linux/mm.h>
 #include <linux/sram.h>
 
+#include <asm/fncpy.h>
 #include <asm/set_memory.h>
 
 #include "sram.h"
@@ -58,20 +59,32 @@ int sram_add_protect_exec(struct sram_partition *part)
  * @src: Source address for the data to copy
  * @size: Size of copy to perform, which starting from dst, must reside in pool
  *
+ * Return: Address for copied data that can safely be called through function
+ *        pointer, or NULL if problem.
+ *
  * This helper function allows sram driver to act as central control location
  * of 'protect-exec' pools which are normal sram pools but are always set
  * read-only and executable except when copying data to them, at which point
  * they are set to read-write non-executable, to make sure no memory is
  * writeable and executable at the same time. This region must be page-aligned
  * and is checked during probe, otherwise page attribute manipulation would
- * not be possible.
+ * not be possible. Care must be taken to only call the returned address as
+ * dst address is not guaranteed to be safely callable.
+ *
+ * NOTE: This function uses the fncpy macro to move code to the executable
+ * region. Some architectures have strict requirements for relocating
+ * executable code, so fncpy is a macro that must be defined by any arch
+ * making use of this functionality that guarantees a safe copy of exec
+ * data and returns a safe address that can be called as a C function
+ * pointer.
  */
-int sram_exec_copy(struct gen_pool *pool, void *dst, void *src,
-                  size_t size)
+void *sram_exec_copy(struct gen_pool *pool, void *dst, void *src,
+                    size_t size)
 {
        struct sram_partition *part = NULL, *p;
        unsigned long base;
        int pages;
+       void *dst_cpy;
 
        mutex_lock(&exec_pool_list_mutex);
        list_for_each_entry(p, &exec_pool_list, list) {
@@ -81,10 +94,10 @@ int sram_exec_copy(struct gen_pool *pool, void *dst, void *src,
        mutex_unlock(&exec_pool_list_mutex);
 
        if (!part)
-               return -EINVAL;
+               return NULL;
 
        if (!addr_in_gen_pool(pool, (unsigned long)dst, size))
-               return -EINVAL;
+               return NULL;
 
        base = (unsigned long)part->base;
        pages = PAGE_ALIGN(size) / PAGE_SIZE;
@@ -94,13 +107,13 @@ int sram_exec_copy(struct gen_pool *pool, void *dst, void *src,
        set_memory_nx((unsigned long)base, pages);
        set_memory_rw((unsigned long)base, pages);
 
-       memcpy(dst, src, size);
+       dst_cpy = fncpy(dst, src, size);
 
        set_memory_ro((unsigned long)base, pages);
        set_memory_x((unsigned long)base, pages);
 
        mutex_unlock(&part->lock);
 
-       return 0;
+       return dst_cpy;
 }
 EXPORT_SYMBOL_GPL(sram_exec_copy);