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 branch 'akpm' (patches from Andrew)

Merge misc fixes from Andrew Morton:
"14 patches.

Subsystems affected by this patch series: MAINTAINERS, binfmt, and
mm (tmpfs, secretmem, kasan, kfence, pagealloc, zram, compaction,
hugetlb, vmalloc, and kmemleak)"

* emailed patches from Andrew Morton <akpm@linux-foundation.org>:
mm: kmemleak: take a full lowmem check in kmemleak_*_phys()
mm/vmalloc: fix spinning drain_vmap_work after reading from /proc/vmcore
revert "fs/binfmt_elf: use PT_LOAD p_align values for static PIE"
revert "fs/binfmt_elf: fix PT_LOAD p_align values for loaders"
hugetlb: do not demote poisoned hugetlb pages
mm: compaction: fix compiler warning when CONFIG_COMPACTION=n
mm: fix unexpected zeroed page mapping with zram swap
mm, page_alloc: fix build_zonerefs_node()
mm, kfence: support kmem_dump_obj() for KFENCE objects
kasan: fix hw tags enablement when KUNIT tests are disabled
irq_work: use kasan_record_aux_stack_noalloc() record callstack
mm/secretmem: fix panic when growing a memfd_secret
tmpfs: fix regressions from wider use of ZERO_PAGE
MAINTAINERS: Broadcom internal lists aren't maintainers

Linus Torvalds 59250f8a ce673f63

