Merge tag 'mm-hotfixes-stable-2025-10-10-15-00' of git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm

+19 -7

include/linux/memcontrol.h

··· 1001 1001 count_memcg_events_mm(mm, idx, 1); 1002 1002 } 1003 1003 1004 - static inline void memcg_memory_event(struct mem_cgroup *memcg, 1005 - enum memcg_memory_event event) 1004 + static inline void __memcg_memory_event(struct mem_cgroup *memcg, 1005 + enum memcg_memory_event event, 1006 + bool allow_spinning) 1006 1007 { 1007 1008 bool swap_event = event == MEMCG_SWAP_HIGH || event == MEMCG_SWAP_MAX || 1008 1009 event == MEMCG_SWAP_FAIL; 1009 1010 1011 + /* For now only MEMCG_MAX can happen with !allow_spinning context. */ 1012 + VM_WARN_ON_ONCE(!allow_spinning && event != MEMCG_MAX); 1013 + 1010 1014 atomic_long_inc(&memcg->memory_events_local[event]); 1011 - if (!swap_event) 1015 + if (!swap_event && allow_spinning) 1012 1016 cgroup_file_notify(&memcg->events_local_file); 1013 1017 1014 1018 do { 1015 1019 atomic_long_inc(&memcg->memory_events[event]); 1016 - if (swap_event) 1017 - cgroup_file_notify(&memcg->swap_events_file); 1018 - else 1019 - cgroup_file_notify(&memcg->events_file); 1020 + if (allow_spinning) { 1021 + if (swap_event) 1022 + cgroup_file_notify(&memcg->swap_events_file); 1023 + else 1024 + cgroup_file_notify(&memcg->events_file); 1025 + } 1020 1026 1021 1027 if (!cgroup_subsys_on_dfl(memory_cgrp_subsys)) 1022 1028 break; ··· 1030 1024 break; 1031 1025 } while ((memcg = parent_mem_cgroup(memcg)) && 1032 1026 !mem_cgroup_is_root(memcg)); 1027 + } 1028 + 1029 + static inline void memcg_memory_event(struct mem_cgroup *memcg, 1030 + enum memcg_memory_event event) 1031 + { 1032 + __memcg_memory_event(memcg, event, true); 1033 1033 } 1034 1034 1035 1035 static inline void memcg_memory_event_mm(struct mm_struct *mm,

+1 -1

include/linux/mm.h

··· 323 323 #define VM_MIXEDMAP 0x10000000 /* Can contain "struct page" and pure PFN pages */ 324 324 #define VM_HUGEPAGE 0x20000000 /* MADV_HUGEPAGE marked this vma */ 325 325 #define VM_NOHUGEPAGE 0x40000000 /* MADV_NOHUGEPAGE marked this vma */ 326 - #define VM_MERGEABLE 0x80000000 /* KSM may merge identical pages */ 326 + #define VM_MERGEABLE BIT(31) /* KSM may merge identical pages */ 327 327 328 328 #ifdef CONFIG_ARCH_USES_HIGH_VMA_FLAGS 329 329 #define VM_HIGH_ARCH_BIT_0 32 /* bit only usable on 64-bit architectures */

+2 -6

mm/damon/vaddr.c

··· 328 328 } 329 329 330 330 pte = pte_offset_map_lock(walk->mm, pmd, addr, &ptl); 331 - if (!pte) { 332 - walk->action = ACTION_AGAIN; 331 + if (!pte) 333 332 return 0; 334 - } 335 333 if (!pte_present(ptep_get(pte))) 336 334 goto out; 337 335 damon_ptep_mkold(pte, walk->vma, addr); ··· 479 481 #endif /* CONFIG_TRANSPARENT_HUGEPAGE */ 480 482 481 483 pte = pte_offset_map_lock(walk->mm, pmd, addr, &ptl); 482 - if (!pte) { 483 - walk->action = ACTION_AGAIN; 484 + if (!pte) 484 485 return 0; 485 - } 486 486 ptent = ptep_get(pte); 487 487 if (!pte_present(ptent)) 488 488 goto out;

