mm/hmm: remove unused code and tidy comments (f970b977) · Commits · 戴 / test

include/linux/hmm.h

+2 −102

Original line number	Diff line number	Diff line
		@@ -3,58 +3,8 @@
		* Copyright 2013 Red Hat Inc.
		*
		* Authors: Jérôme Glisse <jglisse@redhat.com>
		*/
		/*
		* Heterogeneous Memory Management (HMM)
		*
		* See Documentation/vm/hmm.rst for reasons and overview of what HMM is and it
		* is for. Here we focus on the HMM API description, with some explanation of
		* the underlying implementation.
		*
		* Short description: HMM provides a set of helpers to share a virtual address
		* space between CPU and a device, so that the device can access any valid
		* address of the process (while still obeying memory protection). HMM also
		* provides helpers to migrate process memory to device memory, and back. Each
		* set of functionality (address space mirroring, and migration to and from
		* device memory) can be used independently of the other.
		*
		*
		* HMM address space mirroring API:
		*
		* Use HMM address space mirroring if you want to mirror a range of the CPU
		* page tables of a process into a device page table. Here, "mirror" means "keep
		* synchronized". Prerequisites: the device must provide the ability to write-
		* protect its page tables (at PAGE_SIZE granularity), and must be able to
		* recover from the resulting potential page faults.
		*
		* HMM guarantees that at any point in time, a given virtual address points to
		* either the same memory in both CPU and device page tables (that is: CPU and
		* device page tables each point to the same pages), or that one page table (CPU
		* or device) points to no entry, while the other still points to the old page
		* for the address. The latter case happens when the CPU page table update
		* happens first, and then the update is mirrored over to the device page table.
		* This does not cause any issue, because the CPU page table cannot start
		* pointing to a new page until the device page table is invalidated.
		*
		* HMM uses mmu_notifiers to monitor the CPU page tables, and forwards any
		* updates to each device driver that has registered a mirror. It also provides
		* some API calls to help with taking a snapshot of the CPU page table, and to
		* synchronize with any updates that might happen concurrently.
		*
		*
		* HMM migration to and from device memory:
		*
		* HMM provides a set of helpers to hotplug device memory as ZONE_DEVICE, with
		* a new MEMORY_DEVICE_PRIVATE type. This provides a struct page for each page
		* of the device memory, and allows the device driver to manage its memory
		* using those struct pages. Having struct pages for device memory makes
		* migration easier. Because that memory is not addressable by the CPU it must
		* never be pinned to the device; in other words, any CPU page fault can always
		* cause the device memory to be migrated (copied/moved) back to regular memory.
		*
		* A new migrate helper (migrate_vma()) has been added (see mm/migrate.c) that
		* allows use of a device DMA engine to perform the copy operation between
		* regular system memory and device memory.
		* See Documentation/vm/hmm.rst for reasons and overview of what HMM is.
		*/
		#ifndef LINUX_HMM_H
		#define LINUX_HMM_H
		@@ -120,9 +70,6 @@ enum hmm_pfn_value_e {
		*
		* @notifier: a mmu_interval_notifier that includes the start/end
		* @notifier_seq: result of mmu_interval_read_begin()
		* @hmm: the core HMM structure this range is active against
		* @vma: the vm area struct for the range
		* @list: all range lock are on a list
		* @start: range virtual start address (inclusive)
		* @end: range virtual end address (exclusive)
		* @pfns: array of pfns (big enough for the range)
		@@ -130,8 +77,7 @@ enum hmm_pfn_value_e {
		* @values: pfn value for some special case (none, special, error, ...)
		* @default_flags: default flags for the range (write, read, ... see hmm doc)
		* @pfn_flags_mask: allows to mask pfn flags so that only default_flags matter
		* @pfn_shifts: pfn shift value (should be <= PAGE_SHIFT)
		* @valid: pfns array did not change since it has been fill by an HMM function
		* @pfn_shift: pfn shift value (should be <= PAGE_SHIFT)
		* @dev_private_owner: owner of device private pages
		*/
		struct hmm_range {
		@@ -171,52 +117,6 @@ static inline struct page hmm_device_entry_to_page(const struct hmm_range rang
		return pfn_to_page(entry >> range->pfn_shift);
		}

		/*
		* hmm_device_entry_to_pfn() - return pfn value store in a device entry
		* @range: range use to decode device entry value
		* @entry: device entry to extract pfn from
		* Return: pfn value if device entry is valid, -1UL otherwise
		*/
		static inline unsigned long
		hmm_device_entry_to_pfn(const struct hmm_range *range, uint64_t pfn)
		{
		if (pfn == range->values[HMM_PFN_NONE])
		return -1UL;
		if (pfn == range->values[HMM_PFN_ERROR])
		return -1UL;
		if (pfn == range->values[HMM_PFN_SPECIAL])
		return -1UL;
		if (!(pfn & range->flags[HMM_PFN_VALID]))
		return -1UL;
		return (pfn >> range->pfn_shift);
		}

		/*
		* hmm_device_entry_from_page() - create a valid device entry for a page
		* @range: range use to encode HMM pfn value
		* @page: page for which to create the device entry
		* Return: valid device entry for the page
		*/
		static inline uint64_t hmm_device_entry_from_page(const struct hmm_range *range,
		struct page *page)
		{
		return (page_to_pfn(page) << range->pfn_shift) \|
		range->flags[HMM_PFN_VALID];
		}

		/*
		* hmm_device_entry_from_pfn() - create a valid device entry value from pfn
		* @range: range use to encode HMM pfn value
		* @pfn: pfn value for which to create the device entry
		* Return: valid device entry for the pfn
		*/
		static inline uint64_t hmm_device_entry_from_pfn(const struct hmm_range *range,
		unsigned long pfn)
		{
		return (pfn << range->pfn_shift) \|
		range->flags[HMM_PFN_VALID];
		}

		/* Don't fault in missing PTEs, just snapshot the current state. */
		#define HMM_FAULT_SNAPSHOT (1 << 1)

mm/hmm.c

+17 −7

Original line number	Diff line number	Diff line
		@@ -38,6 +38,18 @@ enum {
		HMM_NEED_ALL_BITS = HMM_NEED_FAULT \| HMM_NEED_WRITE_FAULT,
		};

		/*
		* hmm_device_entry_from_pfn() - create a valid device entry value from pfn
		* @range: range use to encode HMM pfn value
		* @pfn: pfn value for which to create the device entry
		* Return: valid device entry for the pfn
		*/
		static uint64_t hmm_device_entry_from_pfn(const struct hmm_range *range,
		unsigned long pfn)
		{
		return (pfn << range->pfn_shift) \| range->flags[HMM_PFN_VALID];
		}

		static int hmm_pfns_fill(unsigned long addr, unsigned long end,
		struct hmm_range *range, enum hmm_pfn_value_e value)
		{
		@@ -544,7 +556,7 @@ static const struct mm_walk_ops hmm_walk_ops = {

		/**
		* hmm_range_fault - try to fault some address in a virtual address range
		* @range: range being faulted
		* @range: argument structure
		* @flags: HMM_FAULT_* flags
		*
		* Return: the number of valid pages in range->pfns[] (from range start
		@@ -558,13 +570,11 @@ static const struct mm_walk_ops hmm_walk_ops = {
		* only).
		* -EBUSY: The range has been invalidated and the caller needs to wait for
		* the invalidation to finish.
		* -EFAULT: Invalid (i.e., either no valid vma or it is illegal to access
		* that range) number of valid pages in range->pfns[] (from
		* range start address).
		* -EFAULT: A page was requested to be valid and could not be made valid
		* ie it has no backing VMA or it is illegal to access
		*
		* This is similar to a regular CPU page fault except that it will not trigger
		* any memory migration if the memory being faulted is not accessible by CPUs
		* and caller does not ask for migration.
		* This is similar to get_user_pages(), except that it can read the page tables
		* without mutating them (ie causing faults).
		*
		* On error, for one virtual address in the range, the function will mark the
		* corresponding HMM pfn entry with an error flag.

Admin message