+206 -168
+32 -32
MAINTAINERS
··· 3743 3743 3744 3744 BROADCOM BCM2711/BCM2835 ARM ARCHITECTURE 3745 3745 M: Nicolas Saenz Julienne <nsaenz@kernel.org> 3746 - L: bcm-kernel-feedback-list@broadcom.com 3746 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 3747 3747 L: linux-rpi-kernel@lists.infradead.org (moderated for non-subscribers) 3748 3748 L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers) 3749 3749 S: Maintained ··· 3758 3758 M: Florian Fainelli <f.fainelli@gmail.com> 3759 3759 M: Ray Jui <rjui@broadcom.com> 3760 3760 M: Scott Branden <sbranden@broadcom.com> 3761 - M: bcm-kernel-feedback-list@broadcom.com 3761 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 3762 3762 S: Maintained 3763 3763 T: git git://github.com/broadcom/mach-bcm 3764 3764 F: arch/arm/mach-bcm/ ··· 3778 3778 3779 3779 BROADCOM BCM4908 ETHERNET DRIVER 3780 3780 M: Rafał Miłecki <rafal@milecki.pl> 3781 - M: bcm-kernel-feedback-list@broadcom.com 3781 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 3782 3782 L: netdev@vger.kernel.org 3783 3783 S: Maintained 3784 3784 F: Documentation/devicetree/bindings/net/brcm,bcm4908-enet.yaml ··· 3787 3787 3788 3788 BROADCOM BCM4908 PINMUX DRIVER 3789 3789 M: Rafał Miłecki <rafal@milecki.pl> 3790 - M: bcm-kernel-feedback-list@broadcom.com 3790 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 3791 3791 L: linux-gpio@vger.kernel.org 3792 3792 S: Maintained 3793 3793 F: Documentation/devicetree/bindings/pinctrl/brcm,bcm4908-pinctrl.yaml ··· 3797 3797 M: Florian Fainelli <f.fainelli@gmail.com> 3798 3798 M: Hauke Mehrtens <hauke@hauke-m.de> 3799 3799 M: Rafał Miłecki <zajec5@gmail.com> 3800 - M: bcm-kernel-feedback-list@broadcom.com 3800 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 3801 3801 L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers) 3802 3802 S: Maintained 3803 3803 F: arch/arm/boot/dts/bcm470* ··· 3808 3808 BROADCOM BCM53573 ARM ARCHITECTURE 3809 3809 M: Florian Fainelli <f.fainelli@gmail.com> 3810 3810 M: Rafał Miłecki <rafal@milecki.pl> 3811 - L: bcm-kernel-feedback-list@broadcom.com 3811 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 3812 3812 L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers) 3813 3813 S: Maintained 3814 3814 F: arch/arm/boot/dts/bcm47189* ··· 3816 3816 3817 3817 BROADCOM BCM63XX ARM ARCHITECTURE 3818 3818 M: Florian Fainelli <f.fainelli@gmail.com> 3819 - M: bcm-kernel-feedback-list@broadcom.com 3819 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 3820 3820 L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers) 3821 3821 S: Maintained 3822 3822 T: git git://github.com/broadcom/stblinux.git ··· 3830 3830 3831 3831 BROADCOM BCM7XXX ARM ARCHITECTURE 3832 3832 M: Florian Fainelli <f.fainelli@gmail.com> 3833 - M: bcm-kernel-feedback-list@broadcom.com 3833 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 3834 3834 L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers) 3835 3835 S: Maintained 3836 3836 T: git git://github.com/broadcom/stblinux.git ··· 3848 3848 BROADCOM BDC DRIVER 3849 3849 M: Al Cooper <alcooperx@gmail.com> 3850 3850 L: linux-usb@vger.kernel.org 3851 - L: bcm-kernel-feedback-list@broadcom.com 3851 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 3852 3852 S: Maintained 3853 3853 F: Documentation/devicetree/bindings/usb/brcm,bdc.yaml 3854 3854 F: drivers/usb/gadget/udc/bdc/ 3855 3855 3856 3856 BROADCOM BMIPS CPUFREQ DRIVER 3857 3857 M: Markus Mayer <mmayer@broadcom.com> 3858 - M: bcm-kernel-feedback-list@broadcom.com 3858 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 3859 3859 L: linux-pm@vger.kernel.org 3860 3860 S: Maintained 3861 3861 F: drivers/cpufreq/bmips-cpufreq.c 3862 3862 3863 3863 BROADCOM BMIPS MIPS ARCHITECTURE 3864 3864 M: Florian Fainelli <f.fainelli@gmail.com> 3865 - L: bcm-kernel-feedback-list@broadcom.com 3865 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 3866 3866 L: linux-mips@vger.kernel.org 3867 3867 S: Maintained 3868 3868 T: git git://github.com/broadcom/stblinux.git ··· 3928 3928 BROADCOM BRCMSTB GPIO DRIVER 3929 3929 M: Doug Berger <opendmb@gmail.com> 3930 3930 M: Florian Fainelli <f.fainelli@gmail.com> 3931 - L: bcm-kernel-feedback-list@broadcom.com 3931 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 3932 3932 S: Supported 3933 3933 F: Documentation/devicetree/bindings/gpio/brcm,brcmstb-gpio.yaml 3934 3934 F: drivers/gpio/gpio-brcmstb.c 3935 3935 3936 3936 BROADCOM BRCMSTB I2C DRIVER 3937 3937 M: Kamal Dasu <kdasu.kdev@gmail.com> 3938 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 3938 3939 L: linux-i2c@vger.kernel.org 3939 - L: bcm-kernel-feedback-list@broadcom.com 3940 3940 S: Supported 3941 3941 F: Documentation/devicetree/bindings/i2c/brcm,brcmstb-i2c.yaml 3942 3942 F: drivers/i2c/busses/i2c-brcmstb.c 3943 3943 3944 3944 BROADCOM BRCMSTB UART DRIVER 3945 3945 M: Al Cooper <alcooperx@gmail.com> 3946 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 3946 3947 L: linux-serial@vger.kernel.org 3947 - L: bcm-kernel-feedback-list@broadcom.com 3948 3948 S: Maintained 3949 3949 F: Documentation/devicetree/bindings/serial/brcm,bcm7271-uart.yaml 3950 3950 F: drivers/tty/serial/8250/8250_bcm7271.c 3951 3951 3952 3952 BROADCOM BRCMSTB USB EHCI DRIVER 3953 3953 M: Al Cooper <alcooperx@gmail.com> 3954 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 3954 3955 L: linux-usb@vger.kernel.org 3955 - L: bcm-kernel-feedback-list@broadcom.com 3956 3956 S: Maintained 3957 3957 F: Documentation/devicetree/bindings/usb/brcm,bcm7445-ehci.yaml 3958 3958 F: drivers/usb/host/ehci-brcm.* 3959 3959 3960 3960 BROADCOM BRCMSTB USB PIN MAP DRIVER 3961 3961 M: Al Cooper <alcooperx@gmail.com> 3962 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 3962 3963 L: linux-usb@vger.kernel.org 3963 - L: bcm-kernel-feedback-list@broadcom.com 3964 3964 S: Maintained 3965 3965 F: Documentation/devicetree/bindings/usb/brcm,usb-pinmap.yaml 3966 3966 F: drivers/usb/misc/brcmstb-usb-pinmap.c 3967 3967 3968 3968 BROADCOM BRCMSTB USB2 and USB3 PHY DRIVER 3969 3969 M: Al Cooper <alcooperx@gmail.com> 3970 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 3970 3971 L: linux-kernel@vger.kernel.org 3971 - L: bcm-kernel-feedback-list@broadcom.com 3972 3972 S: Maintained 3973 3973 F: drivers/phy/broadcom/phy-brcm-usb* 3974 3974 3975 3975 BROADCOM ETHERNET PHY DRIVERS 3976 3976 M: Florian Fainelli <f.fainelli@gmail.com> 3977 - L: bcm-kernel-feedback-list@broadcom.com 3977 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 3978 3978 L: netdev@vger.kernel.org 3979 3979 S: Supported 3980 3980 F: Documentation/devicetree/bindings/net/broadcom-bcm87xx.txt ··· 3985 3985 BROADCOM GENET ETHERNET DRIVER 3986 3986 M: Doug Berger <opendmb@gmail.com> 3987 3987 M: Florian Fainelli <f.fainelli@gmail.com> 3988 - L: bcm-kernel-feedback-list@broadcom.com 3988 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 3989 3989 L: netdev@vger.kernel.org 3990 3990 S: Supported 3991 3991 F: Documentation/devicetree/bindings/net/brcm,bcmgenet.yaml ··· 3999 3999 BROADCOM IPROC ARM ARCHITECTURE 4000 4000 M: Ray Jui <rjui@broadcom.com> 4001 4001 M: Scott Branden <sbranden@broadcom.com> 4002 - M: bcm-kernel-feedback-list@broadcom.com 4002 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 4003 4003 L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers) 4004 4004 S: Maintained 4005 4005 T: git git://github.com/broadcom/stblinux.git ··· 4027 4027 4028 4028 BROADCOM IPROC GBIT ETHERNET DRIVER 4029 4029 M: Rafał Miłecki <rafal@milecki.pl> 4030 - M: bcm-kernel-feedback-list@broadcom.com 4030 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 4031 4031 L: netdev@vger.kernel.org 4032 4032 S: Maintained 4033 4033 F: Documentation/devicetree/bindings/net/brcm,amac.yaml ··· 4036 4036 4037 4037 BROADCOM KONA GPIO DRIVER 4038 4038 M: Ray Jui <rjui@broadcom.com> 4039 - L: bcm-kernel-feedback-list@broadcom.com 4039 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 4040 4040 S: Supported 4041 4041 F: Documentation/devicetree/bindings/gpio/brcm,kona-gpio.txt 4042 4042 F: drivers/gpio/gpio-bcm-kona.c ··· 4069 4069 BROADCOM PMB (POWER MANAGEMENT BUS) DRIVER 4070 4070 M: Rafał Miłecki <rafal@milecki.pl> 4071 4071 M: Florian Fainelli <f.fainelli@gmail.com> 4072 - M: bcm-kernel-feedback-list@broadcom.com 4072 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 4073 4073 L: linux-pm@vger.kernel.org 4074 4074 S: Maintained 4075 4075 T: git git://github.com/broadcom/stblinux.git ··· 4085 4085 4086 4086 BROADCOM SPI DRIVER 4087 4087 M: Kamal Dasu <kdasu.kdev@gmail.com> 4088 - M: bcm-kernel-feedback-list@broadcom.com 4088 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 4089 4089 S: Maintained 4090 4090 F: Documentation/devicetree/bindings/spi/brcm,spi-bcm-qspi.yaml 4091 4091 F: drivers/spi/spi-bcm-qspi.* ··· 4094 4094 4095 4095 BROADCOM STB AVS CPUFREQ DRIVER 4096 4096 M: Markus Mayer <mmayer@broadcom.com> 4097 - M: bcm-kernel-feedback-list@broadcom.com 4097 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 4098 4098 L: linux-pm@vger.kernel.org 4099 4099 S: Maintained 4100 4100 F: Documentation/devicetree/bindings/cpufreq/brcm,stb-avs-cpu-freq.txt ··· 4102 4102 4103 4103 BROADCOM STB AVS TMON DRIVER 4104 4104 M: Markus Mayer <mmayer@broadcom.com> 4105 - M: bcm-kernel-feedback-list@broadcom.com 4105 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 4106 4106 L: linux-pm@vger.kernel.org 4107 4107 S: Maintained 4108 4108 F: Documentation/devicetree/bindings/thermal/brcm,avs-tmon.yaml ··· 4110 4110 4111 4111 BROADCOM STB DPFE DRIVER 4112 4112 M: Markus Mayer <mmayer@broadcom.com> 4113 - M: bcm-kernel-feedback-list@broadcom.com 4113 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 4114 4114 L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers) 4115 4115 S: Maintained 4116 4116 F: Documentation/devicetree/bindings/memory-controllers/brcm,dpfe-cpu.yaml ··· 4119 4119 BROADCOM STB NAND FLASH DRIVER 4120 4120 M: Brian Norris <computersforpeace@gmail.com> 4121 4121 M: Kamal Dasu <kdasu.kdev@gmail.com> 4122 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 4122 4123 L: linux-mtd@lists.infradead.org 4123 - L: bcm-kernel-feedback-list@broadcom.com 4124 4124 S: Maintained 4125 4125 F: drivers/mtd/nand/raw/brcmnand/ 4126 4126 F: include/linux/platform_data/brcmnand.h ··· 4129 4129 M: Jim Quinlan <jim2101024@gmail.com> 4130 4130 M: Nicolas Saenz Julienne <nsaenz@kernel.org> 4131 4131 M: Florian Fainelli <f.fainelli@gmail.com> 4132 - M: bcm-kernel-feedback-list@broadcom.com 4132 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 4133 4133 L: linux-pci@vger.kernel.org 4134 4134 S: Maintained 4135 4135 F: Documentation/devicetree/bindings/pci/brcm,stb-pcie.yaml ··· 4137 4137 4138 4138 BROADCOM SYSTEMPORT ETHERNET DRIVER 4139 4139 M: Florian Fainelli <f.fainelli@gmail.com> 4140 - L: bcm-kernel-feedback-list@broadcom.com 4140 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 4141 4141 L: netdev@vger.kernel.org 4142 4142 S: Supported 4143 4143 F: drivers/net/ethernet/broadcom/bcmsysport.* ··· 4154 4154 4155 4155 BROADCOM VK DRIVER 4156 4156 M: Scott Branden <scott.branden@broadcom.com> 4157 - L: bcm-kernel-feedback-list@broadcom.com 4157 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 4158 4158 S: Supported 4159 4159 F: drivers/misc/bcm-vk/ 4160 4160 F: include/uapi/linux/misc/bcm_vk.h ··· 17648 17648 17649 17649 SECURE DIGITAL HOST CONTROLLER INTERFACE (SDHCI) Broadcom BRCMSTB DRIVER 17650 17650 M: Al Cooper <alcooperx@gmail.com> 17651 + R: Broadcom Kernel Team <bcm-kernel-feedback-list@broadcom.com> 17651 17652 L: linux-mmc@vger.kernel.org 17652 - L: bcm-kernel-feedback-list@broadcom.com 17653 17653 S: Maintained 17654 17654 F: drivers/mmc/host/sdhci-brcmstb* 17655 17655
-2
arch/x86/include/asm/io.h
··· 210 210 extern void iounmap(volatile void __iomem *addr); 211 211 #define iounmap iounmap 212 212 213 - extern void set_iounmap_nonlazy(void); 214 - 215 213 #ifdef __KERNEL__ 216 214 217 215 void memcpy_fromio(void *, const volatile void __iomem *, size_t);
-1
arch/x86/kernel/crash_dump_64.c
··· 37 37 } else 38 38 memcpy(buf, vaddr + offset, csize); 39 39 40 - set_iounmap_nonlazy(); 41 40 iounmap((void __iomem *)vaddr); 42 41 return csize; 43 42 }
+2 -2
fs/binfmt_elf.c
··· 1117 1117 * independently randomized mmap region (0 load_bias 1118 1118 * without MAP_FIXED nor MAP_FIXED_NOREPLACE). 1119 1119 */ 1120 - alignment = maximum_alignment(elf_phdata, elf_ex->e_phnum); 1121 - if (interpreter || alignment > ELF_MIN_ALIGN) { 1120 + if (interpreter) { 1122 1121 load_bias = ELF_ET_DYN_BASE; 1123 1122 if (current->flags & PF_RANDOMIZE) 1124 1123 load_bias += arch_mmap_rnd(); 1124 + alignment = maximum_alignment(elf_phdata, elf_ex->e_phnum); 1125 1125 if (alignment) 1126 1126 load_bias &= ~(alignment - 1); 1127 1127 elf_flags |= MAP_FIXED_NOREPLACE;
+24
include/linux/kfence.h
··· 204 204 */ 205 205 bool __must_check kfence_handle_page_fault(unsigned long addr, bool is_write, struct pt_regs *regs); 206 206 207 + #ifdef CONFIG_PRINTK 208 + struct kmem_obj_info; 209 + /** 210 + * __kfence_obj_info() - fill kmem_obj_info struct 211 + * @kpp: kmem_obj_info to be filled 212 + * @object: the object 213 + * 214 + * Return: 215 + * * false - not a KFENCE object 216 + * * true - a KFENCE object, filled @kpp 217 + * 218 + * Copies information to @kpp for KFENCE objects. 219 + */ 220 + bool __kfence_obj_info(struct kmem_obj_info *kpp, void *object, struct slab *slab); 221 + #endif 222 + 207 223 #else /* CONFIG_KFENCE */ 208 224 209 225 static inline bool is_kfence_address(const void *addr) { return false; } ··· 236 220 { 237 221 return false; 238 222 } 223 + 224 + #ifdef CONFIG_PRINTK 225 + struct kmem_obj_info; 226 + static inline bool __kfence_obj_info(struct kmem_obj_info *kpp, void *object, struct slab *slab) 227 + { 228 + return false; 229 + } 230 + #endif 239 231 240 232 #endif 241 233
+1 -1
kernel/irq_work.c
··· 137 137 if (!irq_work_claim(work)) 138 138 return false; 139 139 140 - kasan_record_aux_stack(work); 140 + kasan_record_aux_stack_noalloc(work); 141 141 142 142 preempt_disable(); 143 143 if (cpu != smp_processor_id()) {
+5 -5
mm/compaction.c
··· 26 26 #include "internal.h" 27 27 28 28 #ifdef CONFIG_COMPACTION 29 + /* 30 + * Fragmentation score check interval for proactive compaction purposes. 31 + */ 32 + #define HPAGE_FRAG_CHECK_INTERVAL_MSEC (500) 33 + 29 34 static inline void count_compact_event(enum vm_event_item item) 30 35 { 31 36 count_vm_event(item); ··· 54 49 #define block_end_pfn(pfn, order) ALIGN((pfn) + 1, 1UL << (order)) 55 50 #define pageblock_start_pfn(pfn) block_start_pfn(pfn, pageblock_order) 56 51 #define pageblock_end_pfn(pfn) block_end_pfn(pfn, pageblock_order) 57 - 58 - /* 59 - * Fragmentation score check interval for proactive compaction purposes. 60 - */ 61 - static const unsigned int HPAGE_FRAG_CHECK_INTERVAL_MSEC = 500; 62 52 63 53 /* 64 54 * Page order with-respect-to which proactive compaction
-6
mm/filemap.c
··· 1063 1063 init_waitqueue_head(&folio_wait_table[i]); 1064 1064 1065 1065 page_writeback_init(); 1066 - 1067 - /* 1068 - * tmpfs uses the ZERO_PAGE for reading holes: it is up-to-date, 1069 - * and splice's page_cache_pipe_buf_confirm() needs to see that. 1070 - */ 1071 - SetPageUptodate(ZERO_PAGE(0)); 1072 1066 } 1073 1067 1074 1068 /*
+10 -7
mm/hugetlb.c
··· 3475 3475 { 3476 3476 int nr_nodes, node; 3477 3477 struct page *page; 3478 - int rc = 0; 3479 3478 3480 3479 lockdep_assert_held(&hugetlb_lock); 3481 3480 ··· 3485 3486 } 3486 3487 3487 3488 for_each_node_mask_to_free(h, nr_nodes, node, nodes_allowed) { 3488 - if (!list_empty(&h->hugepage_freelists[node])) { 3489 - page = list_entry(h->hugepage_freelists[node].next, 3490 - struct page, lru); 3491 - rc = demote_free_huge_page(h, page); 3492 - break; 3489 + list_for_each_entry(page, &h->hugepage_freelists[node], lru) { 3490 + if (PageHWPoison(page)) 3491 + continue; 3492 + 3493 + return demote_free_huge_page(h, page); 3493 3494 } 3494 3495 } 3495 3496 3496 - return rc; 3497 + /* 3498 + * Only way to get here is if all pages on free lists are poisoned. 3499 + * Return -EBUSY so that caller will not retry. 3500 + */ 3501 + return -EBUSY; 3497 3502 } 3498 3503 3499 3504 #define HSTATE_ATTR_RO(_name) \
+3 -2
mm/kasan/hw_tags.c
··· 336 336 337 337 #endif 338 338 339 - #if IS_ENABLED(CONFIG_KASAN_KUNIT_TEST) 340 - 341 339 void kasan_enable_tagging(void) 342 340 { 343 341 if (kasan_arg_mode == KASAN_ARG_MODE_ASYNC) ··· 345 347 else 346 348 hw_enable_tagging_sync(); 347 349 } 350 + 351 + #if IS_ENABLED(CONFIG_KASAN_KUNIT_TEST) 352 + 348 353 EXPORT_SYMBOL_GPL(kasan_enable_tagging); 349 354 350 355 void kasan_force_async_fault(void)
+6 -4
mm/kasan/kasan.h
··· 355 355 #define hw_set_mem_tag_range(addr, size, tag, init) \ 356 356 arch_set_mem_tag_range((addr), (size), (tag), (init)) 357 357 358 + void kasan_enable_tagging(void); 359 + 358 360 #else /* CONFIG_KASAN_HW_TAGS */ 359 361 360 362 #define hw_enable_tagging_sync() 361 363 #define hw_enable_tagging_async() 362 364 #define hw_enable_tagging_asymm() 363 365 366 + static inline void kasan_enable_tagging(void) { } 367 + 364 368 #endif /* CONFIG_KASAN_HW_TAGS */ 365 369 366 370 #if defined(CONFIG_KASAN_HW_TAGS) && IS_ENABLED(CONFIG_KASAN_KUNIT_TEST) 367 371 368 - void kasan_enable_tagging(void); 369 372 void kasan_force_async_fault(void); 370 373 371 - #else /* CONFIG_KASAN_HW_TAGS || CONFIG_KASAN_KUNIT_TEST */ 374 + #else /* CONFIG_KASAN_HW_TAGS && CONFIG_KASAN_KUNIT_TEST */ 372 375 373 - static inline void kasan_enable_tagging(void) { } 374 376 static inline void kasan_force_async_fault(void) { } 375 377 376 - #endif /* CONFIG_KASAN_HW_TAGS || CONFIG_KASAN_KUNIT_TEST */ 378 + #endif /* CONFIG_KASAN_HW_TAGS && CONFIG_KASAN_KUNIT_TEST */ 377 379 378 380 #ifdef CONFIG_KASAN_SW_TAGS 379 381 u8 kasan_random_tag(void);
-21
mm/kfence/core.c
··· 231 231 return !KFENCE_WARN_ON(!kfence_protect_page(ALIGN_DOWN(addr, PAGE_SIZE), false)); 232 232 } 233 233 234 - static inline struct kfence_metadata *addr_to_metadata(unsigned long addr) 235 - { 236 - long index; 237 - 238 - /* The checks do not affect performance; only called from slow-paths. */ 239 - 240 - if (!is_kfence_address((void *)addr)) 241 - return NULL; 242 - 243 - /* 244 - * May be an invalid index if called with an address at the edge of 245 - * __kfence_pool, in which case we would report an "invalid access" 246 - * error. 247 - */ 248 - index = (addr - (unsigned long)__kfence_pool) / (PAGE_SIZE * 2) - 1; 249 - if (index < 0 || index >= CONFIG_KFENCE_NUM_OBJECTS) 250 - return NULL; 251 - 252 - return &kfence_metadata[index]; 253 - } 254 - 255 234 static inline unsigned long metadata_to_pageaddr(const struct kfence_metadata *meta) 256 235 { 257 236 unsigned long offset = (meta - kfence_metadata + 1) * PAGE_SIZE * 2;
+21
mm/kfence/kfence.h
··· 96 96 97 97 extern struct kfence_metadata kfence_metadata[CONFIG_KFENCE_NUM_OBJECTS]; 98 98 99 + static inline struct kfence_metadata *addr_to_metadata(unsigned long addr) 100 + { 101 + long index; 102 + 103 + /* The checks do not affect performance; only called from slow-paths. */ 104 + 105 + if (!is_kfence_address((void *)addr)) 106 + return NULL; 107 + 108 + /* 109 + * May be an invalid index if called with an address at the edge of 110 + * __kfence_pool, in which case we would report an "invalid access" 111 + * error. 112 + */ 113 + index = (addr - (unsigned long)__kfence_pool) / (PAGE_SIZE * 2) - 1; 114 + if (index < 0 || index >= CONFIG_KFENCE_NUM_OBJECTS) 115 + return NULL; 116 + 117 + return &kfence_metadata[index]; 118 + } 119 + 99 120 /* KFENCE error types for report generation. */ 100 121 enum kfence_error_type { 101 122 KFENCE_ERROR_OOB, /* Detected a out-of-bounds access. */
+47
mm/kfence/report.c
··· 273 273 /* We encountered a memory safety error, taint the kernel! */ 274 274 add_taint(TAINT_BAD_PAGE, LOCKDEP_STILL_OK); 275 275 } 276 + 277 + #ifdef CONFIG_PRINTK 278 + static void kfence_to_kp_stack(const struct kfence_track *track, void **kp_stack) 279 + { 280 + int i, j; 281 + 282 + i = get_stack_skipnr(track->stack_entries, track->num_stack_entries, NULL); 283 + for (j = 0; i < track->num_stack_entries && j < KS_ADDRS_COUNT; ++i, ++j) 284 + kp_stack[j] = (void *)track->stack_entries[i]; 285 + if (j < KS_ADDRS_COUNT) 286 + kp_stack[j] = NULL; 287 + } 288 + 289 + bool __kfence_obj_info(struct kmem_obj_info *kpp, void *object, struct slab *slab) 290 + { 291 + struct kfence_metadata *meta = addr_to_metadata((unsigned long)object); 292 + unsigned long flags; 293 + 294 + if (!meta) 295 + return false; 296 + 297 + /* 298 + * If state is UNUSED at least show the pointer requested; the rest 299 + * would be garbage data. 300 + */ 301 + kpp->kp_ptr = object; 302 + 303 + /* Requesting info an a never-used object is almost certainly a bug. */ 304 + if (WARN_ON(meta->state == KFENCE_OBJECT_UNUSED)) 305 + return true; 306 + 307 + raw_spin_lock_irqsave(&meta->lock, flags); 308 + 309 + kpp->kp_slab = slab; 310 + kpp->kp_slab_cache = meta->cache; 311 + kpp->kp_objp = (void *)meta->addr; 312 + kfence_to_kp_stack(&meta->alloc_track, kpp->kp_stack); 313 + if (meta->state == KFENCE_OBJECT_FREED) 314 + kfence_to_kp_stack(&meta->free_track, kpp->kp_free_stack); 315 + /* get_stack_skipnr() ensures the first entry is outside allocator. */ 316 + kpp->kp_ret = kpp->kp_stack[0]; 317 + 318 + raw_spin_unlock_irqrestore(&meta->lock, flags); 319 + 320 + return true; 321 + } 322 + #endif
+4 -4
mm/kmemleak.c
··· 1132 1132 void __ref kmemleak_alloc_phys(phys_addr_t phys, size_t size, int min_count, 1133 1133 gfp_t gfp) 1134 1134 { 1135 - if (!IS_ENABLED(CONFIG_HIGHMEM) || PHYS_PFN(phys) < max_low_pfn) 1135 + if (PHYS_PFN(phys) >= min_low_pfn && PHYS_PFN(phys) < max_low_pfn) 1136 1136 kmemleak_alloc(__va(phys), size, min_count, gfp); 1137 1137 } 1138 1138 EXPORT_SYMBOL(kmemleak_alloc_phys); ··· 1146 1146 */ 1147 1147 void __ref kmemleak_free_part_phys(phys_addr_t phys, size_t size) 1148 1148 { 1149 - if (!IS_ENABLED(CONFIG_HIGHMEM) || PHYS_PFN(phys) < max_low_pfn) 1149 + if (PHYS_PFN(phys) >= min_low_pfn && PHYS_PFN(phys) < max_low_pfn) 1150 1150 kmemleak_free_part(__va(phys), size); 1151 1151 } 1152 1152 EXPORT_SYMBOL(kmemleak_free_part_phys); ··· 1158 1158 */ 1159 1159 void __ref kmemleak_not_leak_phys(phys_addr_t phys) 1160 1160 { 1161 - if (!IS_ENABLED(CONFIG_HIGHMEM) || PHYS_PFN(phys) < max_low_pfn) 1161 + if (PHYS_PFN(phys) >= min_low_pfn && PHYS_PFN(phys) < max_low_pfn) 1162 1162 kmemleak_not_leak(__va(phys)); 1163 1163 } 1164 1164 EXPORT_SYMBOL(kmemleak_not_leak_phys); ··· 1170 1170 */ 1171 1171 void __ref kmemleak_ignore_phys(phys_addr_t phys) 1172 1172 { 1173 - if (!IS_ENABLED(CONFIG_HIGHMEM) || PHYS_PFN(phys) < max_low_pfn) 1173 + if (PHYS_PFN(phys) >= min_low_pfn && PHYS_PFN(phys) < max_low_pfn) 1174 1174 kmemleak_ignore(__va(phys)); 1175 1175 } 1176 1176 EXPORT_SYMBOL(kmemleak_ignore_phys);
+1 -1
mm/page_alloc.c
··· 6131 6131 do { 6132 6132 zone_type--; 6133 6133 zone = pgdat->node_zones + zone_type; 6134 - if (managed_zone(zone)) { 6134 + if (populated_zone(zone)) { 6135 6135 zoneref_set_zone(zone, &zonerefs[nr_zones++]); 6136 6136 check_highest_zone(zone_type); 6137 6137 }
-54
mm/page_io.c
··· 51 51 bio_put(bio); 52 52 } 53 53 54 - static void swap_slot_free_notify(struct page *page) 55 - { 56 - struct swap_info_struct *sis; 57 - struct gendisk *disk; 58 - swp_entry_t entry; 59 - 60 - /* 61 - * There is no guarantee that the page is in swap cache - the software 62 - * suspend code (at least) uses end_swap_bio_read() against a non- 63 - * swapcache page. So we must check PG_swapcache before proceeding with 64 - * this optimization. 65 - */ 66 - if (unlikely(!PageSwapCache(page))) 67 - return; 68 - 69 - sis = page_swap_info(page); 70 - if (data_race(!(sis->flags & SWP_BLKDEV))) 71 - return; 72 - 73 - /* 74 - * The swap subsystem performs lazy swap slot freeing, 75 - * expecting that the page will be swapped out again. 76 - * So we can avoid an unnecessary write if the page 77 - * isn't redirtied. 78 - * This is good for real swap storage because we can 79 - * reduce unnecessary I/O and enhance wear-leveling 80 - * if an SSD is used as the as swap device. 81 - * But if in-memory swap device (eg zram) is used, 82 - * this causes a duplicated copy between uncompressed 83 - * data in VM-owned memory and compressed data in 84 - * zram-owned memory. So let's free zram-owned memory 85 - * and make the VM-owned decompressed page *dirty*, 86 - * so the page should be swapped out somewhere again if 87 - * we again wish to reclaim it. 88 - */ 89 - disk = sis->bdev->bd_disk; 90 - entry.val = page_private(page); 91 - if (disk->fops->swap_slot_free_notify && __swap_count(entry) == 1) { 92 - unsigned long offset; 93 - 94 - offset = swp_offset(entry); 95 - 96 - SetPageDirty(page); 97 - disk->fops->swap_slot_free_notify(sis->bdev, 98 - offset); 99 - } 100 - } 101 - 102 54 static void end_swap_bio_read(struct bio *bio) 103 55 { 104 56 struct page *page = bio_first_page_all(bio); ··· 66 114 } 67 115 68 116 SetPageUptodate(page); 69 - swap_slot_free_notify(page); 70 117 out: 71 118 unlock_page(page); 72 119 WRITE_ONCE(bio->bi_private, NULL); ··· 345 394 if (sis->flags & SWP_SYNCHRONOUS_IO) { 346 395 ret = bdev_read_page(sis->bdev, swap_page_sector(page), page); 347 396 if (!ret) { 348 - if (trylock_page(page)) { 349 - swap_slot_free_notify(page); 350 - unlock_page(page); 351 - } 352 - 353 397 count_vm_event(PSWPIN); 354 398 goto out; 355 399 }
+17
mm/secretmem.c
··· 158 158 .isolate_page = secretmem_isolate_page, 159 159 }; 160 160 161 + static int secretmem_setattr(struct user_namespace *mnt_userns, 162 + struct dentry *dentry, struct iattr *iattr) 163 + { 164 + struct inode *inode = d_inode(dentry); 165 + unsigned int ia_valid = iattr->ia_valid; 166 + 167 + if ((ia_valid & ATTR_SIZE) && inode->i_size) 168 + return -EINVAL; 169 + 170 + return simple_setattr(mnt_userns, dentry, iattr); 171 + } 172 + 173 + static const struct inode_operations secretmem_iops = { 174 + .setattr = secretmem_setattr, 175 + }; 176 + 161 177 static struct vfsmount *secretmem_mnt; 162 178 163 179 static struct file *secretmem_file_create(unsigned long flags) ··· 193 177 mapping_set_gfp_mask(inode->i_mapping, GFP_HIGHUSER); 194 178 mapping_set_unevictable(inode->i_mapping); 195 179 180 + inode->i_op = &secretmem_iops; 196 181 inode->i_mapping->a_ops = &secretmem_aops; 197 182 198 183 /* pretend we are a normal file with zero size */
+20 -11
mm/shmem.c
··· 2513 2513 pgoff_t end_index; 2514 2514 unsigned long nr, ret; 2515 2515 loff_t i_size = i_size_read(inode); 2516 - bool got_page; 2517 2516 2518 2517 end_index = i_size >> PAGE_SHIFT; 2519 2518 if (index > end_index) ··· 2569 2570 */ 2570 2571 if (!offset) 2571 2572 mark_page_accessed(page); 2572 - got_page = true; 2573 + /* 2574 + * Ok, we have the page, and it's up-to-date, so 2575 + * now we can copy it to user space... 2576 + */ 2577 + ret = copy_page_to_iter(page, offset, nr, to); 2578 + put_page(page); 2579 + 2580 + } else if (iter_is_iovec(to)) { 2581 + /* 2582 + * Copy to user tends to be so well optimized, but 2583 + * clear_user() not so much, that it is noticeably 2584 + * faster to copy the zero page instead of clearing. 2585 + */ 2586 + ret = copy_page_to_iter(ZERO_PAGE(0), offset, nr, to); 2573 2587 } else { 2574 - page = ZERO_PAGE(0); 2575 - got_page = false; 2588 + /* 2589 + * But submitting the same page twice in a row to 2590 + * splice() - or others? - can result in confusion: 2591 + * so don't attempt that optimization on pipes etc. 2592 + */ 2593 + ret = iov_iter_zero(nr, to); 2576 2594 } 2577 2595 2578 - /* 2579 - * Ok, we have the page, and it's up-to-date, so 2580 - * now we can copy it to user space... 2581 - */ 2582 - ret = copy_page_to_iter(page, offset, nr, to); 2583 2596 retval += ret; 2584 2597 offset += ret; 2585 2598 index += offset >> PAGE_SHIFT; 2586 2599 offset &= ~PAGE_MASK; 2587 2600 2588 - if (got_page) 2589 - put_page(page); 2590 2601 if (!iov_iter_count(to)) 2591 2602 break; 2592 2603 if (ret < nr) {
+1 -1
mm/slab.c
··· 3665 3665 #endif /* CONFIG_NUMA */ 3666 3666 3667 3667 #ifdef CONFIG_PRINTK 3668 - void kmem_obj_info(struct kmem_obj_info *kpp, void *object, struct slab *slab) 3668 + void __kmem_obj_info(struct kmem_obj_info *kpp, void *object, struct slab *slab) 3669 3669 { 3670 3670 struct kmem_cache *cachep; 3671 3671 unsigned int objnr;
+1 -1
mm/slab.h
··· 868 868 void *kp_stack[KS_ADDRS_COUNT]; 869 869 void *kp_free_stack[KS_ADDRS_COUNT]; 870 870 }; 871 - void kmem_obj_info(struct kmem_obj_info *kpp, void *object, struct slab *slab); 871 + void __kmem_obj_info(struct kmem_obj_info *kpp, void *object, struct slab *slab); 872 872 #endif 873 873 874 874 #ifdef CONFIG_HAVE_HARDENED_USERCOPY_ALLOCATOR
+9
mm/slab_common.c
··· 555 555 } 556 556 EXPORT_SYMBOL_GPL(kmem_valid_obj); 557 557 558 + static void kmem_obj_info(struct kmem_obj_info *kpp, void *object, struct slab *slab) 559 + { 560 + if (__kfence_obj_info(kpp, object, slab)) 561 + return; 562 + __kmem_obj_info(kpp, object, slab); 563 + } 564 + 558 565 /** 559 566 * kmem_dump_obj - Print available slab provenance information 560 567 * @object: slab object for which to find provenance information. ··· 597 590 pr_cont(" slab%s %s", cp, kp.kp_slab_cache->name); 598 591 else 599 592 pr_cont(" slab%s", cp); 593 + if (is_kfence_address(object)) 594 + pr_cont(" (kfence)"); 600 595 if (kp.kp_objp) 601 596 pr_cont(" start %px", kp.kp_objp); 602 597 if (kp.kp_data_offset)
+1 -1
mm/slob.c
··· 463 463 } 464 464 465 465 #ifdef CONFIG_PRINTK 466 - void kmem_obj_info(struct kmem_obj_info *kpp, void *object, struct slab *slab) 466 + void __kmem_obj_info(struct kmem_obj_info *kpp, void *object, struct slab *slab) 467 467 { 468 468 kpp->kp_ptr = object; 469 469 kpp->kp_slab = slab;
+1 -1
mm/slub.c
··· 4312 4312 } 4313 4313 4314 4314 #ifdef CONFIG_PRINTK 4315 - void kmem_obj_info(struct kmem_obj_info *kpp, void *object, struct slab *slab) 4315 + void __kmem_obj_info(struct kmem_obj_info *kpp, void *object, struct slab *slab) 4316 4316 { 4317 4317 void *base; 4318 4318 int __maybe_unused i;
-11
mm/vmalloc.c
··· 1671 1671 /* for per-CPU blocks */ 1672 1672 static void purge_fragmented_blocks_allcpus(void); 1673 1673 1674 - #ifdef CONFIG_X86_64 1675 - /* 1676 - * called before a call to iounmap() if the caller wants vm_area_struct's 1677 - * immediately freed. 1678 - */ 1679 - void set_iounmap_nonlazy(void) 1680 - { 1681 - atomic_long_set(&vmap_lazy_nr, lazy_max_pages()+1); 1682 - } 1683 - #endif /* CONFIG_X86_64 */ 1684 - 1685 1674 /* 1686 1675 * Purges all lazily-freed vmap areas. 1687 1676 */