Eric Lee / smarc-fsl-linux-kernel

Blame view

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