mm: refactor swap-in logic out of shmem_getpage_gfp (c5bf121e) · Commits · 戴 / test

mm/shmem.c

+244 −205

Original line number	Diff line number	Diff line
		@@ -123,6 +123,10 @@ static unsigned long shmem_default_max_inodes(void)
		static bool shmem_should_replace_page(struct page *page, gfp_t gfp);
		static int shmem_replace_page(struct page **pagep, gfp_t gfp,
		struct shmem_inode_info *info, pgoff_t index);
		static int shmem_swapin_page(struct inode *inode, pgoff_t index,
		struct page **pagep, enum sgp_type sgp,
		gfp_t gfp, struct vm_area_struct *vma,
		vm_fault_t *fault_type);
		static int shmem_getpage_gfp(struct inode *inode, pgoff_t index,
		struct page **pagep, enum sgp_type sgp,
		gfp_t gfp, struct vm_area_struct *vma,
		@@ -1576,75 +1580,28 @@ static int shmem_replace_page(struct page **pagep, gfp_t gfp,
		}

		/*
		* shmem_getpage_gfp - find page in cache, or get from swap, or allocate
		*
		* If we allocate a new one we do not mark it dirty. That's up to the
		* vm. If we swap it in we mark it dirty since we also free the swap
		* entry since a page cannot live in both the swap and page cache.
		*
		* fault_mm and fault_type are only supplied by shmem_fault:
		* otherwise they are NULL.
		* Swap in the page pointed to by *pagep.
		* Caller has to make sure that *pagep contains a valid swapped page.
		* Returns 0 and the page in pagep if success. On failure, returns the
		* the error code and NULL in *pagep.
		*/
		static int shmem_getpage_gfp(struct inode *inode, pgoff_t index,
		struct page **pagep, enum sgp_type sgp, gfp_t gfp,
		struct vm_area_struct vma, struct vm_fault vmf,
		static int shmem_swapin_page(struct inode *inode, pgoff_t index,
		struct page **pagep, enum sgp_type sgp,
		gfp_t gfp, struct vm_area_struct *vma,
		vm_fault_t *fault_type)
		{
		struct address_space *mapping = inode->i_mapping;
		struct shmem_inode_info *info = SHMEM_I(inode);
		struct shmem_sb_info *sbinfo;
		struct mm_struct *charge_mm;
		struct mm_struct *charge_mm = vma ? vma->vm_mm : current->mm;
		struct mem_cgroup *memcg;
		struct page *page;
		swp_entry_t swap;
		enum sgp_type sgp_huge = sgp;
		pgoff_t hindex = index;
		int error;
		int once = 0;
		int alloced = 0;

		if (index > (MAX_LFS_FILESIZE >> PAGE_SHIFT))
		return -EFBIG;
		if (sgp == SGP_NOHUGE \|\| sgp == SGP_HUGE)
		sgp = SGP_CACHE;
		repeat:
		swap.val = 0;
		page = find_lock_entry(mapping, index);
		if (xa_is_value(page)) {
		swap = radix_to_swp_entry(page);
		page = NULL;
		}

		if (sgp <= SGP_CACHE &&
		((loff_t)index << PAGE_SHIFT) >= i_size_read(inode)) {
		error = -EINVAL;
		goto unlock;
		}

		if (page && sgp == SGP_WRITE)
		mark_page_accessed(page);

		/* fallocated page? */
		if (page && !PageUptodate(page)) {
		if (sgp != SGP_READ)
		goto clear;
		unlock_page(page);
		put_page(page);
		page = NULL;
		}
		if (page \|\| (sgp == SGP_READ && !swap.val)) {
		*pagep = page;
		return 0;
		}

		/*
		* Fast cache lookup did not find it:
		* bring it back from swap or allocate.
		*/
		sbinfo = SHMEM_SB(inode->i_sb);
		charge_mm = vma ? vma->vm_mm : current->mm;
		VM_BUG_ON(!pagep \|\| !xa_is_value(pagep));
		swap = radix_to_swp_entry(*pagep);
		*pagep = NULL;

		if (swap.val) {
		/* Look it up and read it in.. */
		page = lookup_swap_cache(swap, NULL, 0);
		if (!page) {
		@@ -1666,7 +1623,7 @@ repeat:
		lock_page(page);
		if (!PageSwapCache(page) \|\| page_private(page) != swap.val \|\|
		!shmem_confirm_swap(mapping, index, swap)) {
		error = -EEXIST; /* try again */
		error = -EEXIST;
		goto unlock;
		}
		if (!PageUptodate(page)) {
		@@ -1695,8 +1652,6 @@ repeat:
		* shmem_undo_range() will have done some of the
		* unaccounting, now delete_from_swap_cache() will do
		* the rest.
		* Reset swap.val? No, leave it so "failed" goes back to
		* "repeat": reading a hole and writing should succeed.
		*/
		if (error) {
		mem_cgroup_cancel_charge(page, memcg, false);
		@@ -1720,7 +1675,92 @@ repeat:
		set_page_dirty(page);
		swap_free(swap);

		} else {
		*pagep = page;
		return 0;
		failed:
		if (!shmem_confirm_swap(mapping, index, swap))
		error = -EEXIST;
		unlock:
		if (page) {
		unlock_page(page);
		put_page(page);
		}

		return error;
		}

		/*
		* shmem_getpage_gfp - find page in cache, or get from swap, or allocate
		*
		* If we allocate a new one we do not mark it dirty. That's up to the
		* vm. If we swap it in we mark it dirty since we also free the swap
		* entry since a page cannot live in both the swap and page cache.
		*
		* fault_mm and fault_type are only supplied by shmem_fault:
		* otherwise they are NULL.
		*/
		static int shmem_getpage_gfp(struct inode *inode, pgoff_t index,
		struct page **pagep, enum sgp_type sgp, gfp_t gfp,
		struct vm_area_struct vma, struct vm_fault vmf,
		vm_fault_t *fault_type)
		{
		struct address_space *mapping = inode->i_mapping;
		struct shmem_inode_info *info = SHMEM_I(inode);
		struct shmem_sb_info *sbinfo;
		struct mm_struct *charge_mm;
		struct mem_cgroup *memcg;
		struct page *page;
		enum sgp_type sgp_huge = sgp;
		pgoff_t hindex = index;
		int error;
		int once = 0;
		int alloced = 0;

		if (index > (MAX_LFS_FILESIZE >> PAGE_SHIFT))
		return -EFBIG;
		if (sgp == SGP_NOHUGE \|\| sgp == SGP_HUGE)
		sgp = SGP_CACHE;
		repeat:
		if (sgp <= SGP_CACHE &&
		((loff_t)index << PAGE_SHIFT) >= i_size_read(inode)) {
		return -EINVAL;
		}

		sbinfo = SHMEM_SB(inode->i_sb);
		charge_mm = vma ? vma->vm_mm : current->mm;

		page = find_lock_entry(mapping, index);
		if (xa_is_value(page)) {
		error = shmem_swapin_page(inode, index, &page,
		sgp, gfp, vma, fault_type);
		if (error == -EEXIST)
		goto repeat;

		*pagep = page;
		return error;
		}

		if (page && sgp == SGP_WRITE)
		mark_page_accessed(page);

		/* fallocated page? */
		if (page && !PageUptodate(page)) {
		if (sgp != SGP_READ)
		goto clear;
		unlock_page(page);
		put_page(page);
		page = NULL;
		}
		if (page \|\| sgp == SGP_READ) {
		*pagep = page;
		return 0;
		}

		/*
		* Fast cache lookup did not find it:
		* bring it back from swap or allocate.
		*/

		if (vma && userfaultfd_missing(vma)) {
		*fault_type = handle_userfault(vmf, VM_UFFD_MISSING);
		return 0;
		@@ -1755,28 +1795,31 @@ repeat:
		alloc_huge:
		page = shmem_alloc_and_acct_page(gfp, inode, index, true);
		if (IS_ERR(page)) {
		alloc_nohuge: page = shmem_alloc_and_acct_page(gfp, inode,
		alloc_nohuge:
		page = shmem_alloc_and_acct_page(gfp, inode,
		index, false);
		}
		if (IS_ERR(page)) {
		int retry = 5;

		error = PTR_ERR(page);
		page = NULL;
		if (error != -ENOSPC)
		goto failed;
		goto unlock;
		/*
		* Try to reclaim some spece by splitting a huge page
		* Try to reclaim some space by splitting a huge page
		* beyond i_size on the filesystem.
		*/
		while (retry--) {
		int ret;

		ret = shmem_unused_huge_shrink(sbinfo, NULL, 1);
		if (ret == SHRINK_STOP)
		break;
		if (ret)
		goto alloc_nohuge;
		}
		goto failed;
		goto unlock;
		}

		if (PageTransHuge(page))
		@@ -1850,7 +1893,6 @@ clear:
		}
		SetPageUptodate(head);
		}
		}

		/* Perhaps the file has been truncated since we checked */
		if (sgp <= SGP_CACHE &&
		@@ -1879,9 +1921,6 @@ unacct:
		put_page(page);
		goto alloc_nohuge;
		}
		failed:
		if (swap.val && !shmem_confirm_swap(mapping, index, swap))
		error = -EEXIST;
		unlock:
		if (page) {
		unlock_page(page);

Admin message