Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * SRAM protect-exec region helper functions
4 *
5 * Copyright (C) 2017 Texas Instruments Incorporated - https://www.ti.com/
6 * Dave Gerlach
7 */
8
9#include <linux/device.h>
10#include <linux/genalloc.h>
11#include <linux/mm.h>
12#include <linux/sram.h>
13#include <linux/set_memory.h>
14
15#include <asm/fncpy.h>
16
17#include "sram.h"
18
19static DEFINE_MUTEX(exec_pool_list_mutex);
20static LIST_HEAD(exec_pool_list);
21
22int sram_check_protect_exec(struct sram_dev *sram, struct sram_reserve *block,
23 struct sram_partition *part)
24{
25 unsigned long base = (unsigned long)part->base;
26 unsigned long end = base + block->size;
27
28 if (!PAGE_ALIGNED(base) || !PAGE_ALIGNED(end)) {
29 dev_err(sram->dev,
30 "SRAM pool marked with 'protect-exec' is not page aligned and will not be created.\n");
31 return -ENOMEM;
32 }
33
34 return 0;
35}
36
37int sram_add_protect_exec(struct sram_partition *part)
38{
39 mutex_lock(&exec_pool_list_mutex);
40 list_add_tail(&part->list, &exec_pool_list);
41 mutex_unlock(&exec_pool_list_mutex);
42
43 return 0;
44}
45
46/**
47 * sram_exec_copy - copy data to a protected executable region of sram
48 *
49 * @pool: struct gen_pool retrieved that is part of this sram
50 * @dst: Destination address for the copy, that must be inside pool
51 * @src: Source address for the data to copy
52 * @size: Size of copy to perform, which starting from dst, must reside in pool
53 *
54 * Return: Address for copied data that can safely be called through function
55 * pointer, or NULL if problem.
56 *
57 * This helper function allows sram driver to act as central control location
58 * of 'protect-exec' pools which are normal sram pools but are always set
59 * read-only and executable except when copying data to them, at which point
60 * they are set to read-write non-executable, to make sure no memory is
61 * writeable and executable at the same time. This region must be page-aligned
62 * and is checked during probe, otherwise page attribute manipulation would
63 * not be possible. Care must be taken to only call the returned address as
64 * dst address is not guaranteed to be safely callable.
65 *
66 * NOTE: This function uses the fncpy macro to move code to the executable
67 * region. Some architectures have strict requirements for relocating
68 * executable code, so fncpy is a macro that must be defined by any arch
69 * making use of this functionality that guarantees a safe copy of exec
70 * data and returns a safe address that can be called as a C function
71 * pointer.
72 */
73void *sram_exec_copy(struct gen_pool *pool, void *dst, void *src,
74 size_t size)
75{
76 struct sram_partition *part = NULL, *p;
77 unsigned long base;
78 int pages;
79 void *dst_cpy;
80 int ret;
81
82 mutex_lock(&exec_pool_list_mutex);
83 list_for_each_entry(p, &exec_pool_list, list) {
84 if (p->pool == pool)
85 part = p;
86 }
87 mutex_unlock(&exec_pool_list_mutex);
88
89 if (!part)
90 return NULL;
91
92 if (!gen_pool_has_addr(pool, (unsigned long)dst, size))
93 return NULL;
94
95 base = (unsigned long)part->base;
96 pages = PAGE_ALIGN(size) / PAGE_SIZE;
97
98 mutex_lock(&part->lock);
99
100 ret = set_memory_nx((unsigned long)base, pages);
101 if (ret)
102 goto error_out;
103 ret = set_memory_rw((unsigned long)base, pages);
104 if (ret)
105 goto error_out;
106
107 dst_cpy = fncpy(dst, src, size);
108
109 ret = set_memory_rox((unsigned long)base, pages);
110 if (ret)
111 goto error_out;
112
113 mutex_unlock(&part->lock);
114
115 return dst_cpy;
116
117error_out:
118 mutex_unlock(&part->lock);
119 return NULL;
120}
121EXPORT_SYMBOL_GPL(sram_exec_copy);
1/*
2 * SRAM protect-exec region helper functions
3 *
4 * Copyright (C) 2017 Texas Instruments Incorporated - http://www.ti.com/
5 * Dave Gerlach
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 *
11 * This program is distributed "as is" WITHOUT ANY WARRANTY of any
12 * kind, whether express or implied; without even the implied warranty
13 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 */
16
17#include <linux/device.h>
18#include <linux/genalloc.h>
19#include <linux/mm.h>
20#include <linux/sram.h>
21
22#include <asm/fncpy.h>
23#include <asm/set_memory.h>
24
25#include "sram.h"
26
27static DEFINE_MUTEX(exec_pool_list_mutex);
28static LIST_HEAD(exec_pool_list);
29
30int sram_check_protect_exec(struct sram_dev *sram, struct sram_reserve *block,
31 struct sram_partition *part)
32{
33 unsigned long base = (unsigned long)part->base;
34 unsigned long end = base + block->size;
35
36 if (!PAGE_ALIGNED(base) || !PAGE_ALIGNED(end)) {
37 dev_err(sram->dev,
38 "SRAM pool marked with 'protect-exec' is not page aligned and will not be created.\n");
39 return -ENOMEM;
40 }
41
42 return 0;
43}
44
45int sram_add_protect_exec(struct sram_partition *part)
46{
47 mutex_lock(&exec_pool_list_mutex);
48 list_add_tail(&part->list, &exec_pool_list);
49 mutex_unlock(&exec_pool_list_mutex);
50
51 return 0;
52}
53
54/**
55 * sram_exec_copy - copy data to a protected executable region of sram
56 *
57 * @pool: struct gen_pool retrieved that is part of this sram
58 * @dst: Destination address for the copy, that must be inside pool
59 * @src: Source address for the data to copy
60 * @size: Size of copy to perform, which starting from dst, must reside in pool
61 *
62 * Return: Address for copied data that can safely be called through function
63 * pointer, or NULL if problem.
64 *
65 * This helper function allows sram driver to act as central control location
66 * of 'protect-exec' pools which are normal sram pools but are always set
67 * read-only and executable except when copying data to them, at which point
68 * they are set to read-write non-executable, to make sure no memory is
69 * writeable and executable at the same time. This region must be page-aligned
70 * and is checked during probe, otherwise page attribute manipulation would
71 * not be possible. Care must be taken to only call the returned address as
72 * dst address is not guaranteed to be safely callable.
73 *
74 * NOTE: This function uses the fncpy macro to move code to the executable
75 * region. Some architectures have strict requirements for relocating
76 * executable code, so fncpy is a macro that must be defined by any arch
77 * making use of this functionality that guarantees a safe copy of exec
78 * data and returns a safe address that can be called as a C function
79 * pointer.
80 */
81void *sram_exec_copy(struct gen_pool *pool, void *dst, void *src,
82 size_t size)
83{
84 struct sram_partition *part = NULL, *p;
85 unsigned long base;
86 int pages;
87 void *dst_cpy;
88
89 mutex_lock(&exec_pool_list_mutex);
90 list_for_each_entry(p, &exec_pool_list, list) {
91 if (p->pool == pool)
92 part = p;
93 }
94 mutex_unlock(&exec_pool_list_mutex);
95
96 if (!part)
97 return NULL;
98
99 if (!addr_in_gen_pool(pool, (unsigned long)dst, size))
100 return NULL;
101
102 base = (unsigned long)part->base;
103 pages = PAGE_ALIGN(size) / PAGE_SIZE;
104
105 mutex_lock(&part->lock);
106
107 set_memory_nx((unsigned long)base, pages);
108 set_memory_rw((unsigned long)base, pages);
109
110 dst_cpy = fncpy(dst, src, size);
111
112 set_memory_ro((unsigned long)base, pages);
113 set_memory_x((unsigned long)base, pages);
114
115 mutex_unlock(&part->lock);
116
117 return dst_cpy;
118}
119EXPORT_SYMBOL_GPL(sram_exec_copy);