+3 -12

mm/huge_memory.c

··· 4104 4104 static bool thp_underused(struct folio *folio) 4105 4105 { 4106 4106 int num_zero_pages = 0, num_filled_pages = 0; 4107 - void *kaddr; 4108 4107 int i; 4109 4108 4110 4109 if (khugepaged_max_ptes_none == HPAGE_PMD_NR - 1) 4111 4110 return false; 4112 4111 4113 4112 for (i = 0; i < folio_nr_pages(folio); i++) { 4114 - kaddr = kmap_local_folio(folio, i * PAGE_SIZE); 4115 - if (!memchr_inv(kaddr, 0, PAGE_SIZE)) { 4116 - num_zero_pages++; 4117 - if (num_zero_pages > khugepaged_max_ptes_none) { 4118 - kunmap_local(kaddr); 4113 + if (pages_identical(folio_page(folio, i), ZERO_PAGE(0))) { 4114 + if (++num_zero_pages > khugepaged_max_ptes_none) 4119 4115 return true; 4120 - } 4121 4116 } else { 4122 4117 /* 4123 4118 * Another path for early exit once the number 4124 4119 * of non-zero filled pages exceeds threshold. 4125 4120 */ 4126 - num_filled_pages++; 4127 - if (num_filled_pages >= HPAGE_PMD_NR - khugepaged_max_ptes_none) { 4128 - kunmap_local(kaddr); 4121 + if (++num_filled_pages >= HPAGE_PMD_NR - khugepaged_max_ptes_none) 4129 4122 return false; 4130 - } 4131 4123 } 4132 - kunmap_local(kaddr); 4133 4124 } 4134 4125 return false; 4135 4126 }

+2

mm/hugetlb.c

··· 7222 7222 psize); 7223 7223 } 7224 7224 spin_unlock(ptl); 7225 + 7226 + cond_resched(); 7225 7227 } 7226 7228 /* 7227 7229 * Must flush TLB before releasing i_mmap_rwsem: x86's huge_pmd_unshare

+4 -3

mm/memcontrol.c

··· 2307 2307 bool drained = false; 2308 2308 bool raised_max_event = false; 2309 2309 unsigned long pflags; 2310 + bool allow_spinning = gfpflags_allow_spinning(gfp_mask); 2310 2311 2311 2312 retry: 2312 2313 if (consume_stock(memcg, nr_pages)) 2313 2314 return 0; 2314 2315 2315 - if (!gfpflags_allow_spinning(gfp_mask)) 2316 + if (!allow_spinning) 2316 2317 /* Avoid the refill and flush of the older stock */ 2317 2318 batch = nr_pages; 2318 2319 ··· 2349 2348 if (!gfpflags_allow_blocking(gfp_mask)) 2350 2349 goto nomem; 2351 2350 2352 - memcg_memory_event(mem_over_limit, MEMCG_MAX); 2351 + __memcg_memory_event(mem_over_limit, MEMCG_MAX, allow_spinning); 2353 2352 raised_max_event = true; 2354 2353 2355 2354 psi_memstall_enter(&pflags); ··· 2416 2415 * a MEMCG_MAX event. 2417 2416 */ 2418 2417 if (!raised_max_event) 2419 - memcg_memory_event(mem_over_limit, MEMCG_MAX); 2418 + __memcg_memory_event(mem_over_limit, MEMCG_MAX, allow_spinning); 2420 2419 2421 2420 /* 2422 2421 * The allocation either can't fail or will lead to more memory

+11 -12

mm/migrate.c

··· 296 296 } 297 297 298 298 static bool try_to_map_unused_to_zeropage(struct page_vma_mapped_walk *pvmw, 299 - struct folio *folio, 300 - unsigned long idx) 299 + struct folio *folio, pte_t old_pte, unsigned long idx) 301 300 { 302 301 struct page *page = folio_page(folio, idx); 303 - bool contains_data; 304 302 pte_t newpte; 305 - void *addr; 306 303 307 304 if (PageCompound(page)) 308 305 return false; 309 306 VM_BUG_ON_PAGE(!PageAnon(page), page); 310 307 VM_BUG_ON_PAGE(!PageLocked(page), page); 311 - VM_BUG_ON_PAGE(pte_present(ptep_get(pvmw->pte)), page); 308 + VM_BUG_ON_PAGE(pte_present(old_pte), page); 312 309 313 310 if (folio_test_mlocked(folio) || (pvmw->vma->vm_flags & VM_LOCKED) || 314 311 mm_forbids_zeropage(pvmw->vma->vm_mm)) ··· 316 319 * this subpage has been non present. If the subpage is only zero-filled 317 320 * then map it to the shared zeropage. 318 321 */ 319 - addr = kmap_local_page(page); 320 - contains_data = memchr_inv(addr, 0, PAGE_SIZE); 321 - kunmap_local(addr); 322 - 323 - if (contains_data) 322 + if (!pages_identical(page, ZERO_PAGE(0))) 324 323 return false; 325 324 326 325 newpte = pte_mkspecial(pfn_pte(my_zero_pfn(pvmw->address), 327 326 pvmw->vma->vm_page_prot)); 327 + 328 + if (pte_swp_soft_dirty(old_pte)) 329 + newpte = pte_mksoft_dirty(newpte); 330 + if (pte_swp_uffd_wp(old_pte)) 331 + newpte = pte_mkuffd_wp(newpte); 332 + 328 333 set_pte_at(pvmw->vma->vm_mm, pvmw->address, pvmw->pte, newpte); 329 334 330 335 dec_mm_counter(pvmw->vma->vm_mm, mm_counter(folio)); ··· 369 370 continue; 370 371 } 371 372 #endif 373 + old_pte = ptep_get(pvmw.pte); 372 374 if (rmap_walk_arg->map_unused_to_zeropage && 373 - try_to_map_unused_to_zeropage(&pvmw, folio, idx)) 375 + try_to_map_unused_to_zeropage(&pvmw, folio, old_pte, idx)) 374 376 continue; 375 377 376 378 folio_get(folio); 377 379 pte = mk_pte(new, READ_ONCE(vma->vm_page_prot)); 378 - old_pte = ptep_get(pvmw.pte); 379 380 380 381 entry = pte_to_swp_entry(old_pte); 381 382 if (!is_migration_entry_young(entry))

+2 -1

mm/util.c

··· 566 566 unsigned long len, unsigned long prot, 567 567 unsigned long flag, unsigned long pgoff) 568 568 { 569 + loff_t off = (loff_t)pgoff << PAGE_SHIFT; 569 570 unsigned long ret; 570 571 struct mm_struct *mm = current->mm; 571 572 unsigned long populate; ··· 574 573 575 574 ret = security_mmap_file(file, prot, flag); 576 575 if (!ret) 577 - ret = fsnotify_mmap_perm(file, prot, pgoff >> PAGE_SHIFT, len); 576 + ret = fsnotify_mmap_perm(file, prot, off, len); 578 577 if (!ret) { 579 578 if (mmap_write_lock_killable(mm)) 580 579 return -EINTR;

+1

rust/bindings/bindings_helper.h

··· 108 108 109 109 const gfp_t RUST_CONST_HELPER_XA_FLAGS_ALLOC = XA_FLAGS_ALLOC; 110 110 const gfp_t RUST_CONST_HELPER_XA_FLAGS_ALLOC1 = XA_FLAGS_ALLOC1; 111 + const vm_flags_t RUST_CONST_HELPER_VM_MERGEABLE = VM_MERGEABLE; 111 112 112 113 #if IS_ENABLED(CONFIG_ANDROID_BINDER_IPC_RUST) 113 114 #include "../../drivers/android/binder/rust_binder.h"

Configure Feed

Configure Feed