tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'mm-hotfixes-stable-2025-07-24-18-03' of git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm

Pull misc fixes from Andrew Morton:
"11 hotfixes. 9 are cc:stable and the remainder address post-6.15
issues or aren't considered necessary for -stable kernels.

7 are for MM"

* tag 'mm-hotfixes-stable-2025-07-24-18-03' of git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm:
sprintf.h requires stdarg.h
resource: fix false warning in __request_region()
mm/damon/core: commit damos_quota_goal->nid
kasan: use vmalloc_dump_obj() for vmalloc error reports
mm/ksm: fix -Wsometimes-uninitialized from clang-21 in advisor_mode_show()
mm: update MAINTAINERS entry for HMM
nilfs2: reject invalid file types when reading inodes
selftests/mm: fix split_huge_page_test for folio_split() tests
mailmap: add entry for Senozhatsky
mm/zsmalloc: do not pass __GFP_MOVABLE if CONFIG_COMPACTION=n
mm/vmscan: fix hwpoisoned large folio handling in shrink_folio_list

Linus Torvalds 2942242d 94ce1ac2

+60 -9
+4
.mailmap
··· 694 694 Senthilkumar N L <quic_snlakshm@quicinc.com> <snlakshm@codeaurora.org> 695 695 Serge Hallyn <sergeh@kernel.org> <serge.hallyn@canonical.com> 696 696 Serge Hallyn <sergeh@kernel.org> <serue@us.ibm.com> 697 + Sergey Senozhatsky <senozhatsky@chromium.org> <sergey.senozhatsky.work@gmail.com> 698 + Sergey Senozhatsky <senozhatsky@chromium.org> <sergey.senozhatsky@gmail.com> 699 + Sergey Senozhatsky <senozhatsky@chromium.org> <sergey.senozhatsky@mail.by> 700 + Sergey Senozhatsky <senozhatsky@chromium.org> <senozhatsky@google.com> 697 701 Seth Forshee <sforshee@kernel.org> <seth.forshee@canonical.com> 698 702 Shakeel Butt <shakeel.butt@linux.dev> <shakeelb@google.com> 699 703 Shannon Nelson <sln@onemain.com> <shannon.nelson@amd.com>
+4
CREDITS
··· 1397 1397 E: tglx@linutronix.de 1398 1398 D: NAND flash hardware support, JFFS2 on NAND flash 1399 1399 1400 + N: Jérôme Glisse 1401 + E: jglisse@redhat.com 1402 + D: HMM - Heterogeneous Memory Management 1403 + 1400 1404 N: Richard E. Gooch 1401 1405 E: rgooch@atnf.csiro.au 1402 1406 D: parent process death signal to children
+2 -1
MAINTAINERS
··· 11009 11009 F: drivers/crypto/hisilicon/zip/ 11010 11010 11011 11011 HMM - Heterogeneous Memory Management 11012 - M: Jérôme Glisse <jglisse@redhat.com> 11012 + M: Jason Gunthorpe <jgg@nvidia.com> 11013 + M: Leon Romanovsky <leonro@nvidia.com> 11013 11014 L: linux-mm@kvack.org 11014 11015 S: Maintained 11015 11016 F: Documentation/mm/hmm.rst
+8 -1
fs/nilfs2/inode.c
··· 472 472 inode->i_op = &nilfs_symlink_inode_operations; 473 473 inode_nohighmem(inode); 474 474 inode->i_mapping->a_ops = &nilfs_aops; 475 - } else { 475 + } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) || 476 + S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) { 476 477 inode->i_op = &nilfs_special_inode_operations; 477 478 init_special_inode( 478 479 inode, inode->i_mode, 479 480 huge_decode_dev(le64_to_cpu(raw_inode->i_device_code))); 481 + } else { 482 + nilfs_error(sb, 483 + "invalid file type bits in mode 0%o for inode %lu", 484 + inode->i_mode, ino); 485 + err = -EIO; 486 + goto failed_unmap; 480 487 } 481 488 nilfs_ifile_unmap_inode(raw_inode); 482 489 brelse(bh);
+1
include/linux/sprintf.h
··· 4 4 5 5 #include <linux/compiler_attributes.h> 6 6 #include <linux/types.h> 7 + #include <linux/stdarg.h> 7 8 8 9 int num_to_str(char *buf, int size, unsigned long long num, unsigned int width); 9 10
+3 -2
kernel/resource.c
··· 1279 1279 * become unavailable to other users. Conflicts are 1280 1280 * not expected. Warn to aid debugging if encountered. 1281 1281 */ 1282 - if (conflict->desc == IORES_DESC_DEVICE_PRIVATE_MEMORY) { 1283 - pr_warn("Unaddressable device %s %pR conflicts with %pR", 1282 + if (parent == &iomem_resource && 1283 + conflict->desc == IORES_DESC_DEVICE_PRIVATE_MEMORY) { 1284 + pr_warn("Unaddressable device %s %pR conflicts with %pR\n", 1284 1285 conflict->name, conflict, res); 1285 1286 } 1286 1287 if (conflict != parent) {
+15
mm/damon/core.c
··· 754 754 return NULL; 755 755 } 756 756 757 + static void damos_commit_quota_goal_union( 758 + struct damos_quota_goal *dst, struct damos_quota_goal *src) 759 + { 760 + switch (dst->metric) { 761 + case DAMOS_QUOTA_NODE_MEM_USED_BP: 762 + case DAMOS_QUOTA_NODE_MEM_FREE_BP: 763 + dst->nid = src->nid; 764 + break; 765 + default: 766 + break; 767 + } 768 + } 769 + 757 770 static void damos_commit_quota_goal( 758 771 struct damos_quota_goal *dst, struct damos_quota_goal *src) 759 772 { ··· 775 762 if (dst->metric == DAMOS_QUOTA_USER_INPUT) 776 763 dst->current_value = src->current_value; 777 764 /* keep last_psi_total as is, since it will be updated in next cycle */ 765 + damos_commit_quota_goal_union(dst, src); 778 766 } 779 767 780 768 /** ··· 809 795 src_goal->metric, src_goal->target_value); 810 796 if (!new_goal) 811 797 return -ENOMEM; 798 + damos_commit_quota_goal_union(new_goal, src_goal); 812 799 damos_add_quota_goal(dst, new_goal); 813 800 } 814 801 return 0;
+3 -1
mm/kasan/report.c
··· 399 399 } 400 400 401 401 if (is_vmalloc_addr(addr)) { 402 - pr_err("The buggy address %px belongs to a vmalloc virtual mapping\n", addr); 402 + pr_err("The buggy address belongs to a"); 403 + if (!vmalloc_dump_obj(addr)) 404 + pr_cont(" vmalloc virtual mapping\n"); 403 405 page = vmalloc_to_page(addr); 404 406 } 405 407
+3 -3
mm/ksm.c
··· 3669 3669 { 3670 3670 const char *output; 3671 3671 3672 - if (ksm_advisor == KSM_ADVISOR_NONE) 3673 - output = "[none] scan-time"; 3674 - else if (ksm_advisor == KSM_ADVISOR_SCAN_TIME) 3672 + if (ksm_advisor == KSM_ADVISOR_SCAN_TIME) 3675 3673 output = "none [scan-time]"; 3674 + else 3675 + output = "[none] scan-time"; 3676 3676 3677 3677 return sysfs_emit(buf, "%s\n", output); 3678 3678 }
+4
mm/memory-failure.c
··· 1561 1561 return ret; 1562 1562 } 1563 1563 1564 + /* 1565 + * The caller must guarantee the folio isn't large folio, except hugetlb. 1566 + * try_to_unmap() can't handle it. 1567 + */ 1564 1568 int unmap_poisoned_folio(struct folio *folio, unsigned long pfn, bool must_kill) 1565 1569 { 1566 1570 enum ttu_flags ttu = TTU_IGNORE_MLOCK | TTU_SYNC | TTU_HWPOISON;
+8
mm/vmscan.c
··· 1138 1138 goto keep; 1139 1139 1140 1140 if (folio_contain_hwpoisoned_page(folio)) { 1141 + /* 1142 + * unmap_poisoned_folio() can't handle large 1143 + * folio, just skip it. memory_failure() will 1144 + * handle it if the UCE is triggered again. 1145 + */ 1146 + if (folio_test_large(folio)) 1147 + goto keep_locked; 1148 + 1141 1149 unmap_poisoned_folio(folio, folio_pfn(folio), false); 1142 1150 folio_unlock(folio); 1143 1151 folio_put(folio);
+3
mm/zsmalloc.c
··· 1043 1043 if (!zspage) 1044 1044 return NULL; 1045 1045 1046 + if (!IS_ENABLED(CONFIG_COMPACTION)) 1047 + gfp &= ~__GFP_MOVABLE; 1048 + 1046 1049 zspage->magic = ZSPAGE_MAGIC; 1047 1050 zspage->pool = pool; 1048 1051 zspage->class = class->index;
+2 -1
tools/testing/selftests/mm/split_huge_page_test.c
··· 31 31 #define INPUT_MAX 80 32 32 33 33 #define PID_FMT "%d,0x%lx,0x%lx,%d" 34 + #define PID_FMT_OFFSET "%d,0x%lx,0x%lx,%d,%d" 34 35 #define PATH_FMT "%s,0x%lx,0x%lx,%d" 35 36 36 37 #define PFN_MASK ((1UL<<55)-1) ··· 484 483 write_debugfs(PID_FMT, getpid(), (uint64_t)addr, 485 484 (uint64_t)addr + fd_size, order); 486 485 else 487 - write_debugfs(PID_FMT, getpid(), (uint64_t)addr, 486 + write_debugfs(PID_FMT_OFFSET, getpid(), (uint64_t)addr, 488 487 (uint64_t)addr + fd_size, order, offset); 489 488 490 489 for (i = 0; i < fd_size; i++)