1 #ifndef JEMALLOC_INTERNAL_PAGES_EXTERNS_H 2 #define JEMALLOC_INTERNAL_PAGES_EXTERNS_H 3 4 /* Page size. LG_PAGE is determined by the configure script. */ 5 #ifdef PAGE_MASK 6 # undef PAGE_MASK 7 #endif 8 #define PAGE ((size_t)(1U << LG_PAGE)) 9 #define PAGE_MASK ((size_t)(PAGE - 1)) 10 /* Return the page base address for the page containing address a. */ 11 #define PAGE_ADDR2BASE(a) \ 12 ((void *)((uintptr_t)(a) & ~PAGE_MASK)) 13 /* Return the smallest pagesize multiple that is >= s. */ 14 #define PAGE_CEILING(s) \ 15 (((s) + PAGE_MASK) & ~PAGE_MASK) 16 /* Return the largest pagesize multiple that is <=s. */ 17 #define PAGE_FLOOR(s) \ 18 ((s) & ~PAGE_MASK) 19 20 /* Huge page size. LG_HUGEPAGE is determined by the configure script. */ 21 #define HUGEPAGE ((size_t)(1U << LG_HUGEPAGE)) 22 #define HUGEPAGE_MASK ((size_t)(HUGEPAGE - 1)) 23 24 #if LG_HUGEPAGE != 0 25 # define HUGEPAGE_PAGES (HUGEPAGE / PAGE) 26 #else 27 /* 28 * It's convenient to define arrays (or bitmaps) of HUGEPAGE_PAGES lengths. If 29 * we can't autodetect the hugepage size, it gets treated as 0, in which case 30 * we'll trigger a compiler error in those arrays. Avoid this case by ensuring 31 * that this value is at least 1. (We won't ever run in this degraded state; 32 * hpa_supported() returns false in this case. 33 */ 34 # define HUGEPAGE_PAGES 1 35 #endif 36 37 /* Return the huge page base address for the huge page containing address a. */ 38 #define HUGEPAGE_ADDR2BASE(a) \ 39 ((void *)((uintptr_t)(a) & ~HUGEPAGE_MASK)) 40 /* Return the smallest pagesize multiple that is >= s. */ 41 #define HUGEPAGE_CEILING(s) \ 42 (((s) + HUGEPAGE_MASK) & ~HUGEPAGE_MASK) 43 44 /* PAGES_CAN_PURGE_LAZY is defined if lazy purging is supported. */ 45 #if defined(_WIN32) || defined(JEMALLOC_PURGE_MADVISE_FREE) 46 # define PAGES_CAN_PURGE_LAZY 47 #endif 48 /* 49 * PAGES_CAN_PURGE_FORCED is defined if forced purging is supported. 50 * 51 * The only supported way to hard-purge on Windows is to decommit and then 52 * re-commit, but doing so is racy, and if re-commit fails it's a pain to 53 * propagate the "poisoned" memory state. Since we typically decommit as the 54 * next step after purging on Windows anyway, there's no point in adding such 55 * complexity. 56 */ 57 #if !defined(_WIN32) && ((defined(JEMALLOC_PURGE_MADVISE_DONTNEED) && \ 58 defined(JEMALLOC_PURGE_MADVISE_DONTNEED_ZEROS)) || \ 59 defined(JEMALLOC_MAPS_COALESCE)) 60 # define PAGES_CAN_PURGE_FORCED 61 #endif 62 63 static const bool pages_can_purge_lazy = 64 #ifdef PAGES_CAN_PURGE_LAZY 65 true 66 #else 67 false 68 #endif 69 ; 70 static const bool pages_can_purge_forced = 71 #ifdef PAGES_CAN_PURGE_FORCED 72 true 73 #else 74 false 75 #endif 76 ; 77 78 #if defined(JEMALLOC_HAVE_MADVISE_HUGE) || defined(JEMALLOC_HAVE_MEMCNTL) 79 # define PAGES_CAN_HUGIFY 80 #endif 81 82 static const bool pages_can_hugify = 83 #ifdef PAGES_CAN_HUGIFY 84 true 85 #else 86 false 87 #endif 88 ; 89 90 typedef enum { 91 thp_mode_default = 0, /* Do not change hugepage settings. */ 92 thp_mode_always = 1, /* Always set MADV_HUGEPAGE. */ 93 thp_mode_never = 2, /* Always set MADV_NOHUGEPAGE. */ 94 95 thp_mode_names_limit = 3, /* Used for option processing. */ 96 thp_mode_not_supported = 3 /* No THP support detected. */ 97 } thp_mode_t; 98 99 #define THP_MODE_DEFAULT thp_mode_default 100 extern thp_mode_t opt_thp; 101 extern thp_mode_t init_system_thp_mode; /* Initial system wide state. */ 102 extern const char *thp_mode_names[]; 103 104 void *pages_map(void *addr, size_t size, size_t alignment, bool *commit); 105 void pages_unmap(void *addr, size_t size); 106 bool pages_commit(void *addr, size_t size); 107 bool pages_decommit(void *addr, size_t size); 108 bool pages_purge_lazy(void *addr, size_t size); 109 bool pages_purge_forced(void *addr, size_t size); 110 bool pages_huge(void *addr, size_t size); 111 bool pages_nohuge(void *addr, size_t size); 112 bool pages_dontdump(void *addr, size_t size); 113 bool pages_dodump(void *addr, size_t size); 114 bool pages_boot(void); 115 void pages_set_thp_state (void *ptr, size_t size); 116 void pages_mark_guards(void *head, void *tail); 117 void pages_unmark_guards(void *head, void *tail); 118 119 #endif /* JEMALLOC_INTERNAL_PAGES_EXTERNS_H */ 120