Merge branch 'akpm' (patches from Andrew)

+1 -1

MAINTAINERS

··· 4508 4508 S: Supported 4509 4509 W: https://clangbuiltlinux.github.io/ 4510 4510 B: https://github.com/ClangBuiltLinux/linux/issues 4511 - C: irc://chat.freenode.net/clangbuiltlinux 4511 + C: irc://irc.libera.chat/clangbuiltlinux 4512 4512 F: Documentation/kbuild/llvm.rst 4513 4513 F: include/linux/compiler-clang.h 4514 4514 F: scripts/clang-tools/

+4 -3

include/linux/kfence.h

··· 51 51 static __always_inline bool is_kfence_address(const void *addr) 52 52 { 53 53 /* 54 - * The non-NULL check is required in case the __kfence_pool pointer was 55 - * never initialized; keep it in the slow-path after the range-check. 54 + * The __kfence_pool != NULL check is required to deal with the case 55 + * where __kfence_pool == NULL && addr < KFENCE_POOL_SIZE. Keep it in 56 + * the slow-path after the range-check! 56 57 */ 57 - return unlikely((unsigned long)((char *)addr - __kfence_pool) < KFENCE_POOL_SIZE && addr); 58 + return unlikely((unsigned long)((char *)addr - __kfence_pool) < KFENCE_POOL_SIZE && __kfence_pool); 58 59 } 59 60 60 61 /**

+15 -14

include/linux/memcontrol.h

··· 612 612 return !cgroup_subsys_enabled(memory_cgrp_subsys); 613 613 } 614 614 615 - static inline unsigned long mem_cgroup_protection(struct mem_cgroup *root, 616 - struct mem_cgroup *memcg, 617 - bool in_low_reclaim) 615 + static inline void mem_cgroup_protection(struct mem_cgroup *root, 616 + struct mem_cgroup *memcg, 617 + unsigned long *min, 618 + unsigned long *low) 618 619 { 620 + *min = *low = 0; 621 + 619 622 if (mem_cgroup_disabled()) 620 - return 0; 623 + return; 621 624 622 625 /* 623 626 * There is no reclaim protection applied to a targeted reclaim. ··· 656 653 * 657 654 */ 658 655 if (root == memcg) 659 - return 0; 656 + return; 660 657 661 - if (in_low_reclaim) 662 - return READ_ONCE(memcg->memory.emin); 663 - 664 - return max(READ_ONCE(memcg->memory.emin), 665 - READ_ONCE(memcg->memory.elow)); 658 + *min = READ_ONCE(memcg->memory.emin); 659 + *low = READ_ONCE(memcg->memory.elow); 666 660 } 667 661 668 662 void mem_cgroup_calculate_protection(struct mem_cgroup *root, ··· 1147 1147 { 1148 1148 } 1149 1149 1150 - static inline unsigned long mem_cgroup_protection(struct mem_cgroup *root, 1151 - struct mem_cgroup *memcg, 1152 - bool in_low_reclaim) 1150 + static inline void mem_cgroup_protection(struct mem_cgroup *root, 1151 + struct mem_cgroup *memcg, 1152 + unsigned long *min, 1153 + unsigned long *low) 1153 1154 { 1154 - return 0; 1155 + *min = *low = 0; 1155 1156 } 1156 1157 1157 1158 static inline void mem_cgroup_calculate_protection(struct mem_cgroup *root,

+3 -1

include/trace/events/mmflags.h

··· 48 48 {(unsigned long)__GFP_WRITE, "__GFP_WRITE"}, \ 49 49 {(unsigned long)__GFP_RECLAIM, "__GFP_RECLAIM"}, \ 50 50 {(unsigned long)__GFP_DIRECT_RECLAIM, "__GFP_DIRECT_RECLAIM"},\ 51 - {(unsigned long)__GFP_KSWAPD_RECLAIM, "__GFP_KSWAPD_RECLAIM"}\ 51 + {(unsigned long)__GFP_KSWAPD_RECLAIM, "__GFP_KSWAPD_RECLAIM"},\ 52 + {(unsigned long)__GFP_ZEROTAGS, "__GFP_ZEROTAGS"}, \ 53 + {(unsigned long)__GFP_SKIP_KASAN_POISON,"__GFP_SKIP_KASAN_POISON"}\ 52 54 53 55 #define show_gfp_flags(flags) \ 54 56 (flags) ? __print_flags(flags, "|", \

+14 -5

mm/hugetlb.c

··· 2476 2476 if (!rc) { 2477 2477 /* 2478 2478 * This indicates there is an entry in the reserve map 2479 - * added by alloc_huge_page. We know it was added 2479 + * not added by alloc_huge_page. We know it was added 2480 2480 * before the alloc_huge_page call, otherwise 2481 2481 * HPageRestoreReserve would be set on the page. 2482 2482 * Remove the entry so that a subsequent allocation ··· 4660 4660 spin_unlock(ptl); 4661 4661 mmu_notifier_invalidate_range_end(&range); 4662 4662 out_release_all: 4663 - restore_reserve_on_error(h, vma, haddr, new_page); 4663 + /* No restore in case of successful pagetable update (Break COW) */ 4664 + if (new_page != old_page) 4665 + restore_reserve_on_error(h, vma, haddr, new_page); 4664 4666 put_page(new_page); 4665 4667 out_release_old: 4666 4668 put_page(old_page); ··· 4778 4776 pte_t new_pte; 4779 4777 spinlock_t *ptl; 4780 4778 unsigned long haddr = address & huge_page_mask(h); 4781 - bool new_page = false; 4779 + bool new_page, new_pagecache_page = false; 4782 4780 4783 4781 /* 4784 4782 * Currently, we are forced to kill the process in the event the ··· 4801 4799 goto out; 4802 4800 4803 4801 retry: 4802 + new_page = false; 4804 4803 page = find_lock_page(mapping, idx); 4805 4804 if (!page) { 4806 4805 /* Check for page in userfault range */ ··· 4845 4842 goto retry; 4846 4843 goto out; 4847 4844 } 4845 + new_pagecache_page = true; 4848 4846 } else { 4849 4847 lock_page(page); 4850 4848 if (unlikely(anon_vma_prepare(vma))) { ··· 4930 4926 spin_unlock(ptl); 4931 4927 backout_unlocked: 4932 4928 unlock_page(page); 4933 - restore_reserve_on_error(h, vma, haddr, page); 4929 + /* restore reserve for newly allocated pages not in page cache */ 4930 + if (new_page && !new_pagecache_page) 4931 + restore_reserve_on_error(h, vma, haddr, page); 4934 4932 put_page(page); 4935 4933 goto out; 4936 4934 } ··· 5141 5135 int ret = -ENOMEM; 5142 5136 struct page *page; 5143 5137 int writable; 5138 + bool new_pagecache_page = false; 5144 5139 5145 5140 if (is_continue) { 5146 5141 ret = -EFAULT; ··· 5235 5228 ret = huge_add_to_page_cache(page, mapping, idx); 5236 5229 if (ret) 5237 5230 goto out_release_nounlock; 5231 + new_pagecache_page = true; 5238 5232 } 5239 5233 5240 5234 ptl = huge_pte_lockptr(h, dst_mm, dst_pte); ··· 5299 5291 if (vm_shared || is_continue) 5300 5292 unlock_page(page); 5301 5293 out_release_nounlock: 5302 - restore_reserve_on_error(h, dst_vma, dst_addr, page); 5294 + if (!new_pagecache_page) 5295 + restore_reserve_on_error(h, dst_vma, dst_addr, page); 5303 5296 put_page(page); 5304 5297 goto out; 5305 5298 }

+9 -3

mm/memory-failure.c

··· 1146 1146 * unexpected races caused by taking a page refcount. 1147 1147 */ 1148 1148 if (!HWPoisonHandlable(head)) 1149 - return 0; 1149 + return -EBUSY; 1150 1150 1151 1151 if (PageTransHuge(head)) { 1152 1152 /* ··· 1199 1199 } 1200 1200 goto out; 1201 1201 } else if (ret == -EBUSY) { 1202 - /* We raced with freeing huge page to buddy, retry. */ 1203 - if (pass++ < 3) 1202 + /* 1203 + * We raced with (possibly temporary) unhandlable 1204 + * page, retry. 1205 + */ 1206 + if (pass++ < 3) { 1207 + shake_page(p, 1); 1204 1208 goto try_again; 1209 + } 1210 + ret = -EIO; 1205 1211 goto out; 1206 1212 } 1207 1213 }

+12 -13

mm/page_alloc.c

··· 3453 3453 * comment in free_unref_page. 3454 3454 */ 3455 3455 migratetype = get_pcppage_migratetype(page); 3456 - if (unlikely(migratetype >= MIGRATE_PCPTYPES)) { 3457 - if (unlikely(is_migrate_isolate(migratetype))) { 3458 - list_del(&page->lru); 3459 - free_one_page(page_zone(page), page, pfn, 0, 3460 - migratetype, FPI_NONE); 3461 - continue; 3462 - } 3463 - 3464 - /* 3465 - * Non-isolated types over MIGRATE_PCPTYPES get added 3466 - * to the MIGRATE_MOVABLE pcp list. 3467 - */ 3468 - set_pcppage_migratetype(page, MIGRATE_MOVABLE); 3456 + if (unlikely(is_migrate_isolate(migratetype))) { 3457 + list_del(&page->lru); 3458 + free_one_page(page_zone(page), page, pfn, 0, migratetype, FPI_NONE); 3459 + continue; 3469 3460 } 3470 3461 3471 3462 set_page_private(page, pfn); ··· 3466 3475 list_for_each_entry_safe(page, next, list, lru) { 3467 3476 pfn = page_private(page); 3468 3477 set_page_private(page, 0); 3478 + 3479 + /* 3480 + * Non-isolated types over MIGRATE_PCPTYPES get added 3481 + * to the MIGRATE_MOVABLE pcp list. 3482 + */ 3469 3483 migratetype = get_pcppage_migratetype(page); 3484 + if (unlikely(migratetype >= MIGRATE_PCPTYPES)) 3485 + migratetype = MIGRATE_MOVABLE; 3486 + 3470 3487 trace_mm_page_free_batched(page); 3471 3488 free_unref_page_commit(page, pfn, migratetype, 0); 3472 3489

+1 -13

mm/shmem.c

··· 1696 1696 struct address_space *mapping = inode->i_mapping; 1697 1697 struct shmem_inode_info *info = SHMEM_I(inode); 1698 1698 struct mm_struct *charge_mm = vma ? vma->vm_mm : NULL; 1699 - struct swap_info_struct *si; 1700 - struct page *page = NULL; 1699 + struct page *page; 1701 1700 swp_entry_t swap; 1702 1701 int error; 1703 1702 ··· 1704 1705 swap = radix_to_swp_entry(*pagep); 1705 1706 *pagep = NULL; 1706 1707 1707 - /* Prevent swapoff from happening to us. */ 1708 - si = get_swap_device(swap); 1709 - if (!si) { 1710 - error = EINVAL; 1711 - goto failed; 1712 - } 1713 1708 /* Look it up and read it in.. */ 1714 1709 page = lookup_swap_cache(swap, NULL, 0); 1715 1710 if (!page) { ··· 1765 1772 swap_free(swap); 1766 1773 1767 1774 *pagep = page; 1768 - if (si) 1769 - put_swap_device(si); 1770 1775 return 0; 1771 1776 failed: 1772 1777 if (!shmem_confirm_swap(mapping, index, swap)) ··· 1774 1783 unlock_page(page); 1775 1784 put_page(page); 1776 1785 } 1777 - 1778 - if (si) 1779 - put_swap_device(si); 1780 1786 1781 1787 return error; 1782 1788 }

-7

mm/swap_state.c

··· 628 628 if (!mask) 629 629 goto skip; 630 630 631 - /* Test swap type to make sure the dereference is safe */ 632 - if (likely(si->flags & (SWP_BLKDEV | SWP_FS_OPS))) { 633 - struct inode *inode = si->swap_file->f_mapping->host; 634 - if (inode_read_congested(inode)) 635 - goto skip; 636 - } 637 - 638 631 do_poll = false; 639 632 /* Read a page_cluster sized and aligned cluster around offset. */ 640 633 start_offset = offset & ~mask;

+22 -8

mm/vmscan.c

··· 100 100 unsigned int may_swap:1; 101 101 102 102 /* 103 - * Cgroups are not reclaimed below their configured memory.low, 104 - * unless we threaten to OOM. If any cgroups are skipped due to 105 - * memory.low and nothing was reclaimed, go back for memory.low. 103 + * Cgroup memory below memory.low is protected as long as we 104 + * don't threaten to OOM. If any cgroup is reclaimed at 105 + * reduced force or passed over entirely due to its memory.low 106 + * setting (memcg_low_skipped), and nothing is reclaimed as a 107 + * result, then go back for one more cycle that reclaims the protected 108 + * memory (memcg_low_reclaim) to avert OOM. 106 109 */ 107 110 unsigned int memcg_low_reclaim:1; 108 111 unsigned int memcg_low_skipped:1; ··· 2540 2537 for_each_evictable_lru(lru) { 2541 2538 int file = is_file_lru(lru); 2542 2539 unsigned long lruvec_size; 2540 + unsigned long low, min; 2543 2541 unsigned long scan; 2544 - unsigned long protection; 2545 2542 2546 2543 lruvec_size = lruvec_lru_size(lruvec, lru, sc->reclaim_idx); 2547 - protection = mem_cgroup_protection(sc->target_mem_cgroup, 2548 - memcg, 2549 - sc->memcg_low_reclaim); 2544 + mem_cgroup_protection(sc->target_mem_cgroup, memcg, 2545 + &min, &low); 2550 2546 2551 - if (protection) { 2547 + if (min || low) { 2552 2548 /* 2553 2549 * Scale a cgroup's reclaim pressure by proportioning 2554 2550 * its current usage to its memory.low or memory.min ··· 2578 2576 * hard protection. 2579 2577 */ 2580 2578 unsigned long cgroup_size = mem_cgroup_size(memcg); 2579 + unsigned long protection; 2580 + 2581 + /* memory.low scaling, make sure we retry before OOM */ 2582 + if (!sc->memcg_low_reclaim && low > min) { 2583 + protection = low; 2584 + sc->memcg_low_skipped = 1; 2585 + } else { 2586 + protection = min; 2587 + } 2581 2588 2582 2589 /* Avoid TOCTOU with earlier protection check */ 2583 2590 cgroup_size = max(cgroup_size, protection); ··· 4424 4413 .may_swap = 1, 4425 4414 .reclaim_idx = gfp_zone(gfp_mask), 4426 4415 }; 4416 + unsigned long pflags; 4427 4417 4428 4418 trace_mm_vmscan_node_reclaim_begin(pgdat->node_id, order, 4429 4419 sc.gfp_mask); 4430 4420 4431 4421 cond_resched(); 4422 + psi_memstall_enter(&pflags); 4432 4423 fs_reclaim_acquire(sc.gfp_mask); 4433 4424 /* 4434 4425 * We need to be able to allocate from the reserves for RECLAIM_UNMAP ··· 4455 4442 current->flags &= ~PF_SWAPWRITE; 4456 4443 memalloc_noreclaim_restore(noreclaim_flag); 4457 4444 fs_reclaim_release(sc.gfp_mask); 4445 + psi_memstall_leave(&pflags); 4458 4446 4459 4447 trace_mm_vmscan_node_reclaim_end(sc.nr_reclaimed); 4460 4448

Configure Feed

Configure Feed