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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
/* SPDX-License-Identifier: GPL-2.0 */
#ifndef __HUGEPAGE_SETTINGS_H__
#define __HUGEPAGE_SETTINGS_H__
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
void hugepage_save_settings(bool thp, bool hugetlb);
/* Transparent Huge Pages (THP) */
enum thp_enabled {
THP_NEVER,
THP_ALWAYS,
THP_INHERIT,
THP_MADVISE,
};
enum thp_defrag {
THP_DEFRAG_ALWAYS,
THP_DEFRAG_DEFER,
THP_DEFRAG_DEFER_MADVISE,
THP_DEFRAG_MADVISE,
THP_DEFRAG_NEVER,
};
enum shmem_enabled {
SHMEM_NEVER,
SHMEM_ALWAYS,
SHMEM_WITHIN_SIZE,
SHMEM_ADVISE,
SHMEM_INHERIT,
SHMEM_DENY,
SHMEM_FORCE,
};
#define NR_ORDERS 20
struct hugepages_settings {
enum thp_enabled enabled;
};
struct khugepaged_settings {
bool defrag;
unsigned int alloc_sleep_millisecs;
unsigned int scan_sleep_millisecs;
unsigned int max_ptes_none;
unsigned int max_ptes_swap;
unsigned int max_ptes_shared;
unsigned long pages_to_scan;
};
struct shmem_hugepages_settings {
enum shmem_enabled enabled;
};
struct thp_settings {
enum thp_enabled thp_enabled;
enum thp_defrag thp_defrag;
enum shmem_enabled shmem_enabled;
bool use_zero_page;
struct khugepaged_settings khugepaged;
unsigned long read_ahead_kb;
struct hugepages_settings hugepages[NR_ORDERS];
struct shmem_hugepages_settings shmem_hugepages[NR_ORDERS];
};
int thp_read_string(const char *name, const char * const strings[]);
void thp_write_string(const char *name, const char *val);
unsigned long thp_read_num(const char *name);
void thp_write_num(const char *name, unsigned long num);
void thp_write_settings(struct thp_settings *settings);
void thp_read_settings(struct thp_settings *settings);
struct thp_settings *thp_current_settings(void);
void thp_push_settings(struct thp_settings *settings);
void thp_pop_settings(void);
void thp_restore_settings(void);
static inline void thp_save_settings(void)
{
hugepage_save_settings(/* thp = */ true, /* hugetlb = */ false);
}
void thp_set_read_ahead_path(char *path);
unsigned long thp_supported_orders(void);
unsigned long thp_shmem_supported_orders(void);
bool thp_available(void);
bool thp_is_enabled(void);
/* HugeTLB */
int detect_hugetlb_page_sizes(unsigned long sizes[], int max);
unsigned long default_huge_page_size(void);
unsigned long hugetlb_nr_pages(unsigned long size);
void hugetlb_set_nr_pages(unsigned long size, unsigned long nr);
unsigned long hugetlb_free_pages(unsigned long size);
static inline void hugetlb_save_settings(void)
{
hugepage_save_settings(/* thp = */ false, /* hugetlb = */ true);
}
void hugetlb_restore_settings(void);
static inline unsigned long hugetlb_nr_default_pages(void)
{
unsigned long size = default_huge_page_size();
if (!size)
return 0;
return hugetlb_nr_pages(size);
}
static inline void hugetlb_set_nr_default_pages(unsigned long nr)
{
unsigned long size = default_huge_page_size();
if (!size)
return;
hugetlb_set_nr_pages(size, nr);
}
static inline unsigned long hugetlb_free_default_pages(void)
{
unsigned long size = default_huge_page_size();
if (!size)
return 0;
return hugetlb_free_pages(size);
}
static inline bool hugetlb_available(void)
{
return default_huge_page_size() != 0;
}
bool hugetlb_setup_default(unsigned long nr);
bool hugetlb_setup_default_exact(unsigned long nr);
unsigned long hugetlb_setup(unsigned long nr, unsigned long sizes[],
int max);
#define HUGETLB_SETUP_DEFAULT_PAGES(nr_pages) \
static void __attribute__((constructor)) __hugetlb_setup_default(void) \
{ \
hugetlb_setup_default((nr_pages)); \
}
#endif /* __HUGEPAGE_SETTINGS_H__ */
|
