Hi Alistair, kernel test robot noticed the following build errors: [auto build test ERROR on 6f1833b8208c3b9e59eff10792667b6639365146] url: https://github.com/intel-lab-lkp/linux/commits/Alistair-Popple/mm-gup-c-Remove-redundant-check-for-PCI-P2PDMA-page/20240910-121806 base: 6f1833b8208c3b9e59eff10792667b6639365146 patch link: https://lore.kernel.org/r/c7026449473790e2844bb82012216c57047c7639.1725941415.git-series.apopple%40nvidia.com patch subject: [PATCH 04/12] mm: Allow compound zone device pages config: csky-defconfig (https://download.01.org/0day-ci/archive/20240912/202409122024.PPIwP6vb-lkp@xxxxxxxxx/config) compiler: csky-linux-gcc (GCC) 14.1.0 reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20240912/202409122024.PPIwP6vb-lkp@xxxxxxxxx/reproduce) If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags | Reported-by: kernel test robot <lkp@xxxxxxxxx> | Closes: https://lore.kernel.org/oe-kbuild-all/202409122024.PPIwP6vb-lkp@xxxxxxxxx/ All error/warnings (new ones prefixed by >>): In file included from include/linux/mm.h:32, from mm/gup.c:7: include/linux/memremap.h: In function 'is_device_private_page': include/linux/memremap.h:164:17: error: implicit declaration of function 'page_dev_pagemap' [-Wimplicit-function-declaration] 164 | page_dev_pagemap(page)->type == MEMORY_DEVICE_PRIVATE; | ^~~~~~~~~~~~~~~~ include/linux/memremap.h:164:39: error: invalid type argument of '->' (have 'int') 164 | page_dev_pagemap(page)->type == MEMORY_DEVICE_PRIVATE; | ^~ include/linux/memremap.h: In function 'is_pci_p2pdma_page': include/linux/memremap.h:176:39: error: invalid type argument of '->' (have 'int') 176 | page_dev_pagemap(page)->type == MEMORY_DEVICE_PCI_P2PDMA; | ^~ include/linux/memremap.h: In function 'is_device_coherent_page': include/linux/memremap.h:182:39: error: invalid type argument of '->' (have 'int') 182 | page_dev_pagemap(page)->type == MEMORY_DEVICE_COHERENT; | ^~ include/linux/memremap.h: In function 'is_pci_p2pdma_page': >> include/linux/memremap.h:177:1: warning: control reaches end of non-void function [-Wreturn-type] 177 | } | ^ include/linux/memremap.h: In function 'is_device_coherent_page': include/linux/memremap.h:183:1: warning: control reaches end of non-void function [-Wreturn-type] 183 | } | ^ -- In file included from include/linux/mm.h:32, from mm/memory.c:44: include/linux/memremap.h: In function 'is_device_private_page': include/linux/memremap.h:164:17: error: implicit declaration of function 'page_dev_pagemap' [-Wimplicit-function-declaration] 164 | page_dev_pagemap(page)->type == MEMORY_DEVICE_PRIVATE; | ^~~~~~~~~~~~~~~~ include/linux/memremap.h:164:39: error: invalid type argument of '->' (have 'int') 164 | page_dev_pagemap(page)->type == MEMORY_DEVICE_PRIVATE; | ^~ include/linux/memremap.h: In function 'is_pci_p2pdma_page': include/linux/memremap.h:176:39: error: invalid type argument of '->' (have 'int') 176 | page_dev_pagemap(page)->type == MEMORY_DEVICE_PCI_P2PDMA; | ^~ include/linux/memremap.h: In function 'is_device_coherent_page': include/linux/memremap.h:182:39: error: invalid type argument of '->' (have 'int') 182 | page_dev_pagemap(page)->type == MEMORY_DEVICE_COHERENT; | ^~ mm/memory.c: In function 'do_swap_page': >> mm/memory.c:4052:31: error: assignment to 'struct dev_pagemap *' from 'int' makes pointer from integer without a cast [-Wint-conversion] 4052 | pgmap = page_dev_pagemap(vmf->page); | ^ include/linux/memremap.h: In function 'is_device_private_page': include/linux/memremap.h:165:1: warning: control reaches end of non-void function [-Wreturn-type] 165 | } | ^ vim +4052 mm/memory.c 3988 3989 /* 3990 * We enter with non-exclusive mmap_lock (to exclude vma changes, 3991 * but allow concurrent faults), and pte mapped but not yet locked. 3992 * We return with pte unmapped and unlocked. 3993 * 3994 * We return with the mmap_lock locked or unlocked in the same cases 3995 * as does filemap_fault(). 3996 */ 3997 vm_fault_t do_swap_page(struct vm_fault *vmf) 3998 { 3999 struct vm_area_struct *vma = vmf->vma; 4000 struct folio *swapcache, *folio = NULL; 4001 struct page *page; 4002 struct swap_info_struct *si = NULL; 4003 rmap_t rmap_flags = RMAP_NONE; 4004 bool need_clear_cache = false; 4005 bool exclusive = false; 4006 swp_entry_t entry; 4007 pte_t pte; 4008 vm_fault_t ret = 0; 4009 void *shadow = NULL; 4010 int nr_pages; 4011 unsigned long page_idx; 4012 unsigned long address; 4013 pte_t *ptep; 4014 4015 if (!pte_unmap_same(vmf)) 4016 goto out; 4017 4018 entry = pte_to_swp_entry(vmf->orig_pte); 4019 if (unlikely(non_swap_entry(entry))) { 4020 if (is_migration_entry(entry)) { 4021 migration_entry_wait(vma->vm_mm, vmf->pmd, 4022 vmf->address); 4023 } else if (is_device_exclusive_entry(entry)) { 4024 vmf->page = pfn_swap_entry_to_page(entry); 4025 ret = remove_device_exclusive_entry(vmf); 4026 } else if (is_device_private_entry(entry)) { 4027 struct dev_pagemap *pgmap; 4028 if (vmf->flags & FAULT_FLAG_VMA_LOCK) { 4029 /* 4030 * migrate_to_ram is not yet ready to operate 4031 * under VMA lock. 4032 */ 4033 vma_end_read(vma); 4034 ret = VM_FAULT_RETRY; 4035 goto out; 4036 } 4037 4038 vmf->page = pfn_swap_entry_to_page(entry); 4039 vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd, 4040 vmf->address, &vmf->ptl); 4041 if (unlikely(!vmf->pte || 4042 !pte_same(ptep_get(vmf->pte), 4043 vmf->orig_pte))) 4044 goto unlock; 4045 4046 /* 4047 * Get a page reference while we know the page can't be 4048 * freed. 4049 */ 4050 get_page(vmf->page); 4051 pte_unmap_unlock(vmf->pte, vmf->ptl); > 4052 pgmap = page_dev_pagemap(vmf->page); 4053 ret = pgmap->ops->migrate_to_ram(vmf); 4054 put_page(vmf->page); 4055 } else if (is_hwpoison_entry(entry)) { 4056 ret = VM_FAULT_HWPOISON; 4057 } else if (is_pte_marker_entry(entry)) { 4058 ret = handle_pte_marker(vmf); 4059 } else { 4060 print_bad_pte(vma, vmf->address, vmf->orig_pte, NULL); 4061 ret = VM_FAULT_SIGBUS; 4062 } 4063 goto out; 4064 } 4065 4066 /* Prevent swapoff from happening to us. */ 4067 si = get_swap_device(entry); 4068 if (unlikely(!si)) 4069 goto out; 4070 4071 folio = swap_cache_get_folio(entry, vma, vmf->address); 4072 if (folio) 4073 page = folio_file_page(folio, swp_offset(entry)); 4074 swapcache = folio; 4075 4076 if (!folio) { 4077 if (data_race(si->flags & SWP_SYNCHRONOUS_IO) && 4078 __swap_count(entry) == 1) { 4079 /* 4080 * Prevent parallel swapin from proceeding with 4081 * the cache flag. Otherwise, another thread may 4082 * finish swapin first, free the entry, and swapout 4083 * reusing the same entry. It's undetectable as 4084 * pte_same() returns true due to entry reuse. 4085 */ 4086 if (swapcache_prepare(entry, 1)) { 4087 /* Relax a bit to prevent rapid repeated page faults */ 4088 schedule_timeout_uninterruptible(1); 4089 goto out; 4090 } 4091 need_clear_cache = true; 4092 4093 /* skip swapcache */ 4094 folio = vma_alloc_folio(GFP_HIGHUSER_MOVABLE, 0, 4095 vma, vmf->address, false); 4096 if (folio) { 4097 __folio_set_locked(folio); 4098 __folio_set_swapbacked(folio); 4099 4100 if (mem_cgroup_swapin_charge_folio(folio, 4101 vma->vm_mm, GFP_KERNEL, 4102 entry)) { 4103 ret = VM_FAULT_OOM; 4104 goto out_page; 4105 } 4106 mem_cgroup_swapin_uncharge_swap(entry); 4107 4108 shadow = get_shadow_from_swap_cache(entry); 4109 if (shadow) 4110 workingset_refault(folio, shadow); 4111 4112 folio_add_lru(folio); 4113 4114 /* To provide entry to swap_read_folio() */ 4115 folio->swap = entry; 4116 swap_read_folio(folio, NULL); 4117 folio->private = NULL; 4118 } 4119 } else { 4120 folio = swapin_readahead(entry, GFP_HIGHUSER_MOVABLE, 4121 vmf); 4122 swapcache = folio; 4123 } 4124 4125 if (!folio) { 4126 /* 4127 * Back out if somebody else faulted in this pte 4128 * while we released the pte lock. 4129 */ 4130 vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd, 4131 vmf->address, &vmf->ptl); 4132 if (likely(vmf->pte && 4133 pte_same(ptep_get(vmf->pte), vmf->orig_pte))) 4134 ret = VM_FAULT_OOM; 4135 goto unlock; 4136 } 4137 4138 /* Had to read the page from swap area: Major fault */ 4139 ret = VM_FAULT_MAJOR; 4140 count_vm_event(PGMAJFAULT); 4141 count_memcg_event_mm(vma->vm_mm, PGMAJFAULT); 4142 page = folio_file_page(folio, swp_offset(entry)); 4143 } else if (PageHWPoison(page)) { 4144 /* 4145 * hwpoisoned dirty swapcache pages are kept for killing 4146 * owner processes (which may be unknown at hwpoison time) 4147 */ 4148 ret = VM_FAULT_HWPOISON; 4149 goto out_release; 4150 } 4151 4152 ret |= folio_lock_or_retry(folio, vmf); 4153 if (ret & VM_FAULT_RETRY) 4154 goto out_release; 4155 4156 if (swapcache) { 4157 /* 4158 * Make sure folio_free_swap() or swapoff did not release the 4159 * swapcache from under us. The page pin, and pte_same test 4160 * below, are not enough to exclude that. Even if it is still 4161 * swapcache, we need to check that the page's swap has not 4162 * changed. 4163 */ 4164 if (unlikely(!folio_test_swapcache(folio) || 4165 page_swap_entry(page).val != entry.val)) 4166 goto out_page; 4167 4168 /* 4169 * KSM sometimes has to copy on read faults, for example, if 4170 * page->index of !PageKSM() pages would be nonlinear inside the 4171 * anon VMA -- PageKSM() is lost on actual swapout. 4172 */ 4173 folio = ksm_might_need_to_copy(folio, vma, vmf->address); 4174 if (unlikely(!folio)) { 4175 ret = VM_FAULT_OOM; 4176 folio = swapcache; 4177 goto out_page; 4178 } else if (unlikely(folio == ERR_PTR(-EHWPOISON))) { 4179 ret = VM_FAULT_HWPOISON; 4180 folio = swapcache; 4181 goto out_page; 4182 } 4183 if (folio != swapcache) 4184 page = folio_page(folio, 0); 4185 4186 /* 4187 * If we want to map a page that's in the swapcache writable, we 4188 * have to detect via the refcount if we're really the exclusive 4189 * owner. Try removing the extra reference from the local LRU 4190 * caches if required. 4191 */ 4192 if ((vmf->flags & FAULT_FLAG_WRITE) && folio == swapcache && 4193 !folio_test_ksm(folio) && !folio_test_lru(folio)) 4194 lru_add_drain(); 4195 } 4196 4197 folio_throttle_swaprate(folio, GFP_KERNEL); 4198 4199 /* 4200 * Back out if somebody else already faulted in this pte. 4201 */ 4202 vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd, vmf->address, 4203 &vmf->ptl); 4204 if (unlikely(!vmf->pte || !pte_same(ptep_get(vmf->pte), vmf->orig_pte))) 4205 goto out_nomap; 4206 4207 if (unlikely(!folio_test_uptodate(folio))) { 4208 ret = VM_FAULT_SIGBUS; 4209 goto out_nomap; 4210 } 4211 4212 nr_pages = 1; 4213 page_idx = 0; 4214 address = vmf->address; 4215 ptep = vmf->pte; 4216 if (folio_test_large(folio) && folio_test_swapcache(folio)) { 4217 int nr = folio_nr_pages(folio); 4218 unsigned long idx = folio_page_idx(folio, page); 4219 unsigned long folio_start = address - idx * PAGE_SIZE; 4220 unsigned long folio_end = folio_start + nr * PAGE_SIZE; 4221 pte_t *folio_ptep; 4222 pte_t folio_pte; 4223 4224 if (unlikely(folio_start < max(address & PMD_MASK, vma->vm_start))) 4225 goto check_folio; 4226 if (unlikely(folio_end > pmd_addr_end(address, vma->vm_end))) 4227 goto check_folio; 4228 4229 folio_ptep = vmf->pte - idx; 4230 folio_pte = ptep_get(folio_ptep); 4231 if (!pte_same(folio_pte, pte_move_swp_offset(vmf->orig_pte, -idx)) || 4232 swap_pte_batch(folio_ptep, nr, folio_pte) != nr) 4233 goto check_folio; 4234 4235 page_idx = idx; 4236 address = folio_start; 4237 ptep = folio_ptep; 4238 nr_pages = nr; 4239 entry = folio->swap; 4240 page = &folio->page; 4241 } 4242 4243 check_folio: 4244 /* 4245 * PG_anon_exclusive reuses PG_mappedtodisk for anon pages. A swap pte 4246 * must never point at an anonymous page in the swapcache that is 4247 * PG_anon_exclusive. Sanity check that this holds and especially, that 4248 * no filesystem set PG_mappedtodisk on a page in the swapcache. Sanity 4249 * check after taking the PT lock and making sure that nobody 4250 * concurrently faulted in this page and set PG_anon_exclusive. 4251 */ 4252 BUG_ON(!folio_test_anon(folio) && folio_test_mappedtodisk(folio)); 4253 BUG_ON(folio_test_anon(folio) && PageAnonExclusive(page)); 4254 4255 /* 4256 * Check under PT lock (to protect against concurrent fork() sharing 4257 * the swap entry concurrently) for certainly exclusive pages. 4258 */ 4259 if (!folio_test_ksm(folio)) { 4260 exclusive = pte_swp_exclusive(vmf->orig_pte); 4261 if (folio != swapcache) { 4262 /* 4263 * We have a fresh page that is not exposed to the 4264 * swapcache -> certainly exclusive. 4265 */ 4266 exclusive = true; 4267 } else if (exclusive && folio_test_writeback(folio) && 4268 data_race(si->flags & SWP_STABLE_WRITES)) { 4269 /* 4270 * This is tricky: not all swap backends support 4271 * concurrent page modifications while under writeback. 4272 * 4273 * So if we stumble over such a page in the swapcache 4274 * we must not set the page exclusive, otherwise we can 4275 * map it writable without further checks and modify it 4276 * while still under writeback. 4277 * 4278 * For these problematic swap backends, simply drop the 4279 * exclusive marker: this is perfectly fine as we start 4280 * writeback only if we fully unmapped the page and 4281 * there are no unexpected references on the page after 4282 * unmapping succeeded. After fully unmapped, no 4283 * further GUP references (FOLL_GET and FOLL_PIN) can 4284 * appear, so dropping the exclusive marker and mapping 4285 * it only R/O is fine. 4286 */ 4287 exclusive = false; 4288 } 4289 } 4290 4291 /* 4292 * Some architectures may have to restore extra metadata to the page 4293 * when reading from swap. This metadata may be indexed by swap entry 4294 * so this must be called before swap_free(). 4295 */ 4296 arch_swap_restore(folio_swap(entry, folio), folio); 4297 4298 /* 4299 * Remove the swap entry and conditionally try to free up the swapcache. 4300 * We're already holding a reference on the page but haven't mapped it 4301 * yet. 4302 */ 4303 swap_free_nr(entry, nr_pages); 4304 if (should_try_to_free_swap(folio, vma, vmf->flags)) 4305 folio_free_swap(folio); 4306 4307 add_mm_counter(vma->vm_mm, MM_ANONPAGES, nr_pages); 4308 add_mm_counter(vma->vm_mm, MM_SWAPENTS, -nr_pages); 4309 pte = mk_pte(page, vma->vm_page_prot); 4310 if (pte_swp_soft_dirty(vmf->orig_pte)) 4311 pte = pte_mksoft_dirty(pte); 4312 if (pte_swp_uffd_wp(vmf->orig_pte)) 4313 pte = pte_mkuffd_wp(pte); 4314 4315 /* 4316 * Same logic as in do_wp_page(); however, optimize for pages that are 4317 * certainly not shared either because we just allocated them without 4318 * exposing them to the swapcache or because the swap entry indicates 4319 * exclusivity. 4320 */ 4321 if (!folio_test_ksm(folio) && 4322 (exclusive || folio_ref_count(folio) == 1)) { 4323 if ((vma->vm_flags & VM_WRITE) && !userfaultfd_pte_wp(vma, pte) && 4324 !pte_needs_soft_dirty_wp(vma, pte)) { 4325 pte = pte_mkwrite(pte, vma); 4326 if (vmf->flags & FAULT_FLAG_WRITE) { 4327 pte = pte_mkdirty(pte); 4328 vmf->flags &= ~FAULT_FLAG_WRITE; 4329 } 4330 } 4331 rmap_flags |= RMAP_EXCLUSIVE; 4332 } 4333 folio_ref_add(folio, nr_pages - 1); 4334 flush_icache_pages(vma, page, nr_pages); 4335 vmf->orig_pte = pte_advance_pfn(pte, page_idx); 4336 4337 /* ksm created a completely new copy */ 4338 if (unlikely(folio != swapcache && swapcache)) { 4339 folio_add_new_anon_rmap(folio, vma, address, RMAP_EXCLUSIVE); 4340 folio_add_lru_vma(folio, vma); 4341 } else if (!folio_test_anon(folio)) { 4342 /* 4343 * We currently only expect small !anon folios, which are either 4344 * fully exclusive or fully shared. If we ever get large folios 4345 * here, we have to be careful. 4346 */ 4347 VM_WARN_ON_ONCE(folio_test_large(folio)); 4348 VM_WARN_ON_FOLIO(!folio_test_locked(folio), folio); 4349 folio_add_new_anon_rmap(folio, vma, address, rmap_flags); 4350 } else { 4351 folio_add_anon_rmap_ptes(folio, page, nr_pages, vma, address, 4352 rmap_flags); 4353 } 4354 4355 VM_BUG_ON(!folio_test_anon(folio) || 4356 (pte_write(pte) && !PageAnonExclusive(page))); 4357 set_ptes(vma->vm_mm, address, ptep, pte, nr_pages); 4358 arch_do_swap_page_nr(vma->vm_mm, vma, address, 4359 pte, pte, nr_pages); 4360 4361 folio_unlock(folio); 4362 if (folio != swapcache && swapcache) { 4363 /* 4364 * Hold the lock to avoid the swap entry to be reused 4365 * until we take the PT lock for the pte_same() check 4366 * (to avoid false positives from pte_same). For 4367 * further safety release the lock after the swap_free 4368 * so that the swap count won't change under a 4369 * parallel locked swapcache. 4370 */ 4371 folio_unlock(swapcache); 4372 folio_put(swapcache); 4373 } 4374 4375 if (vmf->flags & FAULT_FLAG_WRITE) { 4376 ret |= do_wp_page(vmf); 4377 if (ret & VM_FAULT_ERROR) 4378 ret &= VM_FAULT_ERROR; 4379 goto out; 4380 } 4381 4382 /* No need to invalidate - it was non-present before */ 4383 update_mmu_cache_range(vmf, vma, address, ptep, nr_pages); 4384 unlock: 4385 if (vmf->pte) 4386 pte_unmap_unlock(vmf->pte, vmf->ptl); 4387 out: 4388 /* Clear the swap cache pin for direct swapin after PTL unlock */ 4389 if (need_clear_cache) 4390 swapcache_clear(si, entry, 1); 4391 if (si) 4392 put_swap_device(si); 4393 return ret; 4394 out_nomap: 4395 if (vmf->pte) 4396 pte_unmap_unlock(vmf->pte, vmf->ptl); 4397 out_page: 4398 folio_unlock(folio); 4399 out_release: 4400 folio_put(folio); 4401 if (folio != swapcache && swapcache) { 4402 folio_unlock(swapcache); 4403 folio_put(swapcache); 4404 } 4405 if (need_clear_cache) 4406 swapcache_clear(si, entry, 1); 4407 if (si) 4408 put_swap_device(si); 4409 return ret; 4410 } 4411 -- 0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki
