1#include <linux/kmemcheck.h>
  2#include <linux/module.h>
  3#include <linux/mm.h>
  4
  5#include <asm/page.h>
  6#include <asm/pgtable.h>
  7
  8#include "pte.h"
  9#include "shadow.h"
 10
 11/*
 12 * Return the shadow address for the given address. Returns NULL if the
 13 * address is not tracked.
 14 *
 15 * We need to be extremely careful not to follow any invalid pointers,
 16 * because this function can be called for *any* possible address.
 17 */
 18void *kmemcheck_shadow_lookup(unsigned long address)
 19{
 20	pte_t *pte;
 21	struct page *page;
 22
 23	if (!virt_addr_valid(address))
 24		return NULL;
 25
 26	pte = kmemcheck_pte_lookup(address);
 27	if (!pte)
 28		return NULL;
 29
 30	page = virt_to_page(address);
 31	if (!page->shadow)
 32		return NULL;
 33	return page->shadow + (address & (PAGE_SIZE - 1));
 34}
 35
 36static void mark_shadow(void *address, unsigned int n,
 37	enum kmemcheck_shadow status)
 38{
 39	unsigned long addr = (unsigned long) address;
 40	unsigned long last_addr = addr + n - 1;
 41	unsigned long page = addr & PAGE_MASK;
 42	unsigned long last_page = last_addr & PAGE_MASK;
 43	unsigned int first_n;
 44	void *shadow;
 45
 46	/* If the memory range crosses a page boundary, stop there. */
 47	if (page == last_page)
 48		first_n = n;
 49	else
 50		first_n = page + PAGE_SIZE - addr;
 51
 52	shadow = kmemcheck_shadow_lookup(addr);
 53	if (shadow)
 54		memset(shadow, status, first_n);
 55
 56	addr += first_n;
 57	n -= first_n;
 58
 59	/* Do full-page memset()s. */
 60	while (n >= PAGE_SIZE) {
 61		shadow = kmemcheck_shadow_lookup(addr);
 62		if (shadow)
 63			memset(shadow, status, PAGE_SIZE);
 64
 65		addr += PAGE_SIZE;
 66		n -= PAGE_SIZE;
 67	}
 68
 69	/* Do the remaining page, if any. */
 70	if (n > 0) {
 71		shadow = kmemcheck_shadow_lookup(addr);
 72		if (shadow)
 73			memset(shadow, status, n);
 74	}
 75}
 76
 77void kmemcheck_mark_unallocated(void *address, unsigned int n)
 78{
 79	mark_shadow(address, n, KMEMCHECK_SHADOW_UNALLOCATED);
 80}
 81
 82void kmemcheck_mark_uninitialized(void *address, unsigned int n)
 83{
 84	mark_shadow(address, n, KMEMCHECK_SHADOW_UNINITIALIZED);
 85}
 86
 87/*
 88 * Fill the shadow memory of the given address such that the memory at that
 89 * address is marked as being initialized.
 90 */
 91void kmemcheck_mark_initialized(void *address, unsigned int n)
 92{
 93	mark_shadow(address, n, KMEMCHECK_SHADOW_INITIALIZED);
 94}
 95EXPORT_SYMBOL_GPL(kmemcheck_mark_initialized);
 96
 97void kmemcheck_mark_freed(void *address, unsigned int n)
 98{
 99	mark_shadow(address, n, KMEMCHECK_SHADOW_FREED);
100}
101
102void kmemcheck_mark_unallocated_pages(struct page *p, unsigned int n)
103{
104	unsigned int i;
105
106	for (i = 0; i < n; ++i)
107		kmemcheck_mark_unallocated(page_address(&p[i]), PAGE_SIZE);
108}
109
110void kmemcheck_mark_uninitialized_pages(struct page *p, unsigned int n)
111{
112	unsigned int i;
113
114	for (i = 0; i < n; ++i)
115		kmemcheck_mark_uninitialized(page_address(&p[i]), PAGE_SIZE);
116}
117
118void kmemcheck_mark_initialized_pages(struct page *p, unsigned int n)
119{
120	unsigned int i;
121
122	for (i = 0; i < n; ++i)
123		kmemcheck_mark_initialized(page_address(&p[i]), PAGE_SIZE);
124}
125
126enum kmemcheck_shadow kmemcheck_shadow_test(void *shadow, unsigned int size)
127{
128#ifdef CONFIG_KMEMCHECK_PARTIAL_OK
129	uint8_t *x;
130	unsigned int i;
131
132	x = shadow;
133
134	/*
135	 * Make sure _some_ bytes are initialized. Gcc frequently generates
136	 * code to access neighboring bytes.
137	 */
138	for (i = 0; i < size; ++i) {
139		if (x[i] == KMEMCHECK_SHADOW_INITIALIZED)
140			return x[i];
141	}
142
143	return x[0];
144#else
145	return kmemcheck_shadow_test_all(shadow, size);
146#endif
147}
148
149enum kmemcheck_shadow kmemcheck_shadow_test_all(void *shadow, unsigned int size)
150{
151	uint8_t *x;
152	unsigned int i;
153
154	x = shadow;
155
156	/* All bytes must be initialized. */
157	for (i = 0; i < size; ++i) {
158		if (x[i] != KMEMCHECK_SHADOW_INITIALIZED)
159			return x[i];
160	}
161
162	return x[0];
163}
164
165void kmemcheck_shadow_set(void *shadow, unsigned int size)
166{
167	uint8_t *x;
168	unsigned int i;
169
170	x = shadow;
171	for (i = 0; i < size; ++i)
172		x[i] = KMEMCHECK_SHADOW_INITIALIZED;
173}