Commit | Line | Data |
---|---|---|
6a11f75b | 1 | #include <linux/kernel.h> |
8c5fb8ea | 2 | #include <linux/string.h> |
6a11f75b AM |
3 | #include <linux/mm.h> |
4 | #include <linux/page-debug-flags.h> | |
5 | #include <linux/poison.h> | |
77311139 | 6 | #include <linux/ratelimit.h> |
6a11f75b AM |
7 | |
8 | static inline void set_page_poison(struct page *page) | |
9 | { | |
10 | __set_bit(PAGE_DEBUG_FLAG_POISON, &page->debug_flags); | |
11 | } | |
12 | ||
13 | static inline void clear_page_poison(struct page *page) | |
14 | { | |
15 | __clear_bit(PAGE_DEBUG_FLAG_POISON, &page->debug_flags); | |
16 | } | |
17 | ||
18 | static inline bool page_poison(struct page *page) | |
19 | { | |
20 | return test_bit(PAGE_DEBUG_FLAG_POISON, &page->debug_flags); | |
21 | } | |
22 | ||
23 | static void poison_highpage(struct page *page) | |
24 | { | |
25 | /* | |
26 | * Page poisoning for highmem pages is not implemented. | |
27 | * | |
28 | * This can be called from interrupt contexts. | |
29 | * So we need to create a new kmap_atomic slot for this | |
30 | * application and it will need interrupt protection. | |
31 | */ | |
32 | } | |
33 | ||
34 | static void poison_page(struct page *page) | |
35 | { | |
36 | void *addr; | |
37 | ||
38 | if (PageHighMem(page)) { | |
39 | poison_highpage(page); | |
40 | return; | |
41 | } | |
42 | set_page_poison(page); | |
43 | addr = page_address(page); | |
44 | memset(addr, PAGE_POISON, PAGE_SIZE); | |
45 | } | |
46 | ||
47 | static void poison_pages(struct page *page, int n) | |
48 | { | |
49 | int i; | |
50 | ||
51 | for (i = 0; i < n; i++) | |
52 | poison_page(page + i); | |
53 | } | |
54 | ||
55 | static bool single_bit_flip(unsigned char a, unsigned char b) | |
56 | { | |
57 | unsigned char error = a ^ b; | |
58 | ||
59 | return error && !(error & (error - 1)); | |
60 | } | |
61 | ||
62 | static void check_poison_mem(unsigned char *mem, size_t bytes) | |
63 | { | |
77311139 | 64 | static DEFINE_RATELIMIT_STATE(ratelimit, 5 * HZ, 10); |
6a11f75b AM |
65 | unsigned char *start; |
66 | unsigned char *end; | |
67 | ||
8c5fb8ea AM |
68 | start = memchr_inv(mem, PAGE_POISON, bytes); |
69 | if (!start) | |
6a11f75b AM |
70 | return; |
71 | ||
72 | for (end = mem + bytes - 1; end > start; end--) { | |
73 | if (*end != PAGE_POISON) | |
74 | break; | |
75 | } | |
76 | ||
77311139 | 77 | if (!__ratelimit(&ratelimit)) |
6a11f75b AM |
78 | return; |
79 | else if (start == end && single_bit_flip(*start, PAGE_POISON)) | |
80 | printk(KERN_ERR "pagealloc: single bit error\n"); | |
81 | else | |
82 | printk(KERN_ERR "pagealloc: memory corruption\n"); | |
83 | ||
84 | print_hex_dump(KERN_ERR, "", DUMP_PREFIX_ADDRESS, 16, 1, start, | |
85 | end - start + 1, 1); | |
86 | dump_stack(); | |
87 | } | |
88 | ||
89 | static void unpoison_highpage(struct page *page) | |
90 | { | |
91 | /* | |
92 | * See comment in poison_highpage(). | |
93 | * Highmem pages should not be poisoned for now | |
94 | */ | |
95 | BUG_ON(page_poison(page)); | |
96 | } | |
97 | ||
98 | static void unpoison_page(struct page *page) | |
99 | { | |
100 | if (PageHighMem(page)) { | |
101 | unpoison_highpage(page); | |
102 | return; | |
103 | } | |
104 | if (page_poison(page)) { | |
105 | void *addr = page_address(page); | |
106 | ||
107 | check_poison_mem(addr, PAGE_SIZE); | |
108 | clear_page_poison(page); | |
109 | } | |
110 | } | |
111 | ||
112 | static void unpoison_pages(struct page *page, int n) | |
113 | { | |
114 | int i; | |
115 | ||
116 | for (i = 0; i < n; i++) | |
117 | unpoison_page(page + i); | |
118 | } | |
119 | ||
120 | void kernel_map_pages(struct page *page, int numpages, int enable) | |
121 | { | |
122 | if (!debug_pagealloc_enabled) | |
123 | return; | |
124 | ||
125 | if (enable) | |
126 | unpoison_pages(page, numpages); | |
127 | else | |
128 | poison_pages(page, numpages); | |
129 | } |