Commit b1701d5e authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'mm-stable-2022-08-09' of git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm 

Pull remaining MM updates from Andrew Morton:
 "Three patch series - two that perform cleanups and one feature:

   - hugetlb_vmemmap cleanups from Muchun Song

   - hardware poisoning support for 1GB hugepages, from Naoya Horiguchi

   - highmem documentation fixups from Fabio De Francesco"

* tag 'mm-stable-2022-08-09' of git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm: (23 commits)
  Documentation/mm: add details about kmap_local_page() and preemption
  highmem: delete a sentence from kmap_local_page() kdocs
  Documentation/mm: rrefer kmap_local_page() and avoid kmap()
  Documentation/mm: avoid invalid use of addresses from kmap_local_page()
  Documentation/mm: don't kmap*() pages which can't come from HIGHMEM
  highmem: specify that kmap_local_page() is callable from interrupts
  highmem: remove unneeded spaces in kmap_local_page() kdocs
  mm, hwpoison: enable memory error handling on 1GB hugepage
  mm, hwpoison: skip raw hwpoison page in freeing 1GB hugepage
  mm, hwpoison: make __page_handle_poison returns int
  mm, hwpoison: set PG_hwpoison for busy hugetlb pages
  mm, hwpoison: make unpoison aware of raw error info in hwpoisoned hugepage
  mm, hwpoison, hugetlb: support saving mechanism of raw error pages
  mm/hugetlb: make pud_huge() and follow_huge_pud() aware of non-present pud entry
  mm/hugetlb: check gigantic_page_runtime_supported() in return_unused_surplus_pages()
  mm: hugetlb_vmemmap: use PTRS_PER_PTE instead of PMD_SIZE / PAGE_SIZE
  mm: hugetlb_vmemmap: move code comments to vmemmap_dedup.rst
  mm: hugetlb_vmemmap: improve hugetlb_vmemmap code readability
  mm: hugetlb_vmemmap: replace early_param() with core_param()
  mm: hugetlb_vmemmap: move vmemmap code related to HugeTLB to hugetlb_vmemmap.c
  ...
parents c2356983 a9e9c939

Documentation/admin-guide/kernel-parameters.txt

+4 −3
Original line number Diff line number Diff line
@@ -1735,12 +1735,13 @@ 
	hugetlb_free_vmemmap=

			[KNL] Reguires CONFIG_HUGETLB_PAGE_OPTIMIZE_VMEMMAP

			enabled.

			Control if HugeTLB Vmemmap Optimization (HVO) is enabled.

			Allows heavy hugetlb users to free up some more

			memory (7 * PAGE_SIZE for each 2MB hugetlb page).

			Format: { [oO][Nn]/Y/y/1 | [oO][Ff]/N/n/0 (default) }

			Format: { on | off (default) }



			[oO][Nn]/Y/y/1: enable the feature

			[oO][Ff]/N/n/0: disable the feature

			on: enable HVO

			off: disable HVO



			Built with CONFIG_HUGETLB_PAGE_OPTIMIZE_VMEMMAP_DEFAULT_ON=y,

			the default is on.

Documentation/admin-guide/mm/hugetlbpage.rst

+2 −2
Original line number Diff line number Diff line
@@ -164,8 +164,8 @@ default_hugepagesz 
	will all result in 256 2M huge pages being allocated.  Valid default

	huge page size is architecture dependent.

hugetlb_free_vmemmap

	When CONFIG_HUGETLB_PAGE_OPTIMIZE_VMEMMAP is set, this enables optimizing

	unused vmemmap pages associated with each HugeTLB page.

	When CONFIG_HUGETLB_PAGE_OPTIMIZE_VMEMMAP is set, this enables HugeTLB

	Vmemmap Optimization (HVO).



When multiple huge page sizes are supported, ``/proc/sys/vm/nr_hugepages``

indicates the current number of pre-allocated huge pages of the default size.

Documentation/admin-guide/mm/memory-hotplug.rst

+2 −2
Original line number Diff line number Diff line
@@ -653,8 +653,8 @@ block might fail: 
- Concurrent activity that operates on the same physical memory area, such as

  allocating gigantic pages, can result in temporary offlining failures.



- Out of memory when dissolving huge pages, especially when freeing unused

  vmemmap pages associated with each hugetlb page is enabled.

- Out of memory when dissolving huge pages, especially when HugeTLB Vmemmap

  Optimization (HVO) is enabled.



  Offlining code may be able to migrate huge page contents, but may not be able

  to dissolve the source huge page because it fails allocating (unmovable) pages

Documentation/admin-guide/sysctl/vm.rst

+1 −2
Original line number Diff line number Diff line
@@ -569,8 +569,7 @@ This knob is not available when the size of 'struct page' (a structure defined 
in include/linux/mm_types.h) is not power of two (an unusual system config could

result in this).



Enable (set to 1) or disable (set to 0) the feature of optimizing vmemmap pages

associated with each HugeTLB page.

Enable (set to 1) or disable (set to 0) HugeTLB Vmemmap Optimization (HVO).



Once enabled, the vmemmap pages of subsequent allocation of HugeTLB pages from

buddy allocator will be optimized (7 pages per 2MB HugeTLB page and 4095 pages

Documentation/mm/highmem.rst

+27 −4
Original line number Diff line number Diff line
@@ -60,17 +60,40 @@ list shows them in order of preference of use. 
  This function should be preferred, where feasible, over all the others.



  These mappings are thread-local and CPU-local, meaning that the mapping

  can only be accessed from within this thread and the thread is bound the

  CPU while the mapping is active. Even if the thread is preempted (since

  preemption is never disabled by the function) the CPU can not be

  unplugged from the system via CPU-hotplug until the mapping is disposed.

  can only be accessed from within this thread and the thread is bound to the

  CPU while the mapping is active. Although preemption is never disabled by

  this function, the CPU can not be unplugged from the system via

  CPU-hotplug until the mapping is disposed.



  It's valid to take pagefaults in a local kmap region, unless the context

  in which the local mapping is acquired does not allow it for other reasons.



  As said, pagefaults and preemption are never disabled. There is no need to

  disable preemption because, when context switches to a different task, the

  maps of the outgoing task are saved and those of the incoming one are

  restored.



  kmap_local_page() always returns a valid virtual address and it is assumed

  that kunmap_local() will never fail.



  On CONFIG_HIGHMEM=n kernels and for low memory pages this returns the

  virtual address of the direct mapping. Only real highmem pages are

  temporarily mapped. Therefore, users may call a plain page_address()

  for pages which are known to not come from ZONE_HIGHMEM. However, it is

  always safe to use kmap_local_page() / kunmap_local().



  While it is significantly faster than kmap(), for the higmem case it

  comes with restrictions about the pointers validity. Contrary to kmap()

  mappings, the local mappings are only valid in the context of the caller

  and cannot be handed to other contexts. This implies that users must

  be absolutely sure to keep the use of the return address local to the

  thread which mapped it.



  Most code can be designed to use thread local mappings. User should

  therefore try to design their code to avoid the use of kmap() by mapping

  pages in the same thread the address will be used and prefer

  kmap_local_page().



  Nesting kmap_local_page() and kmap_atomic() mappings is allowed to a certain

  extent (up to KMAP_TYPE_NR) but their invocations have to be strictly ordered

  because the map implementation is stack based. See kmap_local_page() kdocs