/linux/arch/powerpc/include/asm/nohash/32/ |
H A D | pte-8xx.h | 123 unsigned long clr, unsigned long set, int huge); 136 int huge = psize > mmu_virtual_psize ? 1 : 0; in __ptep_set_access_flags() local 138 pte_update(vma->vm_mm, address, ptep, clr, set, huge); in __ptep_set_access_flags() 175 static inline int number_of_cells_per_pte(pmd_t *pmd, pte_basic_t val, int huge) in number_of_cells_per_pte() argument 177 if (!huge) in number_of_cells_per_pte() 188 unsigned long clr, unsigned long set, int huge) in __pte_update() argument 196 num = number_of_cells_per_pte(pmd, new, huge); in __pte_update() 211 unsigned long clr, unsigned long set, int huge) in pte_update() argument 215 if (huge && ptep_is_8m_pmdp(mm, addr, ptep)) { in pte_update() 218 old = __pte_update(mm, addr, pte_offset_kernel(pmdp, 0), clr, set, huge); in pte_update() [all …]
|
/linux/tools/testing/selftests/mm/ |
H A D | charge_reserved_hugetlb.sh | 54 if [[ -e /mnt/huge ]]; then 55 rm -rf /mnt/huge/* 56 umount /mnt/huge || echo error 57 rmdir /mnt/huge 262 if [[ -e /mnt/huge ]]; then 263 rm -rf /mnt/huge/* 264 umount /mnt/huge 265 rmdir /mnt/huge 292 mkdir -p /mnt/huge 293 mount -t hugetlbfs -o pagesize=${MB}M,size=256M none /mnt/huge [all …]
|
H A D | run_vmtests.sh | 67 test transparent huge pages 69 test hugetlbfs huge pages 121 for huge in -t -T "-H -m $hugetlb_mb"; do 130 # just test partial gup when hit a huge in whatever form 133 $huge $test_cmd $write $share $num 141 # get huge pagesize and freepages from /proc/meminfo 152 # huge pages totaling 256MB (262144KB) in size. The userfaultfd 153 # hugetlb test requires a minimum of 2 * nr_cpus huge pages. Take 155 # number of huge pages available. 185 printf "Not enough huge page [all...] |
/linux/Documentation/mm/ |
H A D | hugetlbfs_reserv.rst | 9 typically preallocated for application use. These huge pages are instantiated 10 in a task's address space at page fault time if the VMA indicates huge pages 11 are to be used. If no huge page exists at page fault time, the task is sent 12 a SIGBUS and often dies an unhappy death. Shortly after huge page support 14 of huge pages at mmap() time. The idea is that if there were not enough 15 huge pages to cover the mapping, the mmap() would fail. This was first 17 were enough free huge pages to cover the mapping. Like most things in the 19 'reserve' huge pages at mmap() time to ensure that huge pages would be 21 describe how huge page reserve processing is done in the v4.10 kernel. 34 This is a global (per-hstate) count of reserved huge pages. Reserved [all …]
|
H A D | transhuge.rst | 13 knowledge fall back to breaking huge pmd mapping into table of ptes and, 41 is complete, so they won't ever notice the fact the page is huge. But 57 Code walking pagetables but unaware about huge pmds can simply call 92 To make pagetable walks huge pmd aware, all you need to do is to call 94 mmap_lock in read (or write) mode to be sure a huge pmd cannot be 100 page table lock will prevent the huge pmd being converted into a 104 before. Otherwise, you can proceed to process the huge pmd and the 107 Refcounts and transparent huge pages 133 requests to split pinned huge pages: it expects page count to be equal to
|
H A D | zsmalloc.rst | 157 per zspage. Any object larger than 3264 bytes is considered huge and belongs 159 in huge classes do not share pages). 162 for the huge size class and fewer huge classes overall. This allows for more 165 For zspage chain size of 8, huge class watermark becomes 3632 bytes::: 178 For zspage chain size of 16, huge class watermark becomes 3840 bytes::: 207 pages per zspage number of size classes (clusters) huge size class watermark
|
H A D | arch_pgtable_helpers.rst | 144 | pmd_set_huge | Creates a PMD huge mapping | 146 | pmd_clear_huge | Clears a PMD huge mapping | 199 | pud_set_huge | Creates a PUD huge mapping | 201 | pud_clear_huge | Clears a PUD huge mapping |
|
H A D | unevictable-lru.rst | 315 (unless it is a PTE mapping of a part of a transparent huge page). Or when 350 hugetlbfs ranges, allocating the huge pages and populating the PTEs. 437 A transparent huge page is represented by a single entry on an LRU list. 441 If a user tries to mlock() part of a huge page, and no user mlock()s the 442 whole of the huge page, we want the rest of the page to be reclaimable. 447 We handle this by keeping PTE-mlocked huge pages on evictable LRU lists: 450 This way the huge page is accessible for vmscan. Under memory pressure the 455 of a transparent huge page which are mapped only by PTEs in VM_LOCKED VMAs. 491 (unless it was a PTE mapping of a part of a transparent huge page). 516 (unless it was a PTE mapping of a part of a transparent huge page).
|
/linux/arch/powerpc/include/asm/book3s/64/ |
H A D | hash.h | 162 pte_t *ptep, unsigned long pte, int huge); 190 int huge) in hash__pte_update() argument 196 if (IS_ENABLED(CONFIG_PPC_4K_PAGES) && huge) { in hash__pte_update() 213 if (!huge) in hash__pte_update() 217 hpte_need_flush(mm, addr, ptep, old, huge); in hash__pte_update()
|
H A D | radix.h | 176 int huge) in radix__pte_update() argument 181 if (!huge) in radix__pte_update()
|
/linux/arch/powerpc/include/asm/nohash/ |
H A D | pgtable.h | 7 unsigned long clr, unsigned long set, int huge); 58 unsigned long clr, unsigned long set, int huge) in pte_update() argument 69 if (huge) in pte_update() 95 if (!huge) in pte_update() 143 int huge = psize > mmu_virtual_psize ? 1 : 0; in __ptep_set_access_flags() local 145 pte_update(vma->vm_mm, address, ptep, 0, set, huge); in __ptep_set_access_flags()
|
/linux/arch/loongarch/mm/ |
H A D | init.c | 144 int huge = pmd_val(pmdp_get(pmd)) & _PAGE_HUGE; in vmemmap_check_pmd() local 146 if (huge) in vmemmap_check_pmd() 149 return huge; in vmemmap_check_pmd()
|
/linux/mm/ |
H A D | shmem.c | 122 int huge; member 572 switch (SHMEM_SB(inode->i_sb)->huge) { in shmem_huge_global_enabled() 593 int huge; in shmem_parse_huge() local 599 huge = SHMEM_HUGE_NEVER; in shmem_parse_huge() 601 huge = SHMEM_HUGE_ALWAYS; in shmem_parse_huge() 603 huge = SHMEM_HUGE_WITHIN_SIZE; in shmem_parse_huge() 605 huge = SHMEM_HUGE_ADVISE; in shmem_parse_huge() 607 huge = SHMEM_HUGE_DENY; in shmem_parse_huge() 609 huge = SHMEM_HUGE_FORCE; in shmem_parse_huge() 614 huge != SHMEM_HUGE_NEVER && huge != SHMEM_HUGE_DENY) in shmem_parse_huge() [all …]
|
H A D | memory-failure.c | 924 [MF_MSG_HUGE] = "huge page", 925 [MF_MSG_FREE_HUGE] = "free huge page", 2555 bool huge = false; in unpoison_memory() 2575 unpoison_pr_info("%#lx: huge zero page is not supported\n", in unpoison_memory() 2612 huge = true; in unpoison_memory() 2628 huge = true; in unpoison_memory() 2646 if (!huge) in unpoison_memory() 2669 bool huge = folio_test_hugetlb(folio); in soft_offline_in_use_page() 2678 if (!huge && folio_test_large(folio)) { in soft_offline_in_use_page() 2687 if (!huge) in soft_offline_in_use_page() 2553 bool huge = false; unpoison_memory() local 2667 bool huge = folio_test_hugetlb(folio); soft_offline_in_use_page() local [all...] |
/linux/Documentation/admin-guide/hw-vuln/ |
H A D | multihit.rst | 81 * - KVM: Mitigation: Split huge pages 111 In order to mitigate the vulnerability, KVM initially marks all huge pages 125 The KVM hypervisor mitigation mechanism for marking huge pages as 134 non-executable huge pages in Linux kernel KVM module. All huge
|
/linux/Documentation/core-api/ |
H A D | pin_user_pages.rst | 64 severely by huge pages, because each tail page adds a refcount to the 66 field, refcount overflows were seen in some huge page stress tests. 68 This also means that huge pages and large folios do not suffer 248 acquired since the system was powered on. For huge pages, the head page is 249 pinned once for each page (head page and each tail page) within the huge page. 250 This follows the same sort of behavior that get_user_pages() uses for huge 251 pages: the head page is refcounted once for each tail or head page in the huge 252 page, when get_user_pages() is applied to a huge page. 256 PAGE_SIZE granularity, even if the original pin was applied to a huge page.
|
/linux/arch/alpha/lib/ |
H A D | ev6-clear_user.S | 86 subq $1, 16, $4 # .. .. .. E : If < 16, we can not use the huge loop 87 and $16, 0x3f, $2 # .. .. E .. : Forward work for huge loop 88 subq $2, 0x40, $3 # .. E .. .. : bias counter (huge loop)
|
/linux/Documentation/arch/riscv/ |
H A D | vm-layout.rst | 42 …0000004000000000 | +256 GB | ffffffbfffffffff | ~16M TB | ... huge, almost 64 bits wide hole of… 79 …0000800000000000 | +128 TB | ffff7fffffffffff | ~16M TB | ... huge, almost 64 bits wide hole of… 115 …0100000000000000 | +64 PB | feffffffffffffff | ~16K PB | ... huge, almost 64 bits wide hole of…
|
/linux/arch/powerpc/mm/book3s64/ |
H A D | hash_tlb.c | 41 pte_t *ptep, unsigned long pte, int huge) in hpte_need_flush() argument 61 if (huge) { in hpte_need_flush()
|
/linux/Documentation/admin-guide/mm/ |
H A D | concepts.rst | 79 `huge`. Usage of huge pages significantly reduces pressure on TLB, 83 memory with the huge pages. The first one is `HugeTLB filesystem`, or 86 the memory and mapped using huge pages. The hugetlbfs is described at 89 Another, more recent, mechanism that enables use of the huge pages is 92 the system memory should and can be mapped by the huge pages, THP 201 buffer for DMA, or when THP allocates a huge page. Memory `compaction`
|
/linux/drivers/misc/lkdtm/ |
H A D | bugs.c | 333 static volatile unsigned int huge = INT_MAX - 2; variable 340 value = huge; in lkdtm_OVERFLOW_SIGNED() 355 value = huge; in lkdtm_OVERFLOW_UNSIGNED()
|
/linux/Documentation/features/vm/huge-vmap/ |
H A D | arch-support.txt | 2 # Feature name: huge-vmap
|
/linux/arch/parisc/mm/ |
H A D | init.c | 401 bool huge = false; in map_pages() local 411 huge = true; in map_pages() 416 huge = true; in map_pages() 422 if (huge) in map_pages()
|
/linux/Documentation/filesystems/ext4/ |
H A D | bigalloc.rst | 9 exceeds the page size. However, for a filesystem of mostly huge files,
|
/linux/include/linux/ |
H A D | shmem_fs.h | 64 unsigned char huge; /* Whether to try for hugepages */ member